public SimulationEvent MoveDoneReceived(SimulationEvent e, SimulationModelInfo model, SimulationEvent theTick) { //Should receieve a MoveDone event, and create a new move event and send //it to the Queue Manager with time ticks + 1. SimulationEvent ee = SimulationEventFactory.BuildEvent(ref model, "MoveObject"); ee.eventType = "MoveObject"; DataValue myDV = new IntegerValue(); myDV = e["ObjectID"]; ee["ObjectID"] = myDV; myDV = new LocationValue(); ((LocationValue)(myDV)).X = 150; ((LocationValue)(myDV)).Y = 150; ((LocationValue)(myDV)).Z = 50; ee["DestinationLocation"] = myDV; myDV = new DoubleValue(); ((DoubleValue)(myDV)).value = .5; ee["Throttle"] = myDV; myDV = new IntegerValue(); ((IntegerValue)(myDV)).value = ((IntegerValue)theTick.parameters["Time"]).value + 1000; ee["Time"] = myDV; return ee; }
public void AddEvent(int? time, SimulationEvent theEvent) { if (EventQueue.ContainsKey(time)) { //Another entry with this key exists, add onto list (done below) } else {//No entries exist with this key, create new list, stick it into Queue List<SimulationEvent> tempList = new List<SimulationEvent>(); EventQueue[time] = tempList; } EventQueue[time].Add(theEvent); }
//public WaypointRoute GenerateRoute(LocationValue currentLocation, LocationValue destination, List<WaypointRoute> routes) //{ // WaypointRoute result = null; // LocationGraph graph = LocationGraph.GenerateRouteGraph("start",currentLocation, "end",destination, routes); // result = graph.GenerateWaypointRoute("start","end"); // return result; //} internal void ViewProInitializeObject(SimulationEvent ev) { String id = ((StringValue)ev["ObjectID"]).value; SimObject ob; if (AllObjects.ContainsKey(id)) { ob = AllObjects[id]; } else { ob = new SimObject(id); } ob.Owner = ((StringValue)ev["OwnerID"]).value; ob.Location = ((LocationValue)ev["Location"]); ob.IconName = ((StringValue)ev["IconName"]).value; ob.IsWeapon = ((BooleanValue)ev["IsWeapon"]).value; if (ob.Owner == m_decisionMakerID) { m_myObjects[ob.ID] = ob; } else { if (m_myObjects.ContainsKey(id)) { m_myObjects.Remove(id); } } m_allObjects[ob.ID] = ob; if (PlayerAgent != null) { PlayerAgent.ViewProInitializeObject(ev); } }
public void AuthenticationRequest(SimulationEvent e) { Authenticator.LoadUserFile(); string terminalID = ((StringValue)e["TerminalID"]).value; if (currentlyLoggedInUsers == maxNumberOfUsers) { SendAuthenticationResponse(terminalID, "The server has reached its limit for number of users attached to the DDD.", false); return; } string username = ((StringValue)e["Username"]).value; string password = ((StringValue)e["Password"]).value; if (Authenticator.Authenticate(username, password)) { SendAuthenticationResponse(terminalID, "Authentication successful!", true); } else { SendAuthenticationResponse(terminalID, "Invalid username and/or password", false); } }
private void loadEventsButton_Click(object sender, EventArgs e) { if (ofd2.ShowDialog() == DialogResult.OK) { StreamReader re = File.OpenText(ofd2.FileName); string input = null; SimulationEvent ev = null; eventsListBox.Items.Clear(); while ((input = re.ReadLine()) != null) { ev = SimulationEventFactory.XMLDeserialize(input); if (SimulationEventFactory.ValidateEvent(ref simModel, ev)) { eventsListBox.Items.Add(new EventListBoxItem(ev)); } else { MessageBox.Show("event file contains invalid event: \"" + input + "\""); } } re.Close(); } }
public void AttackSucceeded(SimulationEvent ev) { String attacker = ((StringValue)ev["ObjectID"]).value; String target = ((StringValue)ev["TargetID"]).value; String newState = ((StringValue)ev["NewState"]).value; if (m_attackInProcess) { if (target == m_targetID) { ResetAttack(); if (m_returnAfter) { m_engagementState = EngagementState.Returning; m_dddServer.SendMoveObjectRequest(m_thisID, m_originalLocation, 1); } else { m_done = true; } } } }
private void ProcessRegion(SimulationEvent ev) { String id = ((StringValue)ev["ID"]).value; AttributeCollectionValue atts = ((AttributeCollectionValue)ev["Attributes"]); PolygonValue pv = atts.attributes["Polygon"] as PolygonValue; if (atts.attributes.ContainsKey("CurrentAbsolutePolygon")) { pv = atts["CurrentAbsolutePolygon"] as PolygonValue; } if (id.StartsWith("SeaLane-")) { if (!_seaLanes.ContainsKey(id)) { _seaLanes.Add(id, pv); } else { _seaLanes[id] = pv; } } else if (id.StartsWith("Entry-")) { if (!_entryPoints.ContainsKey(id)) { _entryPoints.Add(id, pv); } else { _entryPoints[id] = pv; } } else if (id.StartsWith("AO-")) { //AO's handled differently now } }
public void ProcessEvent(SimulationEvent e) { //objectProxies = bbClient.GetObjectProxies(); switch (e.eventType) { case "NewObject": NewObject(e); break; case "RevealObject": RevealObject(e); break; case "MoveObject": MoveObject(e); break; case "StateChange": StateChange(e); break; case "TimeTick": TimeTick(e); break; case "ExternalApp_SimStop": ResetSimulation(); break; case "ForceUpdateObjectAttribute": ForceUpdateObjectAttribute(e); break; default: break; } }
public void ProcessEvent(SimulationEvent e) { //objectProxies = bbClient.GetObjectProxies(); switch (e.eventType) { case "TimeTick": TimeTick(e); break; case "NewObject": NewObject(e); break; case "RevealObject": RevealObject(e); break; //case "HandshakeInitializeGUIDone": // HandshakeInitializeGUIDone(e); // break; case "ExternalApp_SimStop": ResetSimulation(); break; case "PlayerControl": PlayerControl(e); break; case "ForceUpdateObjectAttribute": ForceUpdateObjectAttribute(e); break; default: break; } }
private void LoadEvents(string fileName) { StreamReader re = File.OpenText(fileName); string input = null; SimulationEvent ev = null; events.Clear(); input = re.ReadLine(); // thriow away the line with the version number while ((input = re.ReadLine()) != null) { try { ev = SimulationEventFactory.XMLDeserialize(input); if (SimulationEventFactory.ValidateEvent(ref simModel, ev)) { if (simModel.eventModel.events[ev.eventType].shouldReplay) { events.Add(ev); } } else { throw new Exception("error reading: " + input); } } catch (Exception e) { ErrorLog.Write(String.Format("NONFATAL Deserialize Error in LogPlayer.Player: {0}", input)); ErrorLog.Write(e.ToString()); } } re.Close(); }
/// <summary> /// This event is broadcast out to each client. That client will attempt to put the object in motion, but will only /// succeed if the object already exists in its playfield. /// </summary> /// <param name="objectID"></param> /// <param name="ownerID"></param> /// <param name="location"></param> /// <param name="desLocation"></param> /// <param name="maxSpeed"></param> /// <param name="throttle"></param> /// <param name="time"></param> /// <param name="iconName"></param> /// <param name="isWeapon"></param> private void SendViewProMotionUpdate(string objectID, string ownerID, LocationValue location, LocationValue desLocation, double maxSpeed, double throttle, string iconName, bool isWeapon, double activeRegionSpeedMultiplier) { SimulationEvent vpmu = null; vpmu = SimulationEventFactory.BuildEvent(ref simModel, "ViewProMotionUpdate"); vpmu["ObjectID"] = DataValueFactory.BuildString(objectID); vpmu["OwnerID"] = DataValueFactory.BuildString(ownerID); vpmu["Location"] = location; vpmu["DestinationLocation"] = desLocation; //Console.WriteLine(String.Format("VPMU: ID:{0} dX:{1} dY:{2}", objectID, desLocation.X, desLocation.Y)); //if (objectID == "Fighter01_Troop_2") //{ // Console.Out.Write(String.Format("\n{0} is moving at {1}*{2}\n", objectID, maxSpeed, activeRegionSpeedMultiplier)); //} vpmu["MaximumSpeed"] = DataValueFactory.BuildDouble(maxSpeed * activeRegionSpeedMultiplier); vpmu["Throttle"] = DataValueFactory.BuildDouble(throttle); vpmu["Time"] = DataValueFactory.BuildInteger(currentTick); vpmu["IconName"] = DataValueFactory.BuildString(iconName); //add label color to the mix try { vpmu["LabelColor"] = DataValueFactory.BuildInteger(dmColorMapping[ownerID]); } catch (Exception ex) { vpmu["LabelColor"] = DataValueFactory.BuildInteger(-984833); } vpmu["IsWeapon"] = DataValueFactory.BuildBoolean(isWeapon); distClient.PutEvent(vpmu); if (!movingObjects.Contains(objectID) && !DataValueFactory.CompareDataValues(location, desLocation)) { movingObjects.Add(objectID); } }
private void ClockStart() { switch (clockState) { case ClockState.STOPPED: clockState = ClockState.RUNNING; startButton.Text = "Pause"; clockTimer.Interval = updateFrequency; clockTimer.Start(); SimulationEvent tick = SimulationEventFactory.BuildEvent(ref simModel, "TimeTick"); ((IntegerValue)tick["Time"]).value = simulationTime; netClient.PutEvent(tick); manualCheckBox.Enabled = false; break; case ClockState.RUNNING: clockState = ClockState.STOPPED; startButton.Text = "Start"; clockTimer.Stop(); break; } }
private void ClassificationChanged(SimulationEvent e) { String objectID = ((StringValue)e["ObjectID"]).value; if (objectProxies.Count == 0) { return; //another weird edge case } SimulationObjectProxy proxy = objectProxies[objectID]; proxy["IdentifyTime"].SetDataValue(DataValueFactory.BuildInteger(time)); proxy["IdentifiedBy"].SetDataValue(DataValueFactory.BuildString(((StringValue)e["UserID"]).value)); proxy["ClassifiedBy"].SetDataValue(DataValueFactory.BuildString(((StringValue)e["UserID"]).value)); String classification = ((StringValue)e["ClassificationName"]).value; proxy["UserClassifiedIFF"].SetDataValue(DataValueFactory.BuildString(classification)); if (!classifications.ContainsKey(objectID)) { classifications.Add(objectID, ""); } classifications[objectID] = classification; }
public void ReceiveDecisionMakerEvent(SimulationEvent dmEvent) { string dmID = ((StringValue)dmEvent["ID"]).value; string dmRole = ((StringValue)((AttributeCollectionValue)dmEvent["Attributes"])["RoleName"]).value; string team = ((StringValue)((AttributeCollectionValue)dmEvent["Attributes"])["TeamMember"]).value; int dmColor = ((IntegerValue)((AttributeCollectionValue)dmEvent["Attributes"])["Color"]).value; string dmBriefing = ((StringValue)((AttributeCollectionValue)dmEvent["Attributes"])["Briefing"]).value; Boolean isObserver = ((BooleanValue)((AttributeCollectionValue)dmEvent["Attributes"])["IsObserver"]).value; DecisionMaker dm = new DecisionMaker(dmID, null); //STUB; need teams info dm.role = dmRole; dm.color = dmColor; dm.briefing = dmBriefing; dm.isHuman = !((BooleanValue)((AttributeCollectionValue)dmEvent["Attributes"])["ComputerControlled"]).value; if (!allDMs.ContainsKey(dmID)) { allDMs.Add(dmID, dm); } dm.isObserver = isObserver; //SimulationEvent player = SimulationEventFactory.BuildEvent(ref simModelInfo, "PlayerControl"); //((StringValue)player["DecisionMakerID"]).value = dmID; //((StringValue)player["ControlledBy"]).value = "COMPUTER"; //server.PutEvent(player); }
private void ProcessObject(SimulationEvent ev) { String id = ((StringValue)ev["ID"]).value; String objectType = ((StringValue)((AttributeCollectionValue)ev["Attributes"])["ClassName"]).value; AttributeCollectionValue atts = ev["Attributes"] as AttributeCollectionValue; SeamateObject seamateObject = null; if (_unrevealedObjects.ContainsKey(id)) { } else { _unrevealedObjects.Add(id, new SeamateObject(id)); Console.WriteLine("Added to UnrevealedObjects: " + id); } _unrevealedObjects[id].SetAttributes(atts); if (atts.attributes.ContainsKey("OwnerID")) { EstablishOwnership(id, ((StringValue)atts.attributes["OwnerID"]).value); } if (ev.parameters.ContainsKey("StateTable") && !_speciesPossibleStates.ContainsKey(objectType)) { _speciesPossibleStates.Add(objectType, new Dictionary <string, AttributeCollectionValue>()); StateTableValue stv = (StateTableValue)ev["StateTable"]; AttributeCollectionValue stateAttributes = null; foreach (String stateName in stv.states.Keys) { stateAttributes = (AttributeCollectionValue)stv[stateName]; _speciesPossibleStates[objectType].Add(stateName, new AttributeCollectionValue()); foreach (String att in stateAttributes.attributes.Keys) { _speciesPossibleStates[objectType][stateName].attributes.Add(att, DataValueFactory.BuildFromDataValue(stateAttributes[att])); } } } }
public void DisconnectTerminal(SimulationEvent e) { string termID = ((StringValue)e["TerminalID"]).value; string dmID = ""; if (termToDMMap.ContainsKey(termID)) { dmID = termToDMMap[termID]; //.ToUpper()]; } if (dmToTerminalMap.ContainsKey(dmID)) { termID = dmToTerminalMap[dmID]; dmToTerminalMap.Remove(dmID); termToDMMap.Remove(termID); } if (dmsIsReady.ContainsKey(dmID)) { dmsIsReady.Remove(dmID); } if (allDMs.ContainsKey(dmID)) { allDMs[dmID].availability = DecisionMaker.Availability.AVAILABLE; } SimulationEvent player = SimulationEventFactory.BuildEvent(ref simModelInfo, "PlayerControl"); ((StringValue)player["DecisionMakerID"]).value = dmID; ((StringValue)player["ControlledBy"]).value = "COMPUTER"; server.PutEvent(player); player = SimulationEventFactory.BuildEvent(ref simModelInfo, "DisconnectDecisionMaker"); ((StringValue)player["DecisionMakerID"]).value = dmID; server.PutEvent(player); }
public ScenarioReader() { Queue<SimulationEvent> q = new Queue<SimulationEvent>(); QueueManager EventQueue = QueueManager.UniqueInstance(); SimulationEvent dequeued; //simulates reading in from the XML file q.Enqueue(populateQueue()); q.Enqueue(populateQueue2()); q.Enqueue(populateQueue3()); q.Enqueue(populateQueue4()); //Only would dequeue if events are not conditional. //After done reading from XML file, send time queue to queue manager while (q.Count > 0) { dequeued = new SimulationEvent(); dequeued = q.Dequeue(); EventQueue.AddEvent(((IntegerValue)dequeued.parameters["Time"]).value, dequeued); } }
private void EventLoop() { try { List <SimulationEvent> events = null; DateTime nowTimer = new DateTime(); DateTime tickTimer = DateTime.Now; DateTime startTime = new DateTime(); int eventCounter = 0; long start; long end; Dictionary <string, long> simTimes = new Dictionary <string, long>(); foreach (SimulatorExecutionInfo sei in simModelInfo.simulationExecutionModel.simulators) { simTimes[sei.simulatorName] = 0; } while (true) { nowTimer = DateTime.Now; lock (simCoreLock) { switch (state) { case SimCoreState.UNINITIALIZED: throw new Exception("SimCore: shouldn't be in event loop if uninitialized"); case SimCoreState.RUNNING: //distributor.StopIncoming(); events = distClient.GetEvents(); eventCounter = events.Count; foreach (SimulationEvent e in events) { switch (e.eventType) { case "TimeTick": lock (simTimeLock) { simulationTime = (int)((IntegerValue)e["Time"]).value; if (ServerOptions.UsePerformanceLog) { StringBuilder b = new StringBuilder(); b.AppendFormat("SimCore Metric: SimTime: {0}; Processing Time: {1}.", simulationTime / 1000, DateTime.Now - tickTimer); PerformanceLog.Write(b.ToString()); } tickTimer = DateTime.Now; if (simulationTime == 1000) { startTime = DateTime.Now; } } break; case "ExternalApp_SimStop": //Console.Out.WriteLine("SimCore Metric: Exiting SimCore loop. Total run time: {0}; Total ticks: {1}.", DateTime.Now - startTime, (simulationTime / 1000) - 1);//-1 because it is starting at time 1 isReady = false; break; //case "PauseScenario": // if (simulators.ContainsKey("ViewPro")) // { // ((ViewProSim)simulators["ViewPro"]).PauseScenario(); // } // break; //case "ResumeScenario": // if (simulators.ContainsKey("ViewPro")) // { // ((ViewProSim)simulators["ViewPro"]).ResumeScenario(); // } // break; case "ResetSimulation": lock (simTimeLock) { simulationTime = 0; isReady = false; } break; default: break; } //foreach (SimulatorExecutionInfo sei in simModelInfo.simulationExecutionModel.simulators) foreach (KeyValuePair <String, ISimulator> sim in simulators) { start = DateTime.Now.Ticks; //simulators[sei.simulatorName].ProcessEvent(e); sim.Value.ProcessEvent(e); end = DateTime.Now.Ticks; //simTimes[sei.simulatorName] += (end - start); simTimes[sim.Key] += (end - start); } if (e.eventType == "StartupComplete") { SimulationEvent ev = SimulationEventFactory.BuildEvent(ref simModelInfo, "SimCoreReady"); isReady = true; distClient.PutEvent(ev); if (ServerOptions.UsePerformanceLog) { foreach (SimulatorExecutionInfo sei in simModelInfo.simulationExecutionModel.simulators) { if (!simTimes.ContainsKey(sei.simulatorName)) { continue; } StringBuilder b = new StringBuilder(); b.AppendFormat("SimCore Metric: Initialization time in: {0} was {1} seconds.", sei.simulatorName, simTimes[sei.simulatorName] / 10000000.0); PerformanceLog.Write(b.ToString()); simTimes[sei.simulatorName] = 0; } } } } if (eventCounter > 0) { //Console.Out.WriteLine("SimCore Metric: Events Processed: {0}; processing time: {1}.", eventCounter, DateTime.Now - nowTimer); //distributor.ResumeIncoming(); } break; case SimCoreState.STOPPING: long total = 0; if (ServerOptions.UsePerformanceLog) { foreach (SimulatorExecutionInfo sei in simModelInfo.simulationExecutionModel.simulators) { if (!simTimes.ContainsKey(sei.simulatorName)) { continue; } total += simTimes[sei.simulatorName]; } foreach (SimulatorExecutionInfo sei in simModelInfo.simulationExecutionModel.simulators) { if (!simTimes.ContainsKey(sei.simulatorName)) { continue; } StringBuilder b = new StringBuilder(); b.AppendFormat("SimCore Metric: Total time in: {0} was {1} seconds which is {2}% of total simulator time.", sei.simulatorName, simTimes[sei.simulatorName] / 10000000.0, (((double)simTimes[sei.simulatorName]) / total) * 100.0); PerformanceLog.Write(b.ToString()); } } state = SimCoreState.UNINITIALIZED; return; } } Thread.Sleep(updateFrequency / 10); } } catch (ThreadAbortException) { } catch (Exception exc) { MessageBox.Show("An error '" + exc.Message + "' has occurred in the Simulation Server.\nPlease email the C:\\DDDErrorLog.txt file to Aptima customer support with a description of what you were doing at the time of the error."); ErrorLog.Write(exc.ToString() + "\n"); throw new Exception(); } }
private void ForceUpdateObjectAttribute(SimulationEvent e) { return; }
public EventListBoxItem(SimulationEvent se) { simEvent = se; }
public void ViewProActiveRegionUpdate(SimulationEvent ev) { }
//---------------------------------------------------------------------------------------- // ProcessIRV | Parameters : Entity //---------------------------------------------------------------------------------------- public void ProcessIRV(Entity activeEntity) { //assign the entity a rep activeEntity.SalesRep = TheSalesRepManager.AssignFreeSalesRep(activeEntity.EntityCallType); //set the entitys start wait time activeEntity.StartWaitTime = SimulationTime; //Check to see if the active entity actually recived a rep if so... if (activeEntity.SalesRep != null) { //... set the end wait time for the entity activeEntity.EndWaitTime = SimulationTime; //set the rep assigned to the entity to be not availble activeEntity.SalesRep.Avaliable = false; //Calculate the processing interval based on calls type double processingTime = CalculateProcessingTime(activeEntity.EntityCallType); //create the new complete serve event passing in the calculated processing time and the active entity as well as the event type SimulationEvent newCompleteServiceEvent = new SimulationEvent(activeEntity, eEventType.ProcessingComplete, processingTime); //add the event to the calandar MainCalandar.AddEvent(newCompleteServiceEvent); } else//or else... { //add the entity to the queue theQueueManager.AddEntity(activeEntity); }//End outer if }
//---------------------------------------------------------------------------------------- // Initalize Method | Parameters : N/A //---------------------------------------------------------------------------------------- public void Initialize() { //create first entity Entity lastEntity = new Entity(0); //create first event passsin in the first entity SimulationEvent lastEvent = new SimulationEvent(lastEntity, eEventType.EndSimulation, 10800); //create last entity Entity firstEntity = new Entity(callArrives); //create last event passsin in the last entity SimulationEvent firstEvent = new SimulationEvent(firstEntity, eEventType.CallArrive, 0); //add the first event to the calandar MainCalandar.AddEvent(firstEvent); //add the last event to the calandar MainCalandar.AddEvent(lastEvent); }
private static SimulationEvent populateQueue4() { SimulationEvent ee = new SimulationEvent(); Dictionary<string, DataValue> myAtt = new Dictionary<string, DataValue>(); ee.eventType = "MoveObject"; DataValue myDV = new IntegerValue(); ((IntegerValue)(myDV)).value = 1; ee.parameters.Add("ObjectID", myDV); myDV = new LocationValue(); ((LocationValue)(myDV)).X = 100; ((LocationValue)(myDV)).Y = 100; ((LocationValue)(myDV)).Z = 100; ee.parameters.Add("DestinationLocation", myDV); myDV = new DoubleValue(); ((DoubleValue)(myDV)).value = .5; ee.parameters.Add("Throttle", myDV); myDV = new IntegerValue(); ((IntegerValue)(myDV)).value = 10000; ee.parameters.Add("Time", myDV); return ee; }
public void ViewProMotionUpdate(SimulationEvent ev) { }
private void TimeTick(SimulationEvent e) { time = ((IntegerValue)e["Time"]).value; }
public void ViewProStopObjectUpdate(SimulationEvent ev) { }
//---------------------------------------------------------------------------------------- // Process Complete Service Method | Parameter : Entity //---------------------------------------------------------------------------------------- public void ProcessCompleteService(Entity activeEntity) { //Set the active entitys end time to the simulations current time activeEntity.EndSystemTime = SimulationTime; //update the stats for the entity passing in the active entity stats.UpdateEntityStats(activeEntity); //store the rep type of the current rep in a variable eCallType theCallTypeofRep = activeEntity.SalesRep.RepType; //check the length of the queue of the call type that the active entitys rep is int lengthOfQueueRepIsIn = theQueueManager.QueueLength(theCallTypeofRep); //if the queue length for that call type of the rep is null then... if (lengthOfQueueRepIsIn == 0) { //... make the rep avalible activeEntity.SalesRep.Avaliable = true; } else//or else... { //... get the next entity from thequeue that correspons to the rep type of the rep that was assigned to active entity Entity nextEntity = theQueueManager.GetNextEntity(theCallTypeofRep); //pass the rep from the active entity to the next entity nextEntity.SalesRep = activeEntity.SalesRep; //set the simulation end time for the next entity nextEntity.EndWaitTime = SimulationTime; //calculate how long it will take the next entity to comple the service call double processingTime = CalculateProcessingTime(nextEntity.EntityCallType); //create and add the new complete service event to the clandar passing the next entity, the processing complete event and the processing time SimulationEvent newCompleteServiceEvent = new SimulationEvent(nextEntity, eEventType.ProcessingComplete, processingTime); MainCalandar.AddEvent(newCompleteServiceEvent); }//End if }
public void AttackSucceeded(SimulationEvent ev) { m_done = true; }
private void RevealObject(SimulationEvent e) { AttributeCollectionValue atts = (AttributeCollectionValue)e["Attributes"]; string id = ((StringValue)e["ObjectID"]).value; SimulationObjectProxy prox = null; prox = GetObjectProxy(id); if (prox == null) { return; } //Set State info? //AD: This is kind of a quick fix. Gabe would have a better idea on a more permanent //solution. DataValue stv = new DataValue(); stv = prox["StateTable"].GetDataValue(); Dictionary <string, DataValue> tempDict = ((StateTableValue)stv).states; tempDict = ((AttributeCollectionValue)tempDict[((StringValue)atts["State"]).value]).attributes; foreach (KeyValuePair <String, DataValue> kvp in tempDict) { if (!atts.attributes.ContainsKey(kvp.Key)) {//if att exists in atts, it should NOT overwrite reveal attributes. atts.attributes.Add(kvp.Key, kvp.Value); } } ////AD foreach (string attname in atts.attributes.Keys) { if (attname == "ID") { continue; } if (prox.GetKeys().Contains(attname) && prox[attname].IsOwner()) { prox[attname].SetDataValue(atts[attname]); if (attname == "Sensors") { double maxSensor = -1.0; SensorArrayValue sav = atts[attname] as SensorArrayValue; foreach (SensorValue sv in sav.sensors) { maxSensor = Math.Max(maxSensor, sv.maxRange); } if (maxSensor >= 0) { ObjectDistances.UpdateObjectSensorRange(id, maxSensor); } } } } Dictionary <string, DataValue> x = new Dictionary <string, DataValue>(); EmitterValue em = (EmitterValue)prox["Emitters"].GetDataValue(); foreach (string attName in em.attIsEngram.Keys) { if (em.attIsEngram[attName]) { if (StateDB.engrams.ContainsKey(attName)) { x[attName] = DataValueFactory.BuildString(StateDB.engrams[attName].engramValue); } } } prox["CustomAttributes"].SetDataValue(DataValueFactory.BuildCustomAttributes(x)); }
//---------------------------------------------------------------------------------------- // Process Call Arrive | Parameters : Entity //---------------------------------------------------------------------------------------- public void ProcessCallArrive(Entity activeEntity) { //if the max that can be on hold hasn't been reached..... if (theQueueManager.TotalQueueLength() < GlobalParameters.MAX_ON_HOLD)// { //...Update its start time to the current simulation time activeEntity.StartSystemTime = SimulationTime; //...calc wait at switch time double waitIRVInterval = (theDice.diceRoll() * GlobalParameters.IVR_DELAY)*GlobalParameters.SEC_IN_MIN; double completIRVTime = SimulationTime + waitIRVInterval; //...Create the new event taking in the entity and Add the new event to the calandar SimulationEvent newCompleteSwitcheEvent = new SimulationEvent(activeEntity, eEventType.SwitchComplete, completIRVTime); MainCalandar.AddEvent(newCompleteSwitcheEvent); } else// if the max that can be on hold has been reashed or surpassed then... { //...increment the hangup count stats.HangUps++; }//End If callArrives++; //Compute next arrival of and entity Entity nextEntity = new Entity(callArrives); double nextArivalInterval = (theDice.diceRoll() * GlobalParameters.CALL_ARRIVAL_RATE) * GlobalParameters.SEC_IN_MIN; double nextArrivalTime = SimulationTime + nextArivalInterval; //Add event to callander for next arrival SimulationEvent newArrivalEvent = new SimulationEvent(nextEntity, eEventType.CallArrive,nextArrivalTime); MainCalandar.AddEvent(newArrivalEvent); }
private void StateChange(SimulationEvent e) { string id = ((StringValue)e["ObjectID"]).value; SimulationObjectProxy prox = null; // objectProxies[id]; prox = GetObjectProxy(id); if (prox == null) { return; } string newState = ((StringValue)e["NewState"]).value; DataValue dv = prox["StateTable"].GetDataValue(); if (((StateTableValue)dv).states.ContainsKey(newState)) { DataValue dv2 = ((StateTableValue)dv).states[newState]; //AD: Added state to attributes DataValue temp = new StringValue(); ((StringValue)temp).value = newState; ((AttributeCollectionValue)dv2).attributes["State"] = temp; //AD foreach (string attname in ((AttributeCollectionValue)dv2).attributes.Keys) { if (prox.GetKeys().Contains(attname) && prox[attname].IsOwner()) { prox[attname].SetDataValue(((AttributeCollectionValue)dv2).attributes[attname]); if (attname == "Sensors") { double maxSensor = -1.0; SensorArrayValue sav = ((AttributeCollectionValue)dv2).attributes[attname] as SensorArrayValue; foreach (SensorValue sv in sav.sensors) { maxSensor = Math.Max(maxSensor, sv.maxRange); } if (maxSensor >= 0) { ObjectDistances.UpdateObjectSensorRange(id, maxSensor); } } } } } CustomAttributesValue cav = prox["CustomAttributes"].GetDataValue() as CustomAttributesValue; Dictionary <string, DataValue> x = new Dictionary <string, DataValue>(); if (cav != null) { x = cav.attributes; } EmitterValue em = (EmitterValue)prox["Emitters"].GetDataValue(); foreach (string attName in em.attIsEngram.Keys) { if (em.attIsEngram[attName]) { if (StateDB.engrams.ContainsKey(attName)) { x[attName] = DataValueFactory.BuildString(StateDB.engrams[attName].engramValue); } } } prox["CustomAttributes"].SetDataValue(DataValueFactory.BuildCustomAttributes(x)); }
//-------------------------------------------------------------------------------------------- // Add Event | Parameters : SimulationEvent //--------------------------------------------------------------------------------------------- public void AddEvent(SimulationEvent theEvent) { // add the event to the events list then sort to get the events in order as they are added EventList.Add(theEvent); SortEvents(); }
public override void UpdateFromSimulation(int numberOfUpdates, Simulator sim, SimulationEvent eventType) { base.UpdateFromSimulation(numberOfUpdates, sim, eventType); if (eventType == SimulationEvent.TICK) { int varID = sim.GetComponentPinCurrentVarId(ID, 1); if (varID != -1) { double LEDCurrent = sim.GetValueOfVar(varID, 0); if (LEDCurrent > 0) { SetBrightness(Math.Min(LEDCurrent / 0.01, 1.0)); } else { SetBrightness(0); } } else { SetBrightness(0); } } else if (eventType == SimulationEvent.STOPPED) { SetBrightness(0); } }
private void TimeTick(SimulationEvent e) { blackboard.simTime = ((IntegerValue)e["Time"]).value; }
public void ViewProInitializeObject(SimulationEvent ev) { }
private void AttackSucceeded(SimulationEvent e) { if (objectProxies.Count == 0) { return; //another weird edge case } try { String objectID = ((StringValue)e["ObjectID"]).value; SimulationObjectProxy proxy = objectProxies[objectID]; String targetID = ((StringValue)e["TargetID"]).value; SimulationObjectProxy targetProxy = objectProxies[targetID]; String transitionState = ((StringValue)e["NewState"]).value; // It's a sea vessel if it's not a BAMS or Firescout String targetClassName = ((StringValue)targetProxy["ClassName"].GetDataValue()).value; if (targetClassName != "BAMS" && targetClassName != "Firescout" && transitionState == "Dead") { targetProxy["DestroyedTime"].SetDataValue(DataValueFactory.BuildInteger(time)); targetProxy["DestroyedBy"].SetDataValue(DataValueFactory.BuildString(objectID)); //AD: TODO Send view pro attribute event for these objects. SimulationEvent ev = SimulationEventFactory.BuildEvent(ref simModel, "ViewProAttributeUpdate"); AttributeCollectionValue acv = new AttributeCollectionValue(); // acv.attributes.Add("DestroyedTime", DataValueFactory.BuildDetectedValue(DataValueFactory.BuildInteger(time), 100)); // acv.attributes.Add("DestroyedBy", DataValueFactory.BuildDetectedValue(DataValueFactory.BuildString(objectID), 100)); acv.attributes.Add("DestroyedTime", DataValueFactory.BuildInteger(time)); acv.attributes.Add("DestroyedBy", DataValueFactory.BuildString(objectID)); ((StringValue)ev["TargetPlayer"]).value = "BAMS DM"; ((StringValue)ev["ObjectID"]).value = ((StringValue)targetProxy["ID"].GetDataValue()).value; ((StringValue)ev["OwnerID"]).value = ((StringValue)targetProxy["OwnerID"].GetDataValue()).value; ((IntegerValue)ev["Time"]).value = time * 1000; ev["Attributes"] = acv; distClient.PutEvent(ev); ((StringValue)ev["TargetPlayer"]).value = "Firescout DM"; distClient.PutEvent(ev); ((StringValue)ev["TargetPlayer"]).value = "Individual DM"; distClient.PutEvent(ev); } String targetOwnerID = ((StringValue)targetProxy["OwnerID"].GetDataValue()).value; String attackerOwnerID = ((StringValue)proxy["OwnerID"].GetDataValue()).value; if (transitionState == "Dead") { //Clear the intent of any other vessel mentioned in target's intent (pursued or pursuee). String targetIntent = ((StringValue)targetProxy["Intent"].GetDataValue()).value; if (targetIntent != "") { String[] intentArray = targetIntent.Split(":".ToCharArray()); if (intentArray.Length > 1) { SimulationObjectProxy vesselProxyToClear = objectProxies[intentArray[1]]; vesselProxyToClear["Intent"].SetDataValue(DataValueFactory.BuildString("")); } } //IF friendly, increment counter if (!targetOwnerID.ToLower().Contains("pirate")) { IncrementFriendliesLost(1); String attackClassName = ((StringValue)proxy["ClassName"].GetDataValue()).value; if (attackClassName == "BAMS" || attackClassName == "Firescout") { //IF friendly, and attacker was BAMS/FS IncrementFriendliesDestroyedByPlayers(1); } } else { //if hostile increment counter IncrementHostileTargetsDestroyed(1); } } //if (targetClassName == "BAMS" || targetClassName == "Firescout") //{ // //if bams/firescout, increment counter // IncrementHitsTakenByAssets(1); //} if (!attackerOwnerID.Contains("BAMS") && !attackerOwnerID.Contains("Firescout") && !attackerOwnerID.Contains("Individual")) { return; //the following section is only for YOUR attacks, so return if its not BAMS or FS } String attackClass = ((StringValue)proxy["ClassName"].GetDataValue()).value; String targetClassification = ""; try { targetClassification = classifications[targetID]; } catch (Exception exc) { } if (targetClassification != "Hostile" && (targetClassName != "BAMS" || targetClassName != "Firescout")) { //if asset was not classified as hostile, violated ROE IncrementRulesOfEngagementViolations(1); } } catch (Exception ex) { } }
public void ViewProAttributeUpdate(SimulationEvent ev) { }
private void NewObject(SimulationEvent e) { //objectProxies = bbClient.GetObjectProxies(); // update my objects record string id = ((StringValue)e["ID"]).value; string type = ((StringValue)e["ObjectType"]).value; if (objectProxies == null) { objectProxies = new Dictionary <string, SimulationObjectProxy>(); } SimulationObjectProxy prox = bbClient.GetObjectProxy(id); if (prox == null) { return; } if (!objectProxies.ContainsKey(id)) { objectProxies.Add(id, prox); } else { objectProxies[id] = prox; } AttributeCollectionValue atts = (AttributeCollectionValue)e["Attributes"]; string id2 = ((StringValue)e["ID"]).value; SimulationObjectProxy proxi = objectProxies[id2]; if (proxi.GetKeys().Contains("StateTable")) { proxi["StateTable"].SetDataValue(e["StateTable"]); } if (objectProxies.ContainsKey(id2)) { // initialize any object values I own. foreach (string attname in atts.attributes.Keys) { if (proxi.GetKeys().Contains(attname) && proxi[attname].IsOwner()) { proxi[attname].SetDataValue(atts[attname]); if (attname == "Sensors") { double maxSensor = -1.0; SensorArrayValue sav = atts[attname] as SensorArrayValue; foreach (SensorValue sv in sav.sensors) { maxSensor = Math.Max(maxSensor, sv.maxRange); } if (maxSensor >= 0) { ObjectDistances.UpdateObjectSensorRange(id2, maxSensor); } } } } } }
private static SimulationEvent populateQueue3() { SimulationEvent ee = new SimulationEvent(); Dictionary<string, DataValue> myAtt = new Dictionary<string, DataValue>(); ee.eventType = "NewObject"; DataValue myDV = new StringValue(); ((StringValue)(myDV)).value = "PhysicalObject"; ee.parameters.Add("ObjectType", myDV); // START OF ATTRIBUTE DEFINITIONS // myDV = new IntegerValue(); ((IntegerValue)(myDV)).value = 1; myAtt.Add("ID", myDV); myDV = new StringValue(); ((StringValue)(myDV)).value = "Second Object"; myAtt.Add("ObjectName", myDV); myDV = new StringValue(); ((StringValue)(myDV)).value = "flying"; myAtt.Add("ObjectState", myDV); myDV = new StringValue(); ((StringValue)(myDV)).value = "NoClassesYet"; myAtt.Add("ClassName", myDV); myDV = new LocationValue(); ((LocationValue)(myDV)).X = 100; ((LocationValue)(myDV)).Y = 100; ((LocationValue)(myDV)).Z = 0; myAtt.Add("Location", myDV); myDV = new VelocityValue(); ((VelocityValue)(myDV)).VX = 0; ((VelocityValue)(myDV)).VY = 0; ((VelocityValue)(myDV)).VZ = 0; myAtt.Add("Velocity", myDV); myDV = new DoubleValue(); ((DoubleValue)(myDV)).value = 1; myAtt.Add("MaximumSpeed", myDV); myDV = new DoubleValue(); ((DoubleValue)(myDV)).value = 0.0; myAtt.Add("Throttle", myDV); myDV = new LocationValue(); ((LocationValue)(myDV)).X = 0; ((LocationValue)(myDV)).Y = 0; ((LocationValue)(myDV)).Z = 0; myAtt.Add("DestinationLocation", myDV); // END OF ATTRIBUTE DEFINITIONS // myDV = new AttributeCollectionValue(); ((AttributeCollectionValue)(myDV)).attributes = myAtt; ee.parameters.Add("Attributes", myDV); myDV = new IntegerValue(); ((IntegerValue)(myDV)).value = 5000; ee.parameters.Add("Time", myDV); return ee; }