private DataValue CreateAppropriateDataValue(String attributeName, Object attributeValue)
{
DataValue dv = null;
String t = _simModel.objectModel.objects["PhysicalObject"].attributes[attributeName].dataType;
dv = DataValueFactory.BuildValue(t);
switch (t)
{
case "StringType":
((StringValue)dv).value = (String)attributeValue;
break;
case "DoubleType":
((DoubleValue)dv).value = (Double)attributeValue;
break;
case "IntegerType":
((IntegerValue)dv).value = (Int32)attributeValue;
break;
case "BooleanType":
((BooleanValue)dv).value = (Boolean)attributeValue;
break;
case "LocationType":
double[] xyz = (double[])attributeValue;
((LocationValue)dv).X = xyz[0];
((LocationValue)dv).Y = xyz[1];
((LocationValue)dv).Z = xyz[2];
((LocationValue)dv).exists = true;
break;
case "VelocityType":
double[] vxvyvz = (double[])attributeValue;
((LocationValue)dv).X = vxvyvz[0];
((LocationValue)dv).Y = vxvyvz[1];
((LocationValue)dv).Z = vxvyvz[2];
break;
default:
break;
}
return(dv);
}
static public SimulationEvent BuildEvent(ref SimulationModelInfo model, string eventType)
{
SimulationEvent e = new SimulationEvent();
if (!model.eventModel.events.ContainsKey(eventType))
{
throw new Exception("Event type doesn't exist");
}
foreach (ParameterInfo pInfo in model.eventModel.events[eventType].parameters.Values)
{
e[pInfo.name] = DataValueFactory.BuildValue(pInfo.dataType);
}
e.eventType = eventType;
return(e);
}
static public SimulationObject BuildObject(ref SimulationModelInfo model, string objectType)
{
SimulationObject o = new SimulationObject();
if (!model.objectModel.objects.ContainsKey(objectType))
{
throw new Exception("Object type doesn't exist");
}
foreach (AttributeInfo aInfo in model.objectModel.objects[objectType].attributes.Values)
{
o[aInfo.name] = DataValueFactory.BuildValue(aInfo.dataType);
}
o.objectType = objectType;
return(o);
}
/// <summary>
/// This method takes in a capabilities list, and a docked weapons list, and quantifies the weapons and
/// combines those results with the capabilities list for a returned "CapabilitiesList", which the
/// client displays to its user.
/// </summary>
/// <param name="atts"></param>
private void AddCapabilitiesAndWeaponsList(ref AttributeCollectionValue atts)
{
List <string> capabilities = new List <string>();
Dictionary <string, int> weaponsAndQuantities = new Dictionary <string, int>();
string objectID = ((StringValue)atts["ID"]).value;
SimulationObjectProxy obj = objectProxies[objectID];
CapabilityValue cv;
if (atts.attributes.ContainsKey("Capability"))
{
cv = atts["Capability"] as CapabilityValue;
// atts.attributes.Remove("Capability");
}
else
{
cv = obj["Capability"].GetDataValue() as CapabilityValue;
}
foreach (CapabilityValue.Effect ef in ((CapabilityValue)cv).effects)
{
if (!capabilities.Contains(ef.name))
{
capabilities.Add(ef.name);
}
}
StringListValue sl;
SimulationObjectProxy wep;
string className;
if (atts.attributes.ContainsKey("DockedWeapons"))
{
sl = atts["DockedWeapons"] as StringListValue;
}
else
{
sl = obj["DockedWeapons"].GetDataValue() as StringListValue;
}
foreach (string weapon in sl.strings)
{
wep = objectProxies[weapon];
className = ((StringValue)wep["ClassName"].GetDataValue()).value;
if (!weaponsAndQuantities.ContainsKey(className))
{
weaponsAndQuantities.Add(className, 0);
}
weaponsAndQuantities[className]++;
}
List <string> CapabilitiesAndWeaponsList = new List <string>();
foreach (string c in capabilities)
{
CapabilitiesAndWeaponsList.Add(c);
}
foreach (string w in weaponsAndQuantities.Keys)
{
CapabilitiesAndWeaponsList.Add(String.Format("{0} ({1}x)", w, weaponsAndQuantities[w]));
}
DataValue retDV = DataValueFactory.BuildValue("StringListType");
((StringListValue)retDV).strings = CapabilitiesAndWeaponsList;
atts.attributes.Add("CapabilitiesList", retDV);
}
/// <summary>
///
/// </summary>
/// <param name="allObjectViews"></param>
private void SenseAllObjects(ref Dictionary <string, Dictionary <string, AttributeCollectionValue> > allObjectsViews)
{
SimulationObjectProxy sensingProxy = null;
SimulationObjectProxy targetProxy = null;
Vec3D sensingLocation = null;
Vec3D targetsLocation = null;
LocationValue senLocation = null;
LocationValue tarLocation = null;
double distance = 0.0;
SensorArrayValue sav = null;
DataValue targetsAttribute = null;
string ownerID = null;
string objectType = null;
DetectedAttributeValue detectedAttribute;
AttributeCollectionValue singleAttributeCollection = null;
bool isSensed = false;
// The dictionary is constantly created in this method //
Dictionary <string, AttributeCollectionValue> singleObjectView;
//AD to improve this later:
// for each object in the visible ObjectDistances collection
// for each object after the current index
// check for the index object's view of the nested object
// check for the nested object's view of the index object
//Possible hangup is the "All" emitter.
int x = 0;
//Each object senses each other object
//foreach (string sensorObjectID in listOfObjectIDs)
foreach (KeyValuePair <string, List <string> > networks in networkRosters)
{
if (!activeSensorNetworks[networks.Key])
{
continue;
}
foreach (string sensorObjectID in networkObjects[networks.Key])
{
sensingProxy = objectProxies[sensorObjectID];
objectType = sensingProxy.GetObjectType();
senLocation = sensingProxy["Location"].GetDataValue() as LocationValue;
if (senLocation.exists)
{
ownerID = ((StringValue)sensingProxy["OwnerID"].GetDataValue()).value;
singleObjectView = new Dictionary <string, AttributeCollectionValue>();
x++;
//foreach (string targetObjectID in listOfObjectIDs)
foreach (List <string> objects in networkObjects.Values)
{
if (objects.Contains(sensorObjectID))
{
if (((EmitterValue)sensingProxy["Emitters"].GetDataValue()).emitters.ContainsKey("Invisible"))
//OR if it's the "master" object for a region?? -lisa
{
continue;
}
string target = sensorObjectID;
singleAttributeCollection = new AttributeCollectionValue();
foreach (KeyValuePair <string, AttributeInfo> simModelAtt in simModel.objectModel.objects[objectType].attributes)
{
if (!simModelAtt.Value.ownerObservable == true)
{
continue;
}
//if (!sensingProxy.GetKeys().Contains(simModelAtt.Key))
// continue;
DataValue t = sensingProxy[simModelAtt.Key].GetDataValue();
if (t.dataType == "CustomAttributesType")
{
Dictionary <string, DataValue> copiedDict = CopyFromCustomAttributes(((CustomAttributesValue)t).attributes);
t = new CustomAttributesValue();
((CustomAttributesValue)t).attributes = copiedDict;
}
detectedAttribute = new DetectedAttributeValue();
detectedAttribute.stdDev = 100;
detectedAttribute.value = DataValueFactory.BuildFromDataValue(t);
AddAttributeToACV(ref singleAttributeCollection, simModelAtt.Key, detectedAttribute);
}//end foreach sensable attribute
if (!allObjectsViews.ContainsKey(sensorObjectID))
{
allObjectsViews.Add(sensorObjectID, new Dictionary <string, AttributeCollectionValue>());
}
if (!objectViews.ContainsKey(sensorObjectID))
{
objectViews.Add(sensorObjectID, new ObjectsAttributeCollection());
}
//update the global "allObjectViews". The return from UpdateObject is the collection of attributes
//that have changed. These attributes are stored in allObjectsViews and then sent out
//to users.
AttributeCollectionValue changedAttributes = objectViews[sensorObjectID].UpdateObject(target, singleAttributeCollection);
//if (changedAttributes != null && selectedRangeRingLevel != RangeRingLevels.DISABLED)
//{
// CalculateRangeRings(ref changedAttributes, ref sensingProxy);
//}
if (changedAttributes != null)
{
allObjectsViews[sensorObjectID].Add(target, changedAttributes);
}
else//this is so there is at least the empty entry for the detected object so
//you still know it is detected.
{
if (!allObjectsViews[sensorObjectID].ContainsKey(target))
{
allObjectsViews[sensorObjectID].Add(target, new AttributeCollectionValue());
}
}
}
else
{
foreach (string targetObjectID in objects)
{//sensing and target objects are not the same
targetProxy = objectProxies[targetObjectID];
tarLocation = targetProxy["Location"].GetDataValue() as LocationValue;
if (tarLocation.exists)
{
EmitterValue emitters = targetProxy["Emitters"].GetDataValue() as EmitterValue;
if (emitters.emitters.ContainsKey("All"))
{
//if an object has an all emitter, retrieve all attributes without sensing algorithm
AttributeCollectionValue atts = new AttributeCollectionValue();
if (singleObjectView.ContainsKey(targetObjectID))
{
atts = singleObjectView[targetObjectID];
}
SenseAllAttributes(ref atts, targetProxy);
singleObjectView[targetObjectID] = atts;
isSensed = true;
if (!allObjectsViews.ContainsKey(sensorObjectID))
{
allObjectsViews.Add(sensorObjectID, new Dictionary <string, AttributeCollectionValue>());
}
if (!objectViews.ContainsKey(sensorObjectID))
{
objectViews.Add(sensorObjectID, new ObjectsAttributeCollection());
}
//update the global "allObjectViews". The return from UpdateObject is the collection of attributes
//that have changed. These attributes are stored in allObjectsViews and then sent out
//to users.
AttributeCollectionValue changedAttributes = objectViews[sensorObjectID].UpdateObject(targetObjectID, atts);
//if (changedAttributes != null && selectedRangeRingLevel == RangeRingLevels.FULL)
//{//the only way to sense a "target" here is for FULL ring display
// CalculateRangeRings(ref changedAttributes, ref targetProxy);
//}
if (changedAttributes != null)
{
allObjectsViews[sensorObjectID].Add(targetObjectID, changedAttributes);
}
else//this is so there is at least the empty entry for the detected object so
//you still know it is detected.
{
if (!allObjectsViews[sensorObjectID].ContainsKey(targetObjectID))
{
allObjectsViews[sensorObjectID].Add(targetObjectID, new AttributeCollectionValue());
}
}
}
else if (emitters.emitters.ContainsKey("Invisible"))
//or if object is "master" for moving region -lisa
{
continue;
}
else
{//object does not have an all emitter, continue to check each emitter value
AttributeCollectionValue atts = new AttributeCollectionValue();
if (Omniscience)
{
if (singleObjectView.ContainsKey(targetObjectID))
{
atts = singleObjectView[targetObjectID];
}
SenseAllAttributes(ref atts, targetProxy);
singleObjectView[targetObjectID] = atts;
isSensed = true;
if (!allObjectsViews.ContainsKey(sensorObjectID))
{
allObjectsViews.Add(sensorObjectID, new Dictionary <string, AttributeCollectionValue>());
}
if (!objectViews.ContainsKey(sensorObjectID))
{
objectViews.Add(sensorObjectID, new ObjectsAttributeCollection());
}
//update the global "allObjectViews". The return from UpdateObject is the collection of attributes
//that have changed. These attributes are stored in allObjectsViews and then sent out
//to users.
AttributeCollectionValue changedAttributes = objectViews[sensorObjectID].UpdateObject(targetObjectID, atts);
//if (changedAttributes != null && selectedRangeRingLevel == RangeRingLevels.FULL)
//{//the only way to sense a "target" here is for FULL ring display
// CalculateRangeRings(ref changedAttributes, ref targetProxy);
//}
if (changedAttributes != null)
{
allObjectsViews[sensorObjectID].Add(targetObjectID, changedAttributes);
}
else//this is so there is at least the empty entry for the detected object so
//you still know it is detected.
{
if (!allObjectsViews[sensorObjectID].ContainsKey(targetObjectID))
{
allObjectsViews[sensorObjectID].Add(targetObjectID, new AttributeCollectionValue());
}
}
continue;
}
sensingLocation = new Vec3D(senLocation);
targetsLocation = new Vec3D(tarLocation);
isSensed = false;
distance = sensingLocation.ScalerDistanceTo(targetsLocation);
sav = sensingProxy["Sensors"].GetDataValue() as SensorArrayValue;
foreach (SensorValue sv in sav.sensors)
{
if (distance < sv.maxRange)
{
//Find obstructions
List <SimulationObjectProxy> obstructions = FindObstructions(sensingLocation, targetsLocation);
foreach (KeyValuePair <string, List <ConeValue> > kvp in sv.ranges)
{ //Key is the attribute being sensed, value is a list of cones
if (kvp.Key == "All")
{
atts = new AttributeCollectionValue();
if (singleObjectView.ContainsKey(targetObjectID))
{
atts = singleObjectView[targetObjectID];
}
SenseAllAttributes(ref atts, targetProxy);
singleObjectView[targetObjectID] = atts;
isSensed = true;
}
else //not an All sensor, so run detection algorithm
{//Added in main-line
if (!emitters.emitters.ContainsKey(kvp.Key))
{
continue;
}
//Custom attributes fix:
DataValue currentDataValue;
try
{
currentDataValue = targetProxy[kvp.Key].GetDataValue();
}
catch
{
currentDataValue = targetProxy["CustomAttributes"].GetDataValue();
currentDataValue = ((CustomAttributesValue)currentDataValue)[kvp.Key];
//will throw an error here if object doesn't contain custom atts, or
//if it doesnt contain the specified custom att.
}
bool isObstructed = false;
foreach (SimulationObjectProxy reg in obstructions)
{
foreach (string attributeBlocked in ((StringListValue)reg["BlocksSensorTypes"].GetDataValue()).strings)
{
if (kvp.Key == attributeBlocked)
{
isObstructed = true;
}
}
}
if (isObstructed)
{
detectedAttribute = new DetectedAttributeValue();
detectedAttribute.value = DataValueFactory.BuildValue(currentDataValue.dataType);
detectedAttribute.confidence = 0;
//continue;
}
else
{
targetsAttribute = DataValueFactory.BuildFromDataValue(currentDataValue);
//ev is emitters
Dictionary <string, double> emitterCollection = emitters.emitters[kvp.Key];
detectedAttribute = new DetectedAttributeValue();
detectedAttribute = ObjectMath.Detection(senLocation, tarLocation, targetsAttribute, kvp.Value, emitterCollection, obstructions, ref randomGenerator);
}
if (detectedAttribute != null)
{
singleAttributeCollection = new AttributeCollectionValue();
if (singleObjectView.ContainsKey(targetObjectID))
{
singleAttributeCollection = singleObjectView[targetObjectID];
}
AddAttributeToACV(ref singleAttributeCollection, kvp.Key, detectedAttribute);
isSensed = true;
}
}
}//end foreach attribute in sensor
//if the object has any attributes sensed, fill in some other info for the object's view.
if (isSensed)
{
detectedAttribute = new DetectedAttributeValue();
detectedAttribute.stdDev = 100;
detectedAttribute.value = targetProxy["ID"].GetDataValue();
if (singleAttributeCollection == null)
{
singleAttributeCollection = new AttributeCollectionValue();
}
if (!singleObjectView.ContainsKey(targetObjectID))
{
singleObjectView.Add(targetObjectID, singleAttributeCollection);
}
singleAttributeCollection = singleObjectView[targetObjectID];
AddAttributeToACV(ref singleAttributeCollection, "ID", detectedAttribute);
detectedAttribute = new DetectedAttributeValue();
detectedAttribute.stdDev = 100;
detectedAttribute.value = targetProxy["OwnerID"].GetDataValue();
AddAttributeToACV(ref singleAttributeCollection, "OwnerID", detectedAttribute);
} //end if isSensed.
}
} //end foreach sensor in sensor array
if (singleObjectView.ContainsKey(targetObjectID))
{
AttributeCollectionValue attr = singleObjectView[targetObjectID];
if (!allObjectsViews.ContainsKey(sensorObjectID))
{
allObjectsViews.Add(sensorObjectID, new Dictionary <string, AttributeCollectionValue>());
}
if (!objectViews.ContainsKey(sensorObjectID))
{
objectViews.Add(sensorObjectID, new ObjectsAttributeCollection());
}
if (attr.attributes.ContainsKey("CustomAttributes"))
{
DataValue t = ((DetectedAttributeValue)attr["CustomAttributes"]).value;
double conf = ((DetectedAttributeValue)attr["CustomAttributes"]).confidence;
Dictionary <string, DataValue> copiedDict = CopyFromCustomAttributes(((CustomAttributesValue)t).attributes);
t = new CustomAttributesValue();
((CustomAttributesValue)t).attributes = copiedDict;
attr.attributes.Remove("CustomAttributes");
attr.attributes.Add("CustomAttributes", DataValueFactory.BuildDetectedValue(t, Convert.ToInt32(conf)));
}
//update the global "allObjectViews". The return from UpdateObject is the collection of attributes
//that have changed. These attributes are stored in allObjectsViews and then sent out
//to users.
AttributeCollectionValue changedAttributes = objectViews[sensorObjectID].UpdateObject(targetObjectID, attr);
//if (changedAttributes != null && selectedRangeRingLevel == RangeRingLevels.FULL)
//{//the only way to sense a "target" here is for FULL ring display
// CalculateRangeRings(ref changedAttributes, ref targetProxy);
//}
if (changedAttributes != null)
{
allObjectsViews[sensorObjectID].Add(targetObjectID, changedAttributes);
}
else//this is so there is at least the empty entry for the detected object so
//you still know it is detected.
{
if (!allObjectsViews[sensorObjectID].ContainsKey(targetObjectID))
{
allObjectsViews[sensorObjectID].Add(targetObjectID, new AttributeCollectionValue());
}
}
}
else
{
if (objectViews.ContainsKey(sensorObjectID))
{
if (objectViews[sensorObjectID].ContainsObject(targetObjectID))
{
objectViews[sensorObjectID].RemoveObject(targetObjectID);
//if you once knew of this object, and now don't, remove it from object's view.
}
}
}
} //end emitter detection
} //end if target is visible
}
}
} //end foreach target object
} //end if sensor is visible
} //end of foreach sensing object
} //end of Foreach sensor network
if (x > 0)
{
//Console.Out.WriteLine("ViewPro: {0} objects were sensing at time {1}.", x, currentTick / 1000);
}
}
static void Main(string[] args)
{
Polygon2D poly = new Polygon2D();
poly.AddVertex(new Vec2D(1, 1));
poly.AddVertex(new Vec2D(4, 1));
poly.AddVertex(new Vec2D(2.5, 3));
poly.AddVertex(new Vec2D(4, 3));
poly.AddVertex(new Vec2D(4, 4));
poly.AddVertex(new Vec2D(2, 3.5));
bool r;
r = Polygon2D.IsPointInside(poly, new Vec2D(5, 3)); //false
r = Polygon2D.IsPointInside(poly, new Vec2D(2, 2)); //true
r = Polygon2D.IsPointInside(poly, new Vec2D(3.5, 3.5)); //true
r = Polygon2D.IsPointInside(poly, new Vec2D(1, 3.5)); //false
r = Polygon2D.IsPointInside(poly, new Vec2D(3, 2.5)); //false
r = Polygon2D.DoLinesIntersect(new Vec2D(0, 2), new Vec2D(3, 0), new Vec2D(1, 1), new Vec2D(3, 3)); //true
r = Polygon2D.DoLinesIntersect(new Vec2D(0, 2), new Vec2D(3, 0), new Vec2D(2, 1), new Vec2D(3, 3)); //false
DataValue dv = DataValueFactory.BuildValue("CapabilityType");
((CapabilityValue)dv).effects.Add(new CapabilityValue.Effect("foo", 45, 10, .50));
((CapabilityValue)dv).effects.Add(new CapabilityValue.Effect("foo", 100, 5, .25));
string s = DataValueFactory.XMLSerialize(dv);
DataValue dv2 = DataValueFactory.XMLDeserialize(s);
DataValue dv3 = DataValueFactory.BuildValue("VulnerabilityType");
VulnerabilityValue.Transition t = new VulnerabilityValue.Transition("dead");
t.conditions.Add(new VulnerabilityValue.TransitionCondition("foo", 50, 0, 0));
t.conditions.Add(new VulnerabilityValue.TransitionCondition("bar", 20, 0, 0));
((VulnerabilityValue)dv3).transitions.Add(t);
t = new VulnerabilityValue.Transition("hurt");
t.conditions.Add(new VulnerabilityValue.TransitionCondition("foo", 25, 0, 0));
((VulnerabilityValue)dv3).transitions.Add(t);
s = DataValueFactory.XMLSerialize(dv3);
DataValue dv4 = DataValueFactory.XMLDeserialize(s);
System.Console.WriteLine(s == DataValueFactory.XMLSerialize(dv4));
DataValue dv5 = DataValueFactory.BuildValue("StateTableType");
DataValue dv6 = DataValueFactory.BuildValue("AttributeCollectionType");
((StateTableValue)dv5).states["foo"] = DataValueFactory.BuildValue("DoubleType");
((AttributeCollectionValue)dv6).attributes["foo2"] = DataValueFactory.BuildValue("DoubleType");
((StateTableValue)dv5).states["bar"] = dv6;
s = DataValueFactory.XMLSerialize(dv5);
DataValue dv7 = DataValueFactory.XMLDeserialize(s);
DataValue dv8 = DataValueFactory.BuildValue("StringListType");
((StringListValue)dv8).strings.Add("Foo");
((StringListValue)dv8).strings.Add("Bar");
s = DataValueFactory.XMLSerialize(dv8);
dv8 = DataValueFactory.XMLDeserialize(s);
DataValue dv9 = DataValueFactory.BuildValue("PolygonType");
((PolygonValue)dv9).points.Add(new PolygonValue.PolygonPoint(0, 0));
((PolygonValue)dv9).points.Add(new PolygonValue.PolygonPoint(10.234, 34.097));
((PolygonValue)dv9).points.Add(new PolygonValue.PolygonPoint(10.234, 1.2));
s = DataValueFactory.XMLSerialize(dv9);
DataValue dv10 = DataValueFactory.XMLDeserialize(s);
}
