epic/OpenRA
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Change UpdateRules to account for 20181215 hotfix

Browse Source
This commit is contained in:
Paul Chote
2018-12-31 11:02:45 +00:00
committed by reaperrr
parent d179f6eaae
commit 59f2f5669f
26 changed files with 27 additions and 27 deletions
Download Patch File Download Diff File Expand all files Collapse all files

481
OpenRA.Mods.Common/UpdateRules/Rules/20181215/ExtractHackyAIModules.cs Normal file
View File

@@ -0,0 +1,481 @@
#region Copyright & License Information
/*
* Copyright 2007-2018 The OpenRA Developers (see AUTHORS)
* This file is part of OpenRA, which is free software. It is made
* available to you under the terms of the GNU General Public License
* as published by the Free Software Foundation, either version 3 of
* the License, or (at your option) any later version. For more
* information, see COPYING.
*/
#endregion
using System.Collections.Generic;
using System.Linq;
namespace OpenRA.Mods.Common.UpdateRules.Rules
{
public class ExtractHackyAIModules : UpdateRule
{
public override string Name { get { return "Split HackyAI logic handling to BotModules"; } }
public override string Description
{
get
{
return "Most properties and logic are being moved from HackyAI\n" +
"to *BotModules.";
}
}
readonly List<string> locations = new List<string>();
bool messageShown;
readonly string[] harvesterFields =
{
"HarvesterEnemyAvoidanceRadius", "AssignRolesInterval"
};
readonly string[] supportPowerFields =
{
"SupportPowerDecisions"
};
readonly string[] baseBuilderFields =
{
"BuildingQueues",
"DefenseQueues",
"MinimumExcessPower",
"MaximumExcessPower",
"ExcessPowerIncrement",
"ExcessPowerIncreaseThreshold",
"StructureProductionInactiveDelay",
"StructureProductionActiveDelay",
"StructureProductionRandomBonusDelay",
"StructureProductionResumeDelay",
"MaximumFailedPlacementAttempts",
"MaxResourceCellsToCheck",
"CheckForNewBasesDelay",
"MinBaseRadius",
"MaxBaseRadius",
"MinimumDefenseRadius",
"MaximumDefenseRadius",
"RallyPointScanRadius",
"CheckForWaterRadius",
"WaterTerrainTypes",
"NewProductionCashThreshold",
"BuildingCommonNames",
"BuildingLimits",
"BuildingFractions",
};
readonly string[] copyBaseBuilderFields =
{
"MinBaseRadius",
"MaxBaseRadius",
};
readonly string[] captureManagerFields =
{
"CapturingActorTypes",
"CapturableActorTypes",
"MinimumCaptureDelay",
"MaximumCaptureTargetOptions",
"CheckCaptureTargetsForVisibility",
"CapturableStances",
};
readonly string[] squadManagerFields =
{
"SquadSize",
"SquadSizeRandomBonus",
"AssignRolesInterval",
"RushInterval",
"AttackForceInterval",
"MinimumAttackForceDelay",
"RushAttackScanRadius",
"ProtectUnitScanRadius",
"MaxBaseRadius",
"MaximumDefenseRadius",
"IdleScanRadius",
"DangerScanRadius",
"AttackScanRadius",
"ProtectionScanRadius",
"UnitsCommonNames",
"BuildingCommonNames",
};
readonly string[] squadManagerCommonNames =
{
"ConstructionYard",
"NavalProduction",
};
readonly string[] unitBuilderFields =
{
"IdleBaseUnitsMaximum",
"UnitQueues",
"UnitsToBuild",
"UnitLimits",
};
readonly string[] mcvManagerFields =
{
"AssignRolesInterval",
"MinBaseRadius",
"MaxBaseRadius",
"RestrictMCVDeploymentFallbackToBase",
"UnitsCommonNames",
"BuildingCommonNames",
};
public override IEnumerable<string> AfterUpdate(ModData modData)
{
if (!messageShown)
yield return "You may want to check your AI yamls for possible redundant module entries.\n" +
"Additionally, make sure the Player actor has the ConditionManager trait and add it manually if it doesn't.";
messageShown = true;
if (locations.Any())
yield return "This update rule can only autoamtically update the base HackyAI definitions,\n" +
"not any overrides in other files (unless they redefine Type).\n" +
"You will have to manually check and possibly update the following locations:\n" +
UpdateUtils.FormatMessageList(locations);
locations.Clear();
}
public override IEnumerable<string> UpdateActorNode(ModData modData, MiniYamlNode actorNode)
{
if (actorNode.Key != "Player")
yield break;
var dummyAIs = actorNode.ChildrenMatching("DummyAI");
foreach (var dummyAINode in dummyAIs)
dummyAINode.RenameKey("DummyBot");
var hackyAIRemovals = actorNode.ChildrenMatching("-HackyAI");
foreach (var hackyAIRemovalNode in hackyAIRemovals)
hackyAIRemovalNode.RenameKey("-ModularBot");
var hackyAIs = actorNode.ChildrenMatching("HackyAI", includeRemovals: false);
if (!hackyAIs.Any())
yield break;
var addNodes = new List<MiniYamlNode>();
// We add a 'default' HarvesterBotModule in any case (unless the file doesn't contain any HackyAI base definition),
// and only add more for AIs that define custom values for one of its fields.
var defaultHarvNode = new MiniYamlNode("HarvesterBotModule", "");
// We add a 'default' BuildingRepairBotModule in any case,
// and just don't enable it for AIs that had 'ShouldRepairBuildings: false'.
var defaultRepairNode = new MiniYamlNode("BuildingRepairBotModule", "");
foreach (var hackyAINode in hackyAIs)
{
// HackyAIInfo.Name might contain spaces, so Type is better suited to be used as condition name.
// Type can be 'null' if the place we're updating is overriding the default rules (like a map's rules.yaml).
// If that's the case, it's better to not perform most of the updates on this particular yaml file,
// as most - or more likely all - necessary updates will already have been performed on the base ai yaml.
var aiTypeNode = hackyAINode.LastChildMatching("Type");
var aiType = aiTypeNode != null ? aiTypeNode.NodeValue<string>() : null;
if (aiType == null)
{
locations.Add("{0} ({1})".F(hackyAINode.Key, hackyAINode.Location.Filename));
continue;
}
var conditionString = "enable-" + aiType + "-ai";
var addGrantConditionOnBotOwner = true;
// Don't add GrantConditionOnBotOwner if it's already been added with matching condition
var grantBotConditions = actorNode.ChildrenMatching("GrantConditionOnBotOwner");
foreach (var grant in grantBotConditions)
if (grant.LastChildMatching("Condition").NodeValue<string>() == conditionString)
addGrantConditionOnBotOwner = false;
if (addGrantConditionOnBotOwner)
{
var grantNode = new MiniYamlNode("GrantConditionOnBotOwner@" + aiType, "");
var grantCondition = new MiniYamlNode("Condition", conditionString);
var bot = new MiniYamlNode("Bots", aiType);
grantNode.AddNode(grantCondition);
grantNode.AddNode(bot);
addNodes.Add(grantNode);
}
if (harvesterFields.Any(f => hackyAINode.ChildrenMatching(f).Any()))
{
var harvNode = new MiniYamlNode("HarvesterBotModule@" + aiType, "");
harvNode.AddNode(new MiniYamlNode("RequiresCondition", conditionString));
foreach (var hf in harvesterFields)
{
var fieldNode = hackyAINode.LastChildMatching(hf);
if (fieldNode != null)
{
if (hf == "AssignRolesInterval")
fieldNode.MoveAndRenameNode(hackyAINode, harvNode, "ScanForIdleHarvestersInterval");
else
fieldNode.MoveNode(hackyAINode, harvNode);
}
}
addNodes.Add(harvNode);
}
else
{
// We want the default harvester module to be enabled for every AI that didn't customise one of its fields,
// so we need to update RequiresCondition to be enabled on any of the conditions granted by these AIs,
// but only if the condition hasn't been added yet.
var requiresConditionNode = defaultHarvNode.LastChildMatching("RequiresCondition");
if (requiresConditionNode == null)
defaultHarvNode.AddNode(new MiniYamlNode("RequiresCondition", conditionString));
else
{
var oldValue = requiresConditionNode.NodeValue<string>();
if (oldValue.Contains(conditionString))
continue;
requiresConditionNode.ReplaceValue(oldValue + " || " + conditionString);
}
}
if (supportPowerFields.Any(f => hackyAINode.ChildrenMatching(f).Any()))
{
var spNode = new MiniYamlNode("SupportPowerBotModule@" + aiType, "");
spNode.AddNode(new MiniYamlNode("RequiresCondition", conditionString));
foreach (var spf in supportPowerFields)
{
var fieldNode = hackyAINode.LastChildMatching(spf);
if (fieldNode != null)
fieldNode.MoveAndRenameNode(hackyAINode, spNode, "Decisions");
}
addNodes.Add(spNode);
}
if (baseBuilderFields.Any(f => hackyAINode.ChildrenMatching(f).Any()))
{
var bmNode = new MiniYamlNode("BaseBuilderBotModule@" + aiType, "");
bmNode.AddNode(new MiniYamlNode("RequiresCondition", conditionString));
foreach (var bmf in baseBuilderFields)
{
var fieldNode = hackyAINode.LastChildMatching(bmf);
if (fieldNode != null)
{
if (fieldNode.KeyMatches("BuildingFractions", includeRemovals: false))
{
var buildingNodes = fieldNode.Value.Nodes;
foreach (var n in buildingNodes)
ConvertFractionToInteger(n);
}
if (copyBaseBuilderFields.Any(f => f == bmf))
bmNode.AddNode(fieldNode);
else if (fieldNode.KeyMatches("BuildingCommonNames", includeRemovals: false))
foreach (var n in fieldNode.Value.Nodes)
bmNode.AddNode(n.Key + "Types", n.Value.Value);
else
fieldNode.MoveNode(hackyAINode, bmNode);
}
}
addNodes.Add(bmNode);
}
// We want the default repair module to be enabled for every AI that didn't disable 'ShouldRepairBuildings',
// so we need to update RequiresCondition to be enabled on any of the conditions granted by these AIs,
// but only if the condition hasn't been added yet.
var shouldRepairNode = hackyAINode.LastChildMatching("ShouldRepairBuildings");
var enableBuildingRepair = shouldRepairNode == null || shouldRepairNode.NodeValue<bool>();
if (enableBuildingRepair)
{
var requiresConditionNode = defaultRepairNode.LastChildMatching("RequiresCondition");
if (requiresConditionNode == null)
defaultRepairNode.AddNode(new MiniYamlNode("RequiresCondition", conditionString));
else
{
var oldValue = requiresConditionNode.NodeValue<string>();
if (oldValue.Contains(conditionString))
continue;
requiresConditionNode.ReplaceValue(oldValue + " || " + conditionString);
}
}
if (captureManagerFields.Any(f => hackyAINode.ChildrenMatching(f).Any()))
{
var node = new MiniYamlNode("CaptureManagerBotModule@" + aiType, "");
node.AddNode(new MiniYamlNode("RequiresCondition", conditionString));
foreach (var field in captureManagerFields)
{
var fieldNode = hackyAINode.LastChildMatching(field);
if (fieldNode != null)
fieldNode.MoveNode(hackyAINode, node);
}
addNodes.Add(node);
}
if (squadManagerFields.Any(f => hackyAINode.ChildrenMatching(f).Any()))
{
var node = new MiniYamlNode("SquadManagerBotModule@" + aiType, "");
node.AddNode(new MiniYamlNode("RequiresCondition", conditionString));
foreach (var field in squadManagerFields)
{
var fieldNode = hackyAINode.LastChildMatching(field);
if (fieldNode != null)
{
if (fieldNode.KeyMatches("UnitsCommonNames", includeRemovals: false))
{
var mcvNode = fieldNode.LastChildMatching("Mcv");
var excludeNode = fieldNode.LastChildMatching("ExcludeFromSquads");
var navalUnitsNode = fieldNode.LastChildMatching("NavalUnits");
// In the old code, actors listed under Mcv were also excluded from squads.
// However, Mcv[Types] is moved to McvManagerBotModule now, so we need to add them under ExcludeFromSquads as well.
if (excludeNode == null && mcvNode != null)
node.AddNode("ExcludeFromSquadsTypes", mcvNode.Value.Value);
else if (excludeNode != null && mcvNode != null)
{
var mcvValue = mcvNode.NodeValue<string>();
var excludeValue = excludeNode.NodeValue<string>();
node.AddNode("ExcludeFromSquadsTypes", excludeValue + ", " + mcvValue);
}
if (navalUnitsNode != null)
node.AddNode("NavalUnitsTypes", navalUnitsNode.Value.Value);
}
else if (fieldNode.KeyMatches("BuildingCommonNames", includeRemovals: false))
{
foreach (var b in fieldNode.Value.Nodes)
if (squadManagerCommonNames.Any(f => f == b.Key))
node.AddNode(b.Key + "Types", b.Value.Value);
}
else if (fieldNode.KeyMatches("AssignRolesInterval") || fieldNode.KeyMatches("MaxBaseRadius"))
node.AddNode(fieldNode.Key, fieldNode.Value.Value);
else
fieldNode.MoveNode(hackyAINode, node);
}
}
addNodes.Add(node);
}
if (unitBuilderFields.Any(f => hackyAINode.ChildrenMatching(f).Any()))
{
var node = new MiniYamlNode("UnitBuilderBotModule@" + aiType, "");
node.AddNode(new MiniYamlNode("RequiresCondition", conditionString));
foreach (var field in unitBuilderFields)
{
var fieldNode = hackyAINode.LastChildMatching(field);
if (fieldNode != null)
{
if (fieldNode.KeyMatches("UnitsToBuild", includeRemovals: false))
{
var unitNodes = fieldNode.Value.Nodes;
foreach (var n in unitNodes)
ConvertFractionToInteger(n);
}
fieldNode.MoveNode(hackyAINode, node);
}
}
addNodes.Add(node);
}
if (mcvManagerFields.Any(f => hackyAINode.ChildrenMatching(f).Any()))
{
var node = new MiniYamlNode("McvManagerBotModule@" + aiType, "");
node.AddNode(new MiniYamlNode("RequiresCondition", conditionString));
foreach (var field in mcvManagerFields)
{
var fieldNode = hackyAINode.LastChildMatching(field);
if (fieldNode != null)
{
if (fieldNode.KeyMatches("UnitsCommonNames", includeRemovals: false))
{
var mcvNode = fieldNode.LastChildMatching("Mcv");
if (mcvNode != null)
mcvNode.MoveAndRenameNode(hackyAINode, node, "McvTypes");
// Nothing left that needs UnitCommonNames, so we can finally remove it
hackyAINode.RemoveNode(fieldNode);
}
else if (fieldNode.KeyMatches("BuildingCommonNames", includeRemovals: false))
{
foreach (var n in fieldNode.Value.Nodes)
{
if (n.KeyMatches("VehiclesFactory"))
node.AddNode("McvFactoryTypes", n.Value.Value);
else if (n.KeyMatches("ConstructionYard"))
node.AddNode("ConstructionYardTypes", n.Value.Value);
}
// Nothing left that needs BuildingCommonNames, so we can finally remove it
hackyAINode.RemoveNode(fieldNode);
}
else
fieldNode.MoveNode(hackyAINode, node);
}
}
addNodes.Add(node);
}
hackyAINode.RenameKey("ModularBot");
}
// Only add module if any bot is using/enabling it.
var harvRequiresConditionNode = defaultHarvNode.LastChildMatching("RequiresCondition");
if (harvRequiresConditionNode != null)
addNodes.Add(defaultHarvNode);
// Only add module if any bot is using/enabling it.
var repRequiresConditionNode = defaultRepairNode.LastChildMatching("RequiresCondition");
if (repRequiresConditionNode != null)
addNodes.Add(defaultRepairNode);
foreach (var node in addNodes)
actorNode.AddNode(node);
yield break;
}
void ConvertFractionToInteger(MiniYamlNode node)
{
// Is the value a percentage or a 'real' float?
var isPercentage = node.NodeValue<string>().Contains("%");
if (isPercentage)
{
// Remove '%' first, then remove potential '.' and finally clamp to minimum of 1, unless the old value was really zero
var oldValueAsString = node.NodeValue<string>().Split('%')[0];
var oldValueWasZero = oldValueAsString == "0";
var newValue = oldValueAsString.Split('.')[0];
newValue = !oldValueWasZero && newValue == "0" ? "1" : newValue;
node.ReplaceValue(newValue);
}
else
{
var oldValueAsFloat = node.NodeValue<float>();
var oldValueWasZero = node.NodeValue<string>() == "0" || node.NodeValue<string>() == "0.0";
var newValue = (int)(oldValueAsFloat * 100);
// Clamp to minimum of 1, unless the old value was really zero
newValue = !oldValueWasZero && newValue == 0 ? 1 : newValue;
node.ReplaceValue(newValue.ToString());
}
}
}
}