/// <summary>
/// Copy Function
/// </summary>
/// <returns>new copy</returns>
public IFunctions ShallowCopy()
{
IFunctions newAOF = new Functions();
foreach (Requirements aor in this.Requirements)
{
Requirements newAOR = new Requirements();
newAOR.ChildOperator = aor.ChildOperator;
newAOR.Operator = aor.Operator;
newAOR.Statnumber = aor.Statnumber;
newAOR.Target = aor.Target;
newAOR.Value = aor.Value;
newAOF.Requirements.Add(newAOR);
}
foreach (object ob in this.Arguments.Values)
{
if (ob.GetType() == typeof(string))
{
string z = (string)ob;
newAOF.Arguments.Values.Add(z);
}
if (ob.GetType() == typeof(int))
{
int i = (int)ob;
newAOF.Arguments.Values.Add(i);
}
if (ob.GetType() == typeof(Single))
{
float s = (Single)ob;
newAOF.Arguments.Values.Add(s);
}
}
newAOF.dolocalstats = this.dolocalstats;
newAOF.FunctionType = this.FunctionType;
newAOF.Target = this.Target;
newAOF.TickCount = this.TickCount;
newAOF.TickInterval = this.TickInterval;
return newAOF;
}
/// <summary>
/// </summary>
/// Methods to do:
/// Read Item
/// Write Item
/// Return Dynel Item (placing on the ground)
/// <returns>
/// </returns>
public NanoFormula ShallowCopy()
{
NanoFormula nanoFormula = new NanoFormula();
nanoFormula.ID = this.ID;
foreach (KeyValuePair<int, int> nanoFormulaAttribute in this.Attack)
{
nanoFormula.Attack.Add(nanoFormulaAttribute.Key, nanoFormulaAttribute.Value);
}
foreach (KeyValuePair<int, int> nanoFormulaAttribute in this.Defend)
{
nanoFormula.Defend.Add(nanoFormulaAttribute.Key, nanoFormulaAttribute.Value);
}
foreach (KeyValuePair<int, int> nanoFormulaAttribute in this.Stats)
{
nanoFormula.Stats.Add(nanoFormulaAttribute.Key, nanoFormulaAttribute.Value);
}
foreach (Events aoEvents in this.Events)
{
Events newEvent = new Events();
foreach (Functions aoFunctions in aoEvents.Functions)
{
Functions newAOFunctions = new Functions();
foreach (Requirements aor in aoFunctions.Requirements)
{
Requirements newRequirement = new Requirements();
newRequirement.ChildOperator = aor.ChildOperator;
newRequirement.Operator = aor.Operator;
newRequirement.Statnumber = aor.Statnumber;
newRequirement.Target = aor.Target;
newRequirement.Value = aor.Value;
newAOFunctions.Requirements.Add(newRequirement);
}
foreach (object argument in aoFunctions.Arguments.Values)
{
if (argument.GetType() == typeof(string))
{
string z = (string)argument;
newAOFunctions.Arguments.Values.Add(z);
}
if (argument.GetType() == typeof(int))
{
int i = (int)argument;
newAOFunctions.Arguments.Values.Add(i);
}
if (argument.GetType() == typeof(Single))
{
float s = (Single)argument;
newAOFunctions.Arguments.Values.Add(s);
}
}
newAOFunctions.dolocalstats = aoFunctions.dolocalstats;
newAOFunctions.FunctionType = aoFunctions.FunctionType;
newAOFunctions.Target = aoFunctions.Target;
newAOFunctions.TickCount = aoFunctions.TickCount;
newAOFunctions.TickInterval = aoFunctions.TickInterval;
newEvent.Functions.Add(newAOFunctions);
}
newEvent.EventType = aoEvents.EventType;
nanoFormula.Events.Add(newEvent);
}
nanoFormula.flags = this.flags;
nanoFormula.Instance = this.Instance;
nanoFormula.ItemType = this.ItemType;
return nanoFormula;
}
/// <summary>
/// </summary>
/// <param name="rreqs">
/// </param>
/// <returns>
/// </returns>
public List<Requirements> ParseReqs(List<rawreqs> rreqs)
{
int numreqs = rreqs.Count;
List<Requirements> output = new List<Requirements>();
for (int i = 0; i < numreqs; i++)
{
rawreqs rr = rreqs[i];
Requirements aor = new Requirements();
aor.Target = 0x13;
aor.Statnumber = rr.stat;
aor.Operator = rr.ops;
aor.Value = rr.val;
aor.ChildOperator = 255;
if ((i < numreqs - 1)
&& ((aor.Operator == 0x12) || (aor.Operator == 0x13) || (aor.Operator == 0x1a)
|| (aor.Operator == 0x1b) || (aor.Operator == 0x1c) || (aor.Operator == 0x1d)
|| (aor.Operator == 0x1e) || (aor.Operator == 0x25) || (aor.Operator == 0x64)
|| (aor.Operator == 110)))
{
aor.Target = aor.Operator;
i++;
rr = rreqs[i];
aor.Statnumber = rr.stat;
aor.Value = rr.val;
aor.Operator = rr.ops;
}
if (!((i >= numreqs - 1) || (numreqs == 2)))
{
int anum = rreqs[i + 1].stat;
int aval = rreqs[i + 1].val;
int aop = rreqs[i + 1].ops;
if ((((aop == 3) || (aop == 4)) || (aop == 0x2a)) && (anum == 0))
{
aor.ChildOperator = aop;
i++;
}
}
output.Add(aor);
}
for (int i = 0; i < output.Count - 2; i++)
{
output[i].ChildOperator = output[i + 1].ChildOperator;
}
return output;
}
/// <summary>
/// </summary>
/// <param name="requirements">
/// </param>
/// <returns>
/// </returns>
internal static Func<IInstancedEntity, bool> Create(Requirements requirements)
{
return
BuildExpression(
(ItemTarget)requirements.Target,
(Operator)requirements.Operator,
requirements.Statnumber,
requirements.Value).Compile();
}
/// <summary>
/// </summary>
/// <returns>
/// </returns>
public Requirements Copy()
{
Requirements copy = new Requirements();
copy.Operator = this.Operator;
copy.ChildOperator = this.ChildOperator;
copy.Target = this.Target;
copy.Statnumber = this.Statnumber;
copy.Value = this.Value;
return copy;
}
