public void GetOrderedEffectsByCapabilityTest()
{
CapabilityValue target = new CapabilityValue(); // TODO: Initialize to an appropriate value
CapabilityValue.Effect ef = new CapabilityValue.Effect("Capability1", 1000.0, 10, 1);
target.effects.Add(ef);
ef = new CapabilityValue.Effect("Capability2", 2000.0, 20, 1);
target.effects.Add(ef);
ef = new CapabilityValue.Effect("Capability1", 2000.0, 20, 1);
target.effects.Add(ef);
ef = new CapabilityValue.Effect("Capability1", 500.0, 5, 0.5);
target.effects.Add(ef);
ef = new CapabilityValue.Effect("Capability2", 555.0, 6, 0.6);
target.effects.Add(ef);
ef = new CapabilityValue.Effect("Capability1", 5000.0, 50, 1);
target.effects.Add(ef);
//this shows that the function returns the correctly ordered list for Capability1
List<CapabilityValue.Effect> actual;
actual = target.GetOrderedEffectsByCapability("Capability1");
Assert.AreEqual(actual.Count, 4);
Assert.AreEqual(actual[0].range, 500.0);
Assert.AreEqual(actual[1].range, 1000.0);
Assert.AreEqual(actual[0].intensity, 5);
Assert.AreEqual(actual[1].intensity, 10);
//this shows that the function returns the correctly ordered list for Capability2
actual = target.GetOrderedEffectsByCapability("Capability2");
Assert.AreEqual(actual.Count, 2);
Assert.AreEqual(actual[0].range, 555.0);
Assert.AreEqual(actual[1].range, 2000.0);
Assert.AreEqual(actual[0].intensity, 6);
Assert.AreEqual(actual[1].intensity, 20);
//this shows that removal from the returned list doesn't affect the structure of the internal list.
actual.RemoveAt(1);
actual = target.effects;
Assert.AreEqual(actual.Count, 6);
Assert.AreEqual(actual[0].range, 1000.0);
Assert.AreEqual(actual[1].range, 2000.0);
Assert.AreEqual(actual[0].intensity, 10);
Assert.AreEqual(actual[1].intensity, 20);
}
/// <summary>
/// Sends an event to the server which updates a single object's Capability object.
/// This is a complicated data structure. It contains a series of lists, whose values are related.
/// These lists contain a series of Capabilities, Ranges, Intensities, and Probabilities. The index of each of these
/// collections should correlate such that Capabilities[1], Ranges[1], Intensities[1] and Probabilities[1] are all
/// for a single capability. As these are TIGHTLY correlated, you cannot skip inserting any values into this collection.
/// </summary>
/// <param name="objectID">The object's ID</param>
/// <param name="capabilities">The value list index relates to the other List collections passed in as parameters.</param>
/// <param name="ranges">The value list index relates to the other List collections passed in as parameters.</param>
/// <param name="intensities">The value list index relates to the other List collections passed in as parameters.</param>
/// <param name="probabilities">The value list index relates to the other List collections passed in as parameters.</param>
public void UpdateObjectCapabilities(String objectID, List<String> capabilities, List<Double> ranges, List<int> intensities, List<Double> probabilities)
{
CapabilityValue dv = new CapabilityValue();
//construct list of CapName/Range/Intensity/Probability
if ((capabilities.Count == ranges.Count) && (ranges.Count == intensities.Count) && (intensities.Count == probabilities.Count))
{
for (int x = 0; x < capabilities.Count; x++)
{
CapabilityValue.Effect ef = new CapabilityValue.Effect(capabilities[x], ranges[x], intensities[x], probabilities[x]);
dv.effects.Add(ef);
}
SendObjectAttributeUpdateEvent(objectID, "Capability", dv);
}
else
{
Console.WriteLine("In UpdateObjectCapabilities: Lists of Capabilities, Ranges, Intensities and Probabilities have different counts, no event sent");
}
}
public void TestAttackProcessorSimAttackObjectLogic()
{
//SETUP
CapabilityValue target = new CapabilityValue();
CapabilityValue.Effect ef = new CapabilityValue.Effect("Capability1", 1000.0, 10, 1);
target.effects.Add(ef);
ef = new CapabilityValue.Effect("Capability2", 2000.0, 20, 1);
target.effects.Add(ef);
ef = new CapabilityValue.Effect("Capability1", 2000.0, 20, 1);
target.effects.Add(ef);
ef = new CapabilityValue.Effect("Capability1", 500.0, 5, 0.5);
target.effects.Add(ef);
ef = new CapabilityValue.Effect("Capability2", 555.0, 6, 0.6);
target.effects.Add(ef);
ef = new CapabilityValue.Effect("Capability1", 5000.0, 50, 1);
target.effects.Add(ef);
double[] ranges = { 200.0, 800.0, 1500.0, 5000.0 };
int[] expectedIntensities = { 5, 10, 20, 50 };
//TEST
for (int x = 0; x < ranges.Length; x++)//double distance in ranges)
{
List<CapabilityValue.Effect> capabilities = target.GetOrderedEffectsByCapability("Capability1");
bool testComplete = false;
foreach (CapabilityValue.Effect eff in capabilities)
{
if (eff.name == "Capability1" && ranges[x] <= eff.range)
{
//int r = random.Next(0, 100);
//if (r <= ((int)(eff.probability * 100)))
//{
//appliedIntensity = (int)(eff.intensity * newAttack.percentageApplied / 100);
//newAttack.appliedIntensity = appliedIntensity;
//targetVul.ApplyEffect(eff.name, appliedIntensity, distance, ref random);
//}
//break outside of the if because if the probability failed, you dont want a second chance with a different range.
Assert.AreEqual(eff.intensity, expectedIntensities[x]);
testComplete = true;
break; //break because we only want to apply the first range found that satisfied the distance restraint
}
}
Assert.IsTrue(testComplete, System.String.Format("Incorrect value when testing for range {0}", ranges[x]));
}
List<CapabilityValue.Effect> capability = target.GetOrderedEffectsByCapability("Capability1");
bool testCompleted = false;
foreach (CapabilityValue.Effect eff in capability)
{
if (eff.name == "Capability1" && 6000 <= eff.range)
{
//int r = random.Next(0, 100);
//if (r <= ((int)(eff.probability * 100)))
//{
//appliedIntensity = (int)(eff.intensity * newAttack.percentageApplied / 100);
//newAttack.appliedIntensity = appliedIntensity;
//targetVul.ApplyEffect(eff.name, appliedIntensity, distance, ref random);
//}
//break outside of the if because if the probability failed, you dont want a second chance with a different range.
testCompleted = true;
break; //break because we only want to apply the first range found that satisfied the distance restraint
}
}
Assert.IsFalse(testCompleted, System.String.Format("Incorrect value when testing for range {0}", 6000));
}
/*
* Note: This was not being called. If it is needed later, note that after this revision it
* is no longer in sycnh with the other 'overload.' best to create a temp variable inside this,
* convert the input to that variable, and then pass to the other 'overload'
private static DataValue DefineVulnerabilityValue(ObjectDictionary singletons,
ObjectDictionary combo)
{
DataValue returnVulnerabilityValue =
(VulnerabilityValue)DataValueFactory.BuildValue("VulnerabilityType");
VulnerabilityValue.Transition t;
VulnerabilityValue.TransitionCondition tc;
string state;
int effect;
foreach (string capability in singletons.GetKeys())
{
foreach (TransitionType transType in ((SingletonVulnerabilityType)singletons[capability]).Transitions)
{
effect = transType.Effect;
state = transType.State;
tc = new VulnerabilityValue.TransitionCondition(capability, effect);
t = new VulnerabilityValue.Transition(state);
t.conditions.Add(tc);
((VulnerabilityValue)returnVulnerabilityValue).transitions.Add(t);
}
}
foreach (object c in combo.GetDictionary().Values)
{
state = ((ComboVulnerabilityType)c).NewState;
t = new VulnerabilityValue.Transition(state);
foreach (ContributionType cont in ((ComboVulnerabilityType)c).Contributions)
{
effect = cont.Effect;
string capability = cont.Capability;
tc = new VulnerabilityValue.TransitionCondition(capability, effect);
t.conditions.Add(tc);
}
((VulnerabilityValue)returnVulnerabilityValue).transitions.Add(t);
}
return returnVulnerabilityValue;
}
*/
private static DataValue DefineCapabilityValue(Dictionary<string, CapabilityType> capabilityList)
{
DataValue returnCapabilityValue = (CapabilityValue)DataValueFactory.BuildValue("CapabilityType");
CapabilityValue.Effect effect;
int intensity;
double probability,
range;
foreach (string name in capabilityList.Keys)
{
CapabilityType capability = capabilityList[name];
capability.ProximityList.Sort();
foreach (ProximityType prox in capability.ProximityList)
{
range = prox.Range;
prox.EffectList.Sort();
foreach (EffectType e in prox.EffectList)
{
intensity = e.Intensity;
probability = e.Probability;
effect = new CapabilityValue.Effect(name, range, intensity, probability);
((CapabilityValue)returnCapabilityValue).effects.Add(effect);
}
}
}
return returnCapabilityValue;
}
