Index: ps/trunk/binaries/data/mods/public/simulation/components/Mirage.js =================================================================== --- ps/trunk/binaries/data/mods/public/simulation/components/Mirage.js (revision 25075) +++ ps/trunk/binaries/data/mods/public/simulation/components/Mirage.js (revision 25076) @@ -1,244 +1,233 @@ 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.parent = INVALID_ENTITY; this.player = null; + this.parent = INVALID_ENTITY; + + this.miragedIids = new Set(); - this.miragedIids = new Map(); + 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; }; 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 -function MiragedIdentity(cmpIdentity) +Mirage.prototype.CopyIdentity = function(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.classes = clone(cmpIdentity.GetClassesList()); + this.classesList = clone(cmpIdentity.GetClassesList()); }; -MiragedIdentity.prototype.GetClassesList = function() { return this.classes; }; - -Mirage.prototype.CopyIdentity = function(cmpIdentity) -{ - this.miragedIids.set(IID_Identity, new MiragedIdentity(cmpIdentity)); -}; +Mirage.prototype.GetClassesList = function() { return this.classesList; }; // Foundation data -function MiragedFoundation(cmpFoundation) +Mirage.prototype.CopyFoundation = function(cmpFoundation) { + this.miragedIids.add(IID_Foundation); this.numBuilders = cmpFoundation.GetNumBuilders(); this.buildTime = cmpFoundation.GetBuildTime(); }; -MiragedFoundation.prototype.GetNumBuilders = function() { return this.numBuilders; }; -MiragedFoundation.prototype.GetBuildTime = function() { return this.buildTime; }; - -Mirage.prototype.CopyFoundation = function(cmpFoundation) -{ - this.miragedIids.set(IID_Foundation, new MiragedFoundation(cmpFoundation)); -}; +Mirage.prototype.GetNumBuilders = function() { return this.numBuilders; }; +Mirage.prototype.GetBuildTime = function() { return this.buildTime; }; -// Repairable data +// Repairable data (numBuilders and buildTime shared with foundation as entities can't have both) -function MiragedRepairable(cmpRepairable) +Mirage.prototype.CopyRepairable = function(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 -function MiragedHealth(cmpHealth) +Mirage.prototype.CopyHealth = function(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(); }; -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)); -}; +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; }; // Capture data -function MiragedCapture(cmpCapturable) +Mirage.prototype.CopyCapturable = function(cmpCapturable) { + this.miragedIids.add(IID_Capturable); this.capturePoints = clone(cmpCapturable.GetCapturePoints()); this.maxCapturePoints = cmpCapturable.GetMaxCapturePoints(); - this.CanCapture = cmpCapturable.CanCapture; }; -MiragedCapture.prototype.GetCapturePoints = function() { return this.capturePoints; }; -MiragedCapture.prototype.GetMaxCapturePoints = function() { return this.maxCapturePoints; }; +Mirage.prototype.GetMaxCapturePoints = function() { return this.maxCapturePoints; }; +Mirage.prototype.GetCapturePoints = function() { return this.capturePoints; }; -Mirage.prototype.CopyCapturable = function(cmpCapturable) -{ - this.miragedIids.set(IID_Capturable, new MiragedCapture(cmpCapturable)); -}; +Mirage.prototype.CanCapture = Capturable.prototype.CanCapture; // ResourceSupply data -function MiragedResourceSupply(cmpResourceSupply) + +Mirage.prototype.CopyResourceSupply = function(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(); }; -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; }; - -Mirage.prototype.CopyResourceSupply = function(cmpResourceSupply) -{ - this.miragedIids.set(IID_ResourceSupply, new MiragedResourceSupply(cmpResourceSupply)); -}; +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; }; // Market data -function MiragedMarket(cmpMarket, entity, parent, player) -{ - this.entity = entity; - this.parent = parent; - this.player = player; +Mirage.prototype.CopyMarket = function(cmpMarket) +{ + this.miragedIids.add(IID_Market); 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(); }; -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.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.UpdateTraders = function(msg) +Mirage.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.miragedIids.get(IID_Market).UpdateTraders(msg); + this.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 25075) +++ ps/trunk/binaries/data/mods/public/simulation/helpers/Player.js (revision 25076) @@ -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) { - let cmpMirage = Engine.QueryInterface(ent, IID_Mirage); - if (cmpMirage && !cmpMirage.Mirages(iid)) + var cmp = Engine.QueryInterface(ent, IID_Mirage); + if (cmp && !cmp.Mirages(iid)) return null; - else if (!cmpMirage) - return Engine.QueryInterface(ent, iid); + else if (!cmp) + cmp = Engine.QueryInterface(ent, iid); - return cmpMirage.Get(iid); + return cmp; } /** * 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);