Index: ps/trunk/binaries/data/mods/public/simulation/components/Mirage.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/components/Mirage.js (revision 25067)
+++ ps/trunk/binaries/data/mods/public/simulation/components/Mirage.js (revision 25068)
@@ -1,233 +1,244 @@
const VIS_HIDDEN = 0;
const VIS_FOGGED = 1;
const VIS_VISIBLE = 2;
function Mirage() {}
Mirage.prototype.Schema =
"Mirage entities replace real entities in the fog-of-war." +
"";
Mirage.prototype.Init = function()
{
- this.player = null;
this.parent = INVALID_ENTITY;
+ this.player = null;
- this.miragedIids = new Set();
-
- this.classesList = [];
-
- this.numBuilders = 0;
- this.buildTime = {};
-
- this.maxHitpoints = null;
- this.hitpoints = null;
- this.repairable = null;
- this.unhealable = null;
- this.injured = null;
-
- this.capturePoints = [];
- this.maxCapturePoints = 0;
-
- this.maxAmount = null;
- this.amount = null;
- this.type = null;
- this.isInfinite = null;
- this.killBeforeGather = null;
- this.maxGatherers = null;
- this.numGatherers = null;
-
- this.traders = null;
- this.marketType = null;
- this.internationalBonus = null;
+ this.miragedIids = new Map();
};
Mirage.prototype.SetParent = function(ent)
{
this.parent = ent;
};
Mirage.prototype.GetParent = function()
{
return this.parent;
};
Mirage.prototype.SetPlayer = function(player)
{
this.player = player;
};
Mirage.prototype.GetPlayer = function()
{
return this.player;
};
Mirage.prototype.Mirages = function(iid)
{
return this.miragedIids.has(iid);
};
+Mirage.prototype.Get = function(iid)
+{
+ return this.miragedIids.get(iid);
+};
+
// ============================
// Parent entity data
-Mirage.prototype.CopyIdentity = function(cmpIdentity)
+function MiragedIdentity(cmpIdentity)
{
- this.miragedIids.add(IID_Identity);
// Mirages don't get identity classes via the template-filter, so that code can query
// identity components via Engine.QueryInterface without having to explicitly check for mirages.
// This is cloned as otherwise we get a reference to Identity's property,
// and that array is deleted when serializing (as it's not seralized), which ends in OOS.
- this.classesList = clone(cmpIdentity.GetClassesList());
+ this.classes = clone(cmpIdentity.GetClassesList());
};
-Mirage.prototype.GetClassesList = function() { return this.classesList; };
+MiragedIdentity.prototype.GetClassesList = function() { return this.classes; };
+
+Mirage.prototype.CopyIdentity = function(cmpIdentity)
+{
+ this.miragedIids.set(IID_Identity, new MiragedIdentity(cmpIdentity));
+};
// Foundation data
-Mirage.prototype.CopyFoundation = function(cmpFoundation)
+function MiragedFoundation(cmpFoundation)
{
- this.miragedIids.add(IID_Foundation);
this.numBuilders = cmpFoundation.GetNumBuilders();
this.buildTime = cmpFoundation.GetBuildTime();
};
-Mirage.prototype.GetNumBuilders = function() { return this.numBuilders; };
-Mirage.prototype.GetBuildTime = function() { return this.buildTime; };
+MiragedFoundation.prototype.GetNumBuilders = function() { return this.numBuilders; };
+MiragedFoundation.prototype.GetBuildTime = function() { return this.buildTime; };
-// Repairable data (numBuilders and buildTime shared with foundation as entities can't have both)
+Mirage.prototype.CopyFoundation = function(cmpFoundation)
+{
+ this.miragedIids.set(IID_Foundation, new MiragedFoundation(cmpFoundation));
+};
-Mirage.prototype.CopyRepairable = function(cmpRepairable)
+// Repairable data
+
+function MiragedRepairable(cmpRepairable)
{
- this.miragedIids.add(IID_Repairable);
this.numBuilders = cmpRepairable.GetNumBuilders();
this.buildTime = cmpRepairable.GetBuildTime();
};
+MiragedRepairable.prototype.GetNumBuilders = function() { return this.numBuilders; };
+MiragedRepairable.prototype.GetBuildTime = function() { return this.buildTime; };
+
+Mirage.prototype.CopyRepairable = function(cmpRepairable)
+{
+ this.miragedIids.set(IID_Repairable, new MiragedRepairable(cmpRepairable));
+};
+
// Health data
-Mirage.prototype.CopyHealth = function(cmpHealth)
+function MiragedHealth(cmpHealth)
{
- this.miragedIids.add(IID_Health);
this.maxHitpoints = cmpHealth.GetMaxHitpoints();
this.hitpoints = cmpHealth.GetHitpoints();
this.repairable = cmpHealth.IsRepairable();
this.injured = cmpHealth.IsInjured();
this.unhealable = cmpHealth.IsUnhealable();
};
-Mirage.prototype.GetMaxHitpoints = function() { return this.maxHitpoints; };
-Mirage.prototype.GetHitpoints = function() { return this.hitpoints; };
-Mirage.prototype.IsRepairable = function() { return this.repairable; };
-Mirage.prototype.IsInjured = function() { return this.injured; };
-Mirage.prototype.IsUnhealable = function() { return this.unhealable; };
+MiragedHealth.prototype.GetMaxHitpoints = function() { return this.maxHitpoints; };
+MiragedHealth.prototype.GetHitpoints = function() { return this.hitpoints; };
+MiragedHealth.prototype.IsRepairable = function() { return this.repairable; };
+MiragedHealth.prototype.IsInjured = function() { return this.injured; };
+MiragedHealth.prototype.IsUnhealable = function() { return this.unhealable; };
+
+Mirage.prototype.CopyHealth = function(cmpHealth)
+{
+ this.miragedIids.set(IID_Health, new MiragedHealth(cmpHealth));
+};
// Capture data
-Mirage.prototype.CopyCapturable = function(cmpCapturable)
+function MiragedCapture(cmpCapturable)
{
- this.miragedIids.add(IID_Capturable);
this.capturePoints = clone(cmpCapturable.GetCapturePoints());
this.maxCapturePoints = cmpCapturable.GetMaxCapturePoints();
+ this.CanCapture = cmpCapturable.CanCapture;
};
-Mirage.prototype.GetMaxCapturePoints = function() { return this.maxCapturePoints; };
-Mirage.prototype.GetCapturePoints = function() { return this.capturePoints; };
+MiragedCapture.prototype.GetCapturePoints = function() { return this.capturePoints; };
+MiragedCapture.prototype.GetMaxCapturePoints = function() { return this.maxCapturePoints; };
-Mirage.prototype.CanCapture = Capturable.prototype.CanCapture;
+Mirage.prototype.CopyCapturable = function(cmpCapturable)
+{
+ this.miragedIids.set(IID_Capturable, new MiragedCapture(cmpCapturable));
+};
// ResourceSupply data
-
-Mirage.prototype.CopyResourceSupply = function(cmpResourceSupply)
+function MiragedResourceSupply(cmpResourceSupply)
{
- this.miragedIids.add(IID_ResourceSupply);
this.maxAmount = cmpResourceSupply.GetMaxAmount();
this.amount = cmpResourceSupply.GetCurrentAmount();
this.type = cmpResourceSupply.GetType();
this.isInfinite = cmpResourceSupply.IsInfinite();
this.killBeforeGather = cmpResourceSupply.GetKillBeforeGather();
this.maxGatherers = cmpResourceSupply.GetMaxGatherers();
this.numGatherers = cmpResourceSupply.GetNumGatherers();
};
-Mirage.prototype.GetMaxAmount = function() { return this.maxAmount; };
-Mirage.prototype.GetCurrentAmount = function() { return this.amount; };
-Mirage.prototype.GetType = function() { return this.type; };
-Mirage.prototype.IsInfinite = function() { return this.isInfinite; };
-Mirage.prototype.GetKillBeforeGather = function() { return this.killBeforeGather; };
-Mirage.prototype.GetMaxGatherers = function() { return this.maxGatherers; };
-Mirage.prototype.GetNumGatherers = function() { return this.numGatherers; };
+MiragedResourceSupply.prototype.GetMaxAmount = function() { return this.maxAmount; };
+MiragedResourceSupply.prototype.GetCurrentAmount = function() { return this.amount; };
+MiragedResourceSupply.prototype.GetType = function() { return this.type; };
+MiragedResourceSupply.prototype.IsInfinite = function() { return this.isInfinite; };
+MiragedResourceSupply.prototype.GetKillBeforeGather = function() { return this.killBeforeGather; };
+MiragedResourceSupply.prototype.GetMaxGatherers = function() { return this.maxGatherers; };
+MiragedResourceSupply.prototype.GetNumGatherers = function() { return this.numGatherers; };
-// Market data
+Mirage.prototype.CopyResourceSupply = function(cmpResourceSupply)
+{
+ this.miragedIids.set(IID_ResourceSupply, new MiragedResourceSupply(cmpResourceSupply));
+};
-Mirage.prototype.CopyMarket = function(cmpMarket)
+// Market data
+function MiragedMarket(cmpMarket, entity, parent, player)
{
- this.miragedIids.add(IID_Market);
+ this.entity = entity;
+ this.parent = parent;
+ this.player = player;
+
this.traders = new Set();
for (let trader of cmpMarket.GetTraders())
{
let cmpTrader = Engine.QueryInterface(trader, IID_Trader);
let cmpOwnership = Engine.QueryInterface(trader, IID_Ownership);
if (!cmpTrader || !cmpOwnership)
{
cmpMarket.RemoveTrader(trader);
continue;
}
if (this.player != cmpOwnership.GetOwner())
continue;
cmpTrader.SwitchMarket(cmpMarket.entity, this.entity);
cmpMarket.RemoveTrader(trader);
this.AddTrader(trader);
}
this.marketType = cmpMarket.GetType();
this.internationalBonus = cmpMarket.GetInternationalBonus();
};
-Mirage.prototype.HasType = function(type) { return this.marketType.has(type); };
-Mirage.prototype.GetInternationalBonus = function() { return this.internationalBonus; };
-Mirage.prototype.AddTrader = function(trader) { this.traders.add(trader); };
-Mirage.prototype.RemoveTrader = function(trader) { this.traders.delete(trader); };
+MiragedMarket.prototype.HasType = function(type) { return this.marketType.has(type); };
+MiragedMarket.prototype.GetInternationalBonus = function() { return this.internationalBonus; };
+MiragedMarket.prototype.AddTrader = function(trader) { this.traders.add(trader); };
+MiragedMarket.prototype.RemoveTrader = function(trader) { this.traders.delete(trader); };
-Mirage.prototype.UpdateTraders = function(msg)
+MiragedMarket.prototype.UpdateTraders = function(msg)
{
let cmpMarket = Engine.QueryInterface(this.parent, IID_Market);
if (!cmpMarket) // The parent market does not exist anymore
{
for (let trader of this.traders)
{
let cmpTrader = Engine.QueryInterface(trader, IID_Trader);
if (cmpTrader)
cmpTrader.RemoveMarket(this.entity);
}
return;
}
// The market becomes visible, switch all traders from the mirage to the market
for (let trader of this.traders)
{
let cmpTrader = Engine.QueryInterface(trader, IID_Trader);
if (!cmpTrader)
continue;
cmpTrader.SwitchMarket(this.entity, cmpMarket.entity);
this.RemoveTrader(trader);
cmpMarket.AddTrader(trader);
}
};
+Mirage.prototype.CopyMarket = function(cmpMarket)
+{
+ this.miragedIids.set(IID_Market, new MiragedMarket(cmpMarket, this.entity, this.parent, this.player));
+};
+
// ============================
Mirage.prototype.OnVisibilityChanged = function(msg)
{
// Mirages get VIS_HIDDEN when the original entity becomes VIS_VISIBLE.
if (msg.player != this.player || msg.newVisibility != VIS_HIDDEN)
return;
if (this.miragedIids.has(IID_Market))
- this.UpdateTraders(msg);
+ this.miragedIids.get(IID_Market).UpdateTraders(msg);
if (this.parent == INVALID_ENTITY)
Engine.DestroyEntity(this.entity);
else
Engine.PostMessage(this.entity, MT_EntityRenamed, { "entity": this.entity, "newentity": this.parent });
};
Engine.RegisterComponentType(IID_Mirage, "Mirage", Mirage);
Index: ps/trunk/binaries/data/mods/public/simulation/helpers/Player.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/helpers/Player.js (revision 25067)
+++ ps/trunk/binaries/data/mods/public/simulation/helpers/Player.js (revision 25068)
@@ -1,407 +1,407 @@
/**
* Used to create player entities prior to reading the rest of a map,
* all other initialization must be done after loading map (terrain/entities).
* DO NOT use other components here, as they may fail unpredictably.
* settings is the object containing settings for this map.
* newPlayers if true will remove old player entities or add new ones until
* the new number of player entities is obtained
* (used when loading a map or when Atlas changes the number of players).
*/
function LoadPlayerSettings(settings, newPlayers)
{
var playerDefaults = Engine.ReadJSONFile("simulation/data/settings/player_defaults.json").PlayerData;
// Default settings
if (!settings)
settings = {};
// Add gaia to simplify iteration
// (if gaia is not already the first civ such as when called from Atlas' ActorViewer)
if (settings.PlayerData && settings.PlayerData[0] &&
(!settings.PlayerData[0].Civ || settings.PlayerData[0].Civ != "gaia"))
settings.PlayerData.unshift(null);
var playerData = settings.PlayerData;
// Disable the AIIinterface when no AI players are present
if (playerData && !playerData.some(v => v && !!v.AI))
Engine.QueryInterface(SYSTEM_ENTITY, IID_AIInterface).Disable();
var cmpPlayerManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_PlayerManager);
var numPlayers = cmpPlayerManager.GetNumPlayers();
var cmpTemplateManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
// Remove existing players or add new ones
if (newPlayers)
{
var settingsNumPlayers = 9; // default 8 players + gaia
if (playerData)
settingsNumPlayers = playerData.length; // includes gaia (see above)
else
warn("Player.js: Setup has no player data - using defaults");
while (settingsNumPlayers > numPlayers)
{
// Add player entity to engine
var entID = Engine.AddEntity(GetPlayerTemplateName(getSetting(playerData, playerDefaults, numPlayers, "Civ")));
var cmpPlayer = Engine.QueryInterface(entID, IID_Player);
if (!cmpPlayer)
throw new Error("Player.js: Error creating player entity " + numPlayers);
cmpPlayerManager.AddPlayer(entID);
++numPlayers;
}
while (settingsNumPlayers < numPlayers)
{
cmpPlayerManager.RemoveLastPlayer();
--numPlayers;
}
}
// Even when no new player, we must check the template compatibility as player template may be civ dependent
for (var i = 0; i < numPlayers; ++i)
{
var template = GetPlayerTemplateName(getSetting(playerData, playerDefaults, i, "Civ"));
var entID = cmpPlayerManager.GetPlayerByID(i);
if (cmpTemplateManager.GetCurrentTemplateName(entID) === template)
continue;
// We need to recreate this player to have the right template
entID = Engine.AddEntity(template);
cmpPlayerManager.ReplacePlayer(i, entID);
}
// Initialize the player data
for (var i = 0; i < numPlayers; ++i)
{
let cmpPlayer = QueryPlayerIDInterface(i);
cmpPlayer.SetName(getSetting(playerData, playerDefaults, i, "Name"));
cmpPlayer.SetCiv(getSetting(playerData, playerDefaults, i, "Civ"));
var color = getSetting(playerData, playerDefaults, i, "Color");
cmpPlayer.SetColor(color.r, color.g, color.b);
// Special case for gaia
if (i == 0)
{
// Gaia should be its own ally.
cmpPlayer.SetAlly(0);
// Gaia is everyone's enemy
for (var j = 1; j < numPlayers; ++j)
cmpPlayer.SetEnemy(j);
continue;
}
// PopulationLimit
{
let maxPopulation =
settings.PlayerData[i].PopulationLimit !== undefined ?
settings.PlayerData[i].PopulationLimit :
settings.PopulationCap !== undefined ?
settings.PopulationCap :
playerDefaults[i].PopulationLimit !== undefined ?
playerDefaults[i].PopulationLimit :
undefined;
if (maxPopulation !== undefined)
cmpPlayer.SetMaxPopulation(maxPopulation);
}
// StartingResources
if (settings.PlayerData[i].Resources !== undefined)
cmpPlayer.SetResourceCounts(settings.PlayerData[i].Resources);
else if (settings.StartingResources)
{
let resourceCounts = cmpPlayer.GetResourceCounts();
let newResourceCounts = {};
for (let resouces in resourceCounts)
newResourceCounts[resouces] = settings.StartingResources;
cmpPlayer.SetResourceCounts(newResourceCounts);
}
else if (playerDefaults[i].Resources !== undefined)
cmpPlayer.SetResourceCounts(playerDefaults[i].Resources);
// StartingTechnologies
{
let startingTechnologies =
settings.PlayerData[i].StartingTechnologies ||
settings.StartingTechnologies ||
playerDefaults[i].StartingTechnologies ||
[];
if (startingTechnologies.length)
cmpPlayer.SetStartingTechnologies(startingTechnologies);
}
// DisabledTechnologies
{
let disabledTechnologies =
settings.PlayerData[i].DisabledTechnologies ||
settings.DisabledTechnologies ||
playerDefaults[i].DisabledTechnologies ||
[];
if (disabledTechnologies.length)
cmpPlayer.SetDisabledTechnologies(disabledTechnologies);
}
// DisabledTemplates
{
let disabledTemplates =
settings.PlayerData[i].DisabledTemplates ||
settings.DisabledTemplates ||
playerDefaults[i].DisabledTemplates ||
[];
if (disabledTemplates.length)
cmpPlayer.SetDisabledTemplates(disabledTemplates);
}
// DisableSpies
if (settings.DisableSpies)
{
cmpPlayer.AddDisabledTechnology("unlock_spies");
cmpPlayer.AddDisabledTemplate("special/spy");
}
// If diplomacy explicitly defined, use that; otherwise use teams
if (getSetting(playerData, playerDefaults, i, "Diplomacy") !== undefined)
cmpPlayer.SetDiplomacy(getSetting(playerData, playerDefaults, i, "Diplomacy"));
else
{
// Init diplomacy
var myTeam = getSetting(playerData, playerDefaults, i, "Team");
// Set all but self as enemies as SetTeam takes care of allies
for (var j = 0; j < numPlayers; ++j)
{
if (i == j)
cmpPlayer.SetAlly(j);
else
cmpPlayer.SetEnemy(j);
}
cmpPlayer.SetTeam(myTeam === undefined ? -1 : myTeam);
}
cmpPlayer.SetFormations(
getSetting(playerData, playerDefaults, i, "Formations") ||
Engine.ReadJSONFile("simulation/data/civs/" + cmpPlayer.GetCiv() + ".json").Formations);
var startCam = getSetting(playerData, playerDefaults, i, "StartingCamera");
if (startCam !== undefined)
cmpPlayer.SetStartingCamera(startCam.Position, startCam.Rotation);
}
// NOTE: We need to do the team locking here, as otherwise
// SetTeam can't ally the players.
if (settings.LockTeams)
for (let i = 0; i < numPlayers; ++i)
QueryPlayerIDInterface(i).SetLockTeams(true);
}
// Get a setting if it exists or return default
function getSetting(settings, defaults, idx, property)
{
if (settings && settings[idx] && (property in settings[idx]))
return settings[idx][property];
// Use defaults
if (defaults && defaults[idx] && (property in defaults[idx]))
return defaults[idx][property];
return undefined;
}
function GetPlayerTemplateName(civ)
{
let path = "special/player/player";
if (Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager).TemplateExists(path + "_" + civ))
return path + "_" + civ;
return path;
}
/**
* @param id An entity's ID
* @returns The entity ID of the owner player (not his player ID) or ent if ent is a player entity.
*/
function QueryOwnerEntityID(ent)
{
let cmpPlayer = Engine.QueryInterface(ent, IID_Player);
if (cmpPlayer)
return ent;
let cmpOwnership = Engine.QueryInterface(ent, IID_Ownership);
if (!cmpOwnership)
return null;
let owner = cmpOwnership.GetOwner();
if (owner == INVALID_PLAYER)
return null;
let cmpPlayerManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_PlayerManager);
if (!cmpPlayerManager)
return null;
return cmpPlayerManager.GetPlayerByID(owner);
}
/**
* Similar to Engine.QueryInterface but applies to the player entity
* that owns the given entity.
* iid is typically IID_Player.
*/
function QueryOwnerInterface(ent, iid = IID_Player)
{
var cmpOwnership = Engine.QueryInterface(ent, IID_Ownership);
if (!cmpOwnership)
return null;
var owner = cmpOwnership.GetOwner();
if (owner == INVALID_PLAYER)
return null;
return QueryPlayerIDInterface(owner, iid);
}
/**
* Similar to Engine.QueryInterface but applies to the player entity
* with the given ID number.
* iid is typically IID_Player.
*/
function QueryPlayerIDInterface(id, iid = IID_Player)
{
var cmpPlayerManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_PlayerManager);
var playerEnt = cmpPlayerManager.GetPlayerByID(id);
if (!playerEnt)
return null;
return Engine.QueryInterface(playerEnt, iid);
}
/**
* Similar to Engine.QueryInterface but first checks if the entity
* mirages the interface.
*/
function QueryMiragedInterface(ent, iid)
{
- var cmp = Engine.QueryInterface(ent, IID_Mirage);
- if (cmp && !cmp.Mirages(iid))
+ let cmpMirage = Engine.QueryInterface(ent, IID_Mirage);
+ if (cmpMirage && !cmpMirage.Mirages(iid))
return null;
- else if (!cmp)
- cmp = Engine.QueryInterface(ent, iid);
+ else if (!cmpMirage)
+ return Engine.QueryInterface(ent, iid);
- return cmp;
+ return cmpMirage.Get(iid);
}
/**
* Similar to Engine.QueryInterface, but checks for all interfaces
* implementing a builder list (currently Foundation and Repairable)
* TODO Foundation and Repairable could both implement a BuilderList component
*/
function QueryBuilderListInterface(ent)
{
return Engine.QueryInterface(ent, IID_Foundation) || Engine.QueryInterface(ent, IID_Repairable);
}
/**
* Returns true if the entity 'target' is owned by an ally of
* the owner of 'entity'.
*/
function IsOwnedByAllyOfEntity(entity, target)
{
return IsOwnedByEntityHelper(entity, target, "IsAlly");
}
function IsOwnedByMutualAllyOfEntity(entity, target)
{
return IsOwnedByEntityHelper(entity, target, "IsMutualAlly");
}
function IsOwnedByEntityHelper(entity, target, check)
{
// Figure out which player controls us
let owner = 0;
let cmpOwnership = Engine.QueryInterface(entity, IID_Ownership);
if (cmpOwnership)
owner = cmpOwnership.GetOwner();
// Figure out which player controls the target entity
let targetOwner = 0;
let cmpOwnershipTarget = Engine.QueryInterface(target, IID_Ownership);
if (cmpOwnershipTarget)
targetOwner = cmpOwnershipTarget.GetOwner();
let cmpPlayer = QueryPlayerIDInterface(owner);
return cmpPlayer && cmpPlayer[check](targetOwner);
}
/**
* Returns true if the entity 'target' is owned by player
*/
function IsOwnedByPlayer(player, target)
{
var cmpOwnershipTarget = Engine.QueryInterface(target, IID_Ownership);
return cmpOwnershipTarget && player == cmpOwnershipTarget.GetOwner();
}
function IsOwnedByGaia(target)
{
return IsOwnedByPlayer(0, target);
}
/**
* Returns true if the entity 'target' is owned by an ally of player
*/
function IsOwnedByAllyOfPlayer(player, target)
{
return IsOwnedByHelper(player, target, "IsAlly");
}
function IsOwnedByMutualAllyOfPlayer(player, target)
{
return IsOwnedByHelper(player, target, "IsMutualAlly");
}
function IsOwnedByNeutralOfPlayer(player, target)
{
return IsOwnedByHelper(player, target, "IsNeutral");
}
function IsOwnedByEnemyOfPlayer(player, target)
{
return IsOwnedByHelper(player, target, "IsEnemy");
}
function IsOwnedByHelper(player, target, check)
{
let targetOwner = 0;
let cmpOwnershipTarget = Engine.QueryInterface(target, IID_Ownership);
if (cmpOwnershipTarget)
targetOwner = cmpOwnershipTarget.GetOwner();
let cmpPlayer = QueryPlayerIDInterface(player);
return cmpPlayer && cmpPlayer[check](targetOwner);
}
Engine.RegisterGlobal("LoadPlayerSettings", LoadPlayerSettings);
Engine.RegisterGlobal("QueryOwnerEntityID", QueryOwnerEntityID);
Engine.RegisterGlobal("QueryOwnerInterface", QueryOwnerInterface);
Engine.RegisterGlobal("QueryPlayerIDInterface", QueryPlayerIDInterface);
Engine.RegisterGlobal("QueryMiragedInterface", QueryMiragedInterface);
Engine.RegisterGlobal("QueryBuilderListInterface", QueryBuilderListInterface);
Engine.RegisterGlobal("IsOwnedByAllyOfEntity", IsOwnedByAllyOfEntity);
Engine.RegisterGlobal("IsOwnedByMutualAllyOfEntity", IsOwnedByMutualAllyOfEntity);
Engine.RegisterGlobal("IsOwnedByPlayer", IsOwnedByPlayer);
Engine.RegisterGlobal("IsOwnedByGaia", IsOwnedByGaia);
Engine.RegisterGlobal("IsOwnedByAllyOfPlayer", IsOwnedByAllyOfPlayer);
Engine.RegisterGlobal("IsOwnedByMutualAllyOfPlayer", IsOwnedByMutualAllyOfPlayer);
Engine.RegisterGlobal("IsOwnedByNeutralOfPlayer", IsOwnedByNeutralOfPlayer);
Engine.RegisterGlobal("IsOwnedByEnemyOfPlayer", IsOwnedByEnemyOfPlayer);