public object VisitObject(ArmObject obj)
{
OpenBlock();
bool needSeparator = false;
foreach (KeyValuePair <IArmString, ArmElement> entry in obj)
{
if (needSeparator)
{
WriteLine();
}
if (entry.Value is ArmArray array)
{
WriteArray(entry.Key, array);
}
else
{
WriteKeyword(entry.Key);
Write(" ");
_expressionWriter.EnterParens();
entry.Value.RunVisit(this);
_expressionWriter.ExitParens();
}
needSeparator = true;
}
CloseBlock();
return(null);
}
private ArmObject <ArmObject> ReadProperties(JObject propertiesObject)
{
var properties = new ArmObject <ArmObject>();
ReadPropertiesIntoDict(properties, propertiesObject);
return(properties);
}
private ArmObject ReadArmObject(JObject jObject)
{
var armObject = new ArmObject();
foreach (KeyValuePair <string, JToken> entry in jObject)
{
armObject[new ArmStringLiteral(entry.Key)] = ReadValue(entry.Value);
}
return(armObject);
}
public ArmObject <TArmParameter> ConstructParameters(TParameters parameters)
{
IReadOnlyDictionary <TParameter, IReadOnlyList <TParameterName> > referenceTable = CollectReferences(parameters);
var parameterBlock = new ArmObject <TArmParameter>();
TEvaluationState evaluationState = CreateEvaluationState();
foreach (TParameter parameter in GetParameterEvaluationOrder(referenceTable))
{
TArmParameter armParameter = EvaluateParameter(evaluationState, parameter);
parameterBlock[armParameter.ReferenceName] = armParameter;
}
return(parameterBlock);
}
VisitAction IArmVisitor <VisitAction> .VisitObject(ArmObject obj)
{
if (ShouldStop(VisitObject(obj), out VisitAction parentAction))
{
return(parentAction);
}
if (VisitDictionaryAndCheckStop(obj, out parentAction))
{
return(parentAction);
}
return(VisitAction.Continue);
}
public JToken VisitObject(ArmObject obj)
{
var jObj = new JObject();
foreach (KeyValuePair <IArmString, ArmElement> entry in obj)
{
if (entry.Value is null)
{
continue;
}
jObj[entry.Key.ToExpressionString()] = entry.Value.RunVisit(this);
}
return(jObj);
}
public ScriptBlock GetDeparameterizedTemplateScriptBlock(
ScriptBlock scriptBlock,
out ArmObject <ArmParameter> armParameters,
out ArmObject <ArmVariable> armVariables,
out object[] psArgsArray)
{
var ast = (ScriptBlockAst)scriptBlock.Ast;
if (ast.ParamBlock?.Parameters is null)
{
armParameters = null;
armVariables = null;
psArgsArray = null;
return(scriptBlock);
}
(HashSet <string> parameterAsts, HashSet <string> variableAsts, Dictionary <string, int> argsIndex) = CollectParametersToTransform(ast.ParamBlock.Parameters);
// We need to evaluate parameters first
var parametersWithAllowedValues = new HashSet <string>();
armParameters = new PowerShellArmParameterConstructor(parameterAsts, parametersWithAllowedValues)
.ConstructParameters(ast.ParamBlock);
// Construct the list of parameter values to supply for variables
var parameterVariables = new List <PSVariable>(armParameters.Count);
foreach (ArmParameter armParameter in armParameters.Values)
{
var psVar = new PSVariable(armParameter.Name.CoerceToString(), armParameter.GetReference());
parameterVariables.Add(psVar);
}
// Now do variables
armVariables = new PowerShellArmVariableConstructor(variableAsts, parameterVariables)
.ConstructParameters(ast.ParamBlock);
psArgsArray = BuildInvocationArgumentArray(argsIndex, armParameters, armVariables);
// If no ASTs need to be recreated, we can use the old one (and prefer to)
if (parametersWithAllowedValues.Count == 0)
{
return(scriptBlock);
}
return(ConstructScriptBlockWithNewParamBlock(ast, parametersWithAllowedValues));
}
private static bool TryConvertDictionaryToArmObject(IDictionary dictionary, out ArmElement armObject)
{
var obj = new ArmObject();
foreach (DictionaryEntry entry in dictionary)
{
if (!TryConvertToArmString(entry.Key, out IArmString key) ||
!TryConvertToArmElement(entry.Value, out ArmElement value))
{
armObject = null;
return(false);
}
obj[key] = value;
}
armObject = obj;
return(true);
}
private (ArmObject <ArmParameter>, ArmObject <ArmVariable>) ReadParametersAndVariables(JObject templateObject)
{
ArmObject <ArmParameter> parameters = null;
ArmObject <ArmVariable> variables = null;
if (templateObject.TryGetValue("parameters", out JToken parametersValue))
{
parameters = ReadSubobject((JObject)parametersValue, new ArmObject <ArmParameter>(), ReadParameter);
}
if (templateObject.TryGetValue("variables", out JToken variablesValue))
{
variables = ReadSubobject((JObject)variablesValue, new ArmObject <ArmVariable>(), ReadVariable);
}
if (parameters is null && variables is null)
{
return(parameters, variables);
}
TemplateReferenceCollector.ReferenceCollectionResult result = new TemplateReferenceCollector()
.CollectReferences(
((IDictionary <IArmString, ArmVariable>)variables)?.Values,
((IDictionary <IArmString, ArmParameter>)parameters)?.Values);
if (parameters is not null)
{
parameters = new TemplateParserParameterConstructor <ArmParameter, ArmParameterReferenceExpression>(result.Parameters)
.ConstructParameters();
}
if (variables is not null)
{
variables = new TemplateParserParameterConstructor <ArmVariable, ArmVariableReferenceExpression>(result.Variables)
.ConstructParameters();
}
return(parameters, variables);
}
public object VisitObject(ArmObject obj)
{
Write("@{");
bool needSeparator = false;
foreach (KeyValuePair <IArmString, ArmElement> entry in obj)
{
if (needSeparator)
{
Write(";");
}
entry.Key.CoerceToLiteral().RunVisit(this);
Write("=");
entry.Value.RunVisit(this);
needSeparator = true;
}
Write("}");
return(null);
}
private void ReadPropertiesIntoDict(ArmObject <ArmObject> armObject, JObject propertiesObject)
{
foreach (KeyValuePair <string, JToken> entry in propertiesObject)
{
switch (entry.Value)
{
case JObject objectProperty:
armObject[new ArmStringLiteral(entry.Key)] = ReadArmObject(objectProperty);
continue;
case JArray arrayProperty:
armObject[new ArmStringLiteral(entry.Key)] = ReadArmArray(arrayProperty);
continue;
case JValue valueProperty:
armObject[new ArmStringLiteral(entry.Key)] = ReadArmValue(valueProperty);
continue;
default:
throw new ArgumentOutOfRangeException($"Unknown JSON token type '{entry.Value.GetType().FullName}' for property '{entry.Key}'");
}
}
}
public virtual VisitAction VisitObject(ArmObject obj) => DefaultVisit(obj);
private void RandomizeArmStats(ArmObject arm)
{
arm.InitialAccuracy = RandomFunctions.GenerateGaussianByte(Agent.Rng, arm.InitialAccuracy, arm.InitialAccuracy / Agent.Probabilities.ArmStatStandardDivisor);
arm.InitialAtp = RandomFunctions.GenerateGaussianShort(Agent.Rng, arm.InitialAtp, arm.InitialAtp / Agent.Probabilities.ArmStatStandardDivisor);
arm.InitialBullets = RandomFunctions.GenerateGaussianByte(Agent.Rng, arm.InitialBullets, arm.InitialBullets / Agent.Probabilities.ArmStatStandardDivisor);
}
