//private static Thread textChatServerThread;
//private static Thread handshakeManagerThread;
/// <summary>
///
/// </summary>
/// <param name="scenarioFile"></param>
/// <param name="schemaFile"></param>
/// <param name="hostname"></param>
/// <param name="portString"></param>
/// <param name="simModelName"></param>
/// <param name="contextControl"></param>
/// <param name="updateIncr"></param>
/// <param name="lowerLevel"></param>
/// <param name="outputType">Arg0 = Debug, Arg1 = Test</param>
public Coordinator(
string scenarioFile,
string schemaFile,
string replayFile,
ref SimulationEventDistributor distributor,
//string hostname,
//string portString,
string simModelName,
string contextControl,//*NETWORK"
string updateIncr,
string lowerLevel,
List <string> logTypes,
string debugFile
)// Needed(?) only so can start a thread
{
SetError(false);
coordinatorThread = null;
eCommReceiver = null;
//textChatServerThread = null;
//handshakeManagerThread = null;
Coordinator.scenarioFile = scenarioFile;
Coordinator.schemaFile = schemaFile;
Coordinator.replayFile = replayFile;
//Coordinator.hostname = hostname;
//Coordinator.portString = portString;
Coordinator.distributor = distributor;
Coordinator.simModelName = simModelName;
Coordinator.contextControl = contextControl; //*NETWORK"
Coordinator.updateIncr = updateIncr;
Coordinator.lowerLevel = lowerLevel; //GUI
Coordinator.loggingTypes = logTypes;
Coordinator.debugFile = debugFile;
}
public void Initialize(ref SimulationModelInfo simModel, ref Blackboard blackboard, ref SimulationEventDistributor distributor)
{
this.blackboard = blackboard;
this.bbClient = new BlackboardClient();
this.distributor = distributor;
this.distClient = new SimulationEventDistributorClient();
this.simModel = simModel;
distributor.RegisterClient(ref distClient);
//distClient.Subscribe("NewObject");
//distClient.Subscribe("RevealObject");
//distClient.Subscribe("TimeTick");
//distClient.Subscribe("HandshakeInitializeGUIDone");
//distClient.Subscribe("ResetSimulation");
blackboard.RegisterClient(ref bbClient);
bbClient.Subscribe("PhysicalObject", "ID", true, false);
bbClient.Subscribe("PhysicalObject", "OwnerID", true, false);
bbClient.Subscribe("PhysicalObject", "ClassName", true, false);
bbClient.Subscribe("PhysicalObject", "Location", true, false);
bbClient.Subscribe("PhysicalObject", "Capability", true, false);
bbClient.Subscribe("PhysicalObject", "Vulnerability", true, false);
bbClient.Subscribe("PhysicalObject", "IsWeapon", true, false);
bbClient.Subscribe("PhysicalObject", "PursueStarted", true, false);
bbClient.Subscribe("PhysicalObject", "PursueTargetID", true, false);
bbClient.Subscribe("PhysicalObject", "SelfDefenseStartAttack", true, true);
bbClient.Subscribe("PhysicalObject", "SelfDefenseCapability", true, true);
bbClient.Subscribe("PhysicalObject", "SelfDefenseTargetID", true, true);
bbClient.Subscribe("PhysicalObject", "TargetsInRange", true, false);
bbClient.Subscribe("PhysicalObject", "CurrentAttacks", true, false);
bbClient.Subscribe("PhysicalObject", "AttackState", true, false);
objectProxies = new Dictionary <string, SimulationObjectProxy>();
}
public void Initialize(ref SimulationModelInfo simModel, ref Blackboard blackboard, ref SimulationEventDistributor distributor)
{
this.blackboard = blackboard;
this.bbClient = new BlackboardClient();
this.distributor = distributor;
this.distClient = new SimulationEventDistributorClient();
this.simModel = simModel;
distributor.RegisterClient(ref distClient);
//distClient.Subscribe("NewObject");
//distClient.Subscribe("RevealObject");
//distClient.Subscribe("TimeTick");
//distClient.Subscribe("StateChange");
//distClient.Subscribe("ResetSimulation");
blackboard.RegisterClient(ref bbClient);
bbClient.Subscribe("PhysicalObject", "ID", true, false);
bbClient.Subscribe("PhysicalObject", "StateTable", true, false);
bbClient.Subscribe("PhysicalObject", "Throttle", true, false);
bbClient.Subscribe("PhysicalObject", "FuelCapacity", true, true);
bbClient.Subscribe("PhysicalObject", "FuelAmount", true, true);
bbClient.Subscribe("PhysicalObject", "FuelConsumptionRate", true, true);
bbClient.Subscribe("PhysicalObject", "FuelDepletionState", true, true);
bbClient.Subscribe("PhysicalObject", "DockedToParent", true, false);
objectProxies = new Dictionary <string, SimulationObjectProxy>();
}
public void Initialize(ref SimulationModelInfo simModel, ref Blackboard blackboard, ref SimulationEventDistributor distributor)
{
this.blackboard = blackboard;
this.bbClient = new BlackboardClient();
this.distributor = distributor;
this.distClient = new SimulationEventDistributorClient();
this.simModel = simModel;
distributor.RegisterClient(ref distClient);
//distClient.Subscribe("NewObject");
//distClient.Subscribe("MoveObject");
//distClient.Subscribe("TimeTick");
//distClient.Subscribe("ResetSimulation");
blackboard.RegisterClient(ref bbClient);
bbClient.Subscribe("PhysicalObject", "ID", true, false);
bbClient.Subscribe("PhysicalObject", "Location", true, false);
bbClient.Subscribe("PhysicalObject", "Velocity", true, false);
bbClient.Subscribe("PhysicalObject", "Size", true, false);
bbClient.Subscribe("PhysicalObject", "DockedToParent", true, false);
bbClient.Subscribe("PhysicalObject", "Capability", true, false);
bbClient.Subscribe("PhysicalObject", "Vulnerability", true, false);
bbClient.Subscribe("PhysicalObject", "TargetsInRange", true, true);
bbClient.Subscribe("PhysicalObject", "State", true, false);
//bbClient.Subscribe("PhysicalObject", "MaximumSpeed", true, false);
//bbClient.Subscribe("PhysicalObject", "Throttle", true, false);
//bbClient.Subscribe("PhysicalObject", "DestinationLocation", true, false);
objectProxies = new Dictionary <string, SimulationObjectProxy>();
}
public void Start(SimulationModelInfo simModel, ref SimulationEventDistributor distributor, string logName, bool loop)
{
try
{
playerThread = new Thread(new ThreadStart(EventLoop));
//nc = new NetworkClient();
//nc.Connect(hostname, port);
distClient = new SimulationEventDistributorClient();
distributor.RegisterClient(ref distClient);
this.simModel = simModel;
time = 0;
this.loop = loop;
this.logname = logName;
updateFrequency = simModel.simulationExecutionModel.updateFrequency;
SimulationEvent ev = SimulationEventFactory.BuildEvent(ref simModel, "ResetSimulation");
distClient.PutEvent(ev);
LoadEvents(logName);
playerThread.Start();
}
catch (Exception e)
{
throw e;
}
}
public BlackboardManagerSim()
{
blackboard = null;
bbClient = null;
distributor = null;
distClient = null;
simModel = null;
}
public StaticAttributeSim()
{
blackboard = null;
bbClient = null;
distributor = null;
distClient = null;
simModel = null;
objectProxies = null;
}
public TextChatServer(string simModelPath, ref SimulationEventDistributor distributor)
{
simModelName = simModelPath;
simModelInfo = smr.readModel(simModelName);
isRunning = false;
roomMembership = new Dictionary <string, List <string> >();
server = new SimulationEventDistributorClient();
distributor.RegisterClient(ref server);
}
public FuelHandlingSim()
{
time = 0;
blackboard = null;
bbClient = null;
distributor = null;
distClient = null;
simModel = null;
objectProxies = null;
}
public DynamicRegionSim()
{
time = 0;
blackboard = null;
bbClient = null;
distributor = null;
distClient = null;
simModel = null;
objectProxies = null;
}
public ExternalCommunicationSim()
{
blackboard = null;
bbClient = null;
distributor = null;
distClient = null;
simModel = null;
objectProxies = null;
v3 = null;
}
public CollisionDetectionSim()
{
time = 0;
blackboard = null;
bbClient = null;
distributor = null;
distClient = null;
simModel = null;
objectProxies = null;
}
public AttackProcessorSim()
{
time = 0;
blackboard = null;
bbClient = null;
distributor = null;
distClient = null;
simModel = null;
objectProxies = null;
randomSeed = 0;
random = new Random(randomSeed);
}
public ReplayLogger(string logsPath, string simModelPath, ref SimulationEventDistributor distributor, string mode)
{
logPath = logsPath;
simModelName = simModelPath;
simModelInfo = smr.readModel(simModelName);
isRunning = false;
logMode = mode;
//server = new NetworkClient();
//server.Connect(hostName, Convert.ToInt32(portNumber));
cc = new SimulationEventDistributorClient();
distributor.RegisterClient(ref cc);
}
public EventCommunicator(NetworkClient s)
{
server = s;
//Dennis: This needs to be updated to your directory
simModelInfo = smr.readModel(@"C:\SVN\NewDDD\src\DataFiles\SimulationModel.xml");
//simModelInfo = smr.readModel("SimulationModel.xml");
SimulationEventDistributor dist = new SimulationEventDistributor(ref simModelInfo);
SimulationEventDistributorClient cc = new SimulationEventDistributorClient();
dist.RegisterClient(ref cc);
server.Subscribe("MoveDone");
}
public EventCommunicator(NetworkClient s)
{
server = s;
//Dennis: This needs to be updated to your directory
simModelInfo = smr.readModel(@"C:\SVN\NewDDD\src\DataFiles\SimulationModel.xml");
//simModelInfo = smr.readModel("SimulationModel.xml");
SimulationEventDistributor dist = new SimulationEventDistributor(ref simModelInfo);
SimulationEventDistributorClient cc = new SimulationEventDistributorClient();
dist.RegisterClient(ref cc);
server.Subscribe("MoveDone");
}
/// <summary>
/// Constructs a watcher
/// </summary>
/// <param name="inputDelta">Time to sleep between checking ticks</param>
public TickWatcher(NetworkClient s, string simModel)
{
string simModelName = simModel;
simModelInfo = smr.readModel(simModelName);
server = s;
SimulationEventDistributor dist = new SimulationEventDistributor(ref simModelInfo);
SimulationEventDistributorClient cc = new SimulationEventDistributorClient();
dist.RegisterClient(ref cc);/////////////////
server.Subscribe("TimeTick");
}
/// <summary>
/// The NetworkServer will be instantiated once in the DDD Server.
/// External applications such as agents and custom GUIs should ignore this class.
/// </summary>
/// <param name="port"></param>
/// <param name="dist"></param>
public NetworkServer(int port, ref SimulationEventDistributor dist)
{
server = null;
state = ServerState.STOPPING;
eventDist = dist;
m_serverIP = null;
this.port = port;
connectionListenerThread = null;
//eventCheckerThread = null;
clientHandlers = new List <NetworkServerConnectionHandler>();
clientHandlersLock = new object();
//clientCount = 0;
}
protected EventListener(NetworkClient server)
{
myQM = QueueManager.UniqueInstance();
SimulationModelReader smr = new SimulationModelReader();
SimulationModelInfo simModelInfo = smr.readModel("SimulationModel.xml");
SimulationEventDistributor dist = new SimulationEventDistributor(ref simModelInfo);
SimulationEventDistributorClient cc = new SimulationEventDistributorClient();
dist.RegisterClient(ref cc);
server.Subscribe("MoveDone");
}
public ScoringSim()
{
time = 0;
blackboard = null;
bbClient = null;
distributor = null;
distClient = null;
simModel = null;
objectProxies = null;
lastScore = new Dictionary <string, double>();
//regions = new Dictionary<string, BlockingRegion>();
}
public void AddNetworkClient(NetworkClient s)
{
server = s;
simModelInfo = smr.readModel("SimulationModel.xml");
SimulationEventDistributor dist = new SimulationEventDistributor(ref simModelInfo);
SimulationEventDistributorClient cc = new SimulationEventDistributorClient();
dist.RegisterClient(ref cc);
server.Subscribe("MoveDone");
server.Subscribe("MoveObjectRequest");
server.Subscribe("AttackObjectRequest");
}
public void AddNetworkClient(NetworkClient s)
{
server = s;
simModelInfo = smr.readModel("SimulationModel.xml");
SimulationEventDistributor dist = new SimulationEventDistributor(ref simModelInfo);
SimulationEventDistributorClient cc = new SimulationEventDistributorClient();
dist.RegisterClient(ref cc);
server.Subscribe("MoveDone");
server.Subscribe("MoveObjectRequest");
server.Subscribe("AttackObjectRequest");
}
protected EventListener(NetworkClient server)
{
myQM = QueueManager.UniqueInstance();
SimulationModelReader smr = new SimulationModelReader();
SimulationModelInfo simModelInfo = smr.readModel("SimulationModel.xml");
SimulationEventDistributor dist = new SimulationEventDistributor(ref simModelInfo);
SimulationEventDistributorClient cc = new SimulationEventDistributorClient();
dist.RegisterClient(ref cc);
server.Subscribe("MoveDone");
}
//private Dictionary<string, Team> teams;
//private Dictionary<string, DecisionMaker> decisionMakers;
public SelfDefenseSim()
{
time = 0;
blackboard = null;
bbClient = null;
distributor = null;
distClient = null;
simModel = null;
objectProxies = null;
randomSeed = 0;
random = new Random(randomSeed);
//teams = new Dictionary<string, Team>();
//decisionMakers = new Dictionary<string, DecisionMaker>();
}
private void InitializeDistributor()
{
distributor = new SimulationEventDistributor(ref simModelInfo);
distClient = new SimulationEventDistributorClient();
distributor.RegisterClient(ref distClient);
foreach (Aptima.Asim.DDD.CommonComponents.SimulationModelTools.EventInfo e in simModelInfo.eventModel.events.Values)
{
if (e.simCoreSubscribe)
{
distClient.Subscribe(e.name);
}
}
}
public void Initialize(ref SimulationModelInfo simModel, ref Blackboard blackboard, ref SimulationEventDistributor distributor)
{
this.blackboard = blackboard;
this.bbClient = new BlackboardClient();
this.distributor = distributor;
this.distClient = new SimulationEventDistributorClient();
this.simModel = simModel;
distributor.RegisterClient(ref distClient);
//distClient.Subscribe("NewObject");
//distClient.Subscribe("ResetSimulation");
blackboard.RegisterClient(ref bbClient);
bbClient.Subscribe("BaseObject", "ID", true, true);
}
public void Initialize(ref SimulationModelInfo simModel, ref Blackboard blackboard, ref SimulationEventDistributor distributor)
{
this.blackboard = blackboard;
this.bbClient = new BlackboardClient();
this.distributor = distributor;
this.distClient = new SimulationEventDistributorClient();
this.simModel = simModel;
distributor.RegisterClient(ref distClient);
blackboard.RegisterClient(ref bbClient);
bbClient.Subscribe("PhysicalObject", "ID", true, false);
bbClient.Subscribe("PhysicalObject", "Location", true, false);
objectProxies = new Dictionary <string, SimulationObjectProxy>();
}
static void Main(string[] args)
{
string scenarioFile = args[0];
new ScenarioToQueues(scenarioFile);
// string hostname = "dgeller";
string hostname = args[1];
// int port = 9999;
int port = int.Parse(args[2]);
// string simModelName = "SimulationModel.xml";
string simModelName = args[3];
NetworkClient c = new NetworkClient();
c.Connect(hostname, port);
EventCommunicator eventCommunicator = new EventCommunicator(c);
SimulationModelReader smr = new SimulationModelReader();
SimulationModelInfo simModelInfo = smr.readModel(simModelName);
SimulationEventDistributor dist = new SimulationEventDistributor(ref simModelInfo);
SimulationEventDistributorClient cc = new SimulationEventDistributorClient();
dist.RegisterClient(ref cc);
sink = new Watcher(400);
ThreadStart stub = new ThreadStart(sink.WatcherThread);
Thread stubThread = new Thread(stub);
stubThread.Start();
for (int i = 0; i < 5; i++) // in test the move happens at time 2
{
TimerTicker.NextTick();
}
IncomingList.Add(new MoveComplete_Event("UNIT0"));
for (int i = 0; i < 2; i++)
{
TimerTicker.NextTick();
}
Console.WriteLine("The end");
}
/*
* STAThread means the app uses Single-Threaded Apartment threading.
* It specifies the threading model used when you use COM interop.
* Likely it won't affect your program, since COM isn't usually
* needed in .NET in most cases.
*/
/// <summary>
/// Argumnts to main are
/// hostname
/// port number
/// simulation moel name
/// 'LIVE" to use network connections, else use crude simulation
/// Override the sleep interval given in the sim model file
/// </summary>
/// <param name="args"></param>
/// <remarks>arg 0: Scenario file
/// arg 1: schema file
/// arg 2: host name
/// arg 3: port number
/// arg 4: simulation model name
/// arg 5: if "NETWORK" (or not provid3ed) program is connected to real network layer;
/// else use a simulated mechanism
/// arg 6: Update frequency in millisec
/// arg 7: If GUI ((or absent) assume connected to real GUI; else simulate incoming messages
/// Note: Both arg 5 and arg 6 involve (different) simulated ways to generate incoming events
/// </remarks>
static void Main(string[] args)
{
//This does not get called by SimCoreTestGUI
DebugLogger.SetDebugStyleConsole();
List <string> loggingTypes = new List <string>();
loggingTypes.Add("test");
loggingTypes.Add("debug");
SimulationEventDistributor dist = null;
Coordinator boss = new Coordinator(args[0], args[1], null, ref dist, args[4], args[5], args[6], args[7], loggingTypes, @"C:\");
//add types of logging here
boss.CoordinateNow();
Coordinator.debugLogger.Writeline("Program.cs", "The end", "all");
}
static void Main(string[] args)
{
string scenarioFile = args[0];
new ScenarioToQueues(scenarioFile);
// string hostname = "dgeller";
string hostname=args[1];
// int port = 9999;
int port = int.Parse(args[2]);
// string simModelName = "SimulationModel.xml";
string simModelName = args[3];
NetworkClient c = new NetworkClient();
c.Connect(hostname, port);
EventCommunicator eventCommunicator = new EventCommunicator(c);
SimulationModelReader smr = new SimulationModelReader();
SimulationModelInfo simModelInfo = smr.readModel(simModelName);
SimulationEventDistributor dist = new SimulationEventDistributor(ref simModelInfo);
SimulationEventDistributorClient cc = new SimulationEventDistributorClient();
dist.RegisterClient(ref cc);
sink = new Watcher(400);
ThreadStart stub = new ThreadStart(sink.WatcherThread);
Thread stubThread = new Thread(stub);
stubThread.Start();
for (int i = 0; i < 5; i++) // in test the move happens at time 2
{
TimerTicker.NextTick();
}
IncomingList.Add(new MoveComplete_Event("UNIT0"));
for (int i = 0; i < 2; i++)
{
TimerTicker.NextTick();
}
Console.WriteLine("The end");
}
public SeamateProcessorSim()
{
time = 0;
blackboard = null;
bbClient = null;
distributor = null;
distClient = null;
simModel = null;
objectProxies = null;
scoreRulesExist = null;
handledAttacks = null;
dms = null;
classifications = null;
_terminalToDMMap = null;
IndividualDMIsLoggedIn = false;
objectAssignmentList = null;
_attackTargetHashes = null;
mostRecentItemsForStimulators = null;
}
public void Initialize(ref SimulationModelInfo simModel, ref Blackboard blackboard, ref SimulationEventDistributor distributor)
{
this.blackboard = blackboard;
this.bbClient = new BlackboardClient();
this.distributor = distributor;
this.distClient = new SimulationEventDistributorClient();
this.simModel = simModel;
distributor.RegisterClient(ref distClient);
//distClient.Subscribe("NewObject");
//distClient.Subscribe("RevealObject");
//distClient.Subscribe("StateChange");
//distClient.Subscribe("ResetSimulation");
blackboard.RegisterClient(ref bbClient);
bbClient.Subscribe("BaseObject", "ID", true, false);
bbClient.Subscribe("DecisionMaker", "RoleName", true, true);
bbClient.Subscribe("DecisionMaker", "TeamMember", true, true);
bbClient.Subscribe("PhysicalObject", "ObjectName", true, true);
bbClient.Subscribe("PhysicalObject", "OwnerID", true, true);
bbClient.Subscribe("PhysicalObject", "ClassName", true, true);
bbClient.Subscribe("PhysicalObject", "Size", true, true);
bbClient.Subscribe("PhysicalObject", "MaximumSpeed", true, true);
bbClient.Subscribe("PhysicalObject", "State", true, true);
bbClient.Subscribe("PhysicalObject", "StateTable", true, true);
bbClient.Subscribe("PhysicalObject", "Sensors", true, true);
bbClient.Subscribe("PhysicalObject", "Emitters", true, true);
bbClient.Subscribe("PhysicalObject", "LaunchDuration", true, true);
bbClient.Subscribe("PhysicalObject", "AttackDuration", true, true);
bbClient.Subscribe("PhysicalObject", "EngagementDuration", true, true);
bbClient.Subscribe("PhysicalObject", "DockingDuration", true, true);
bbClient.Subscribe("PhysicalObject", "IsWeapon", true, true);
bbClient.Subscribe("PhysicalObject", "IconName", true, true);
bbClient.Subscribe("PhysicalObject", "RemoveOnDestruction", true, true);
bbClient.Subscribe("PhysicalObject", "CustomAttributes", true, true);
bbClient.Subscribe("PhysicalObject", "CanOwn", true, true);
bbClient.Subscribe("PhysicalObject", "SubplatformLimit", true, true);
bbClient.Subscribe("PhysicalObject", "DefaultClassification", true, true);
bbClient.Subscribe("PhysicalObject", "ClassificationDisplayRules", true, true);
bbClient.Subscribe("PhysicalObject", "CurrentClassification", true, true);
objectProxies = new Dictionary <string, SimulationObjectProxy>();
}
public Form1(string simModel, string host, string port, string user)
{
InitializeComponent();
userID = user;
hostName = host;
portNumber = port;
simModelName = simModel;
simModelInfo = smr.readModel(simModelName);
AddToTextBoxText("Welcome " + userID + ".");
server = new NetworkClient();
server.Connect(hostName, Convert.ToInt32(portNumber));
SimulationEventDistributor dist = new SimulationEventDistributor(ref simModelInfo);
SimulationEventDistributorClient cc = new SimulationEventDistributorClient();
dist.RegisterClient(ref cc);
server.Subscribe("TextChat");
isRunning = true;
waitForEventsThread = new Thread(new ThreadStart(WaitForEvents));
waitForEventsThread.Start();
}
public void Initialize(ref SimulationModelInfo simModel, ref Blackboard blackboard, ref SimulationEventDistributor distributor)
{
this.blackboard = blackboard;
this.bbClient = new BlackboardClient();
this.distributor = distributor;
this.distClient = new SimulationEventDistributorClient();
this.simModel = simModel;
distributor.RegisterClient(ref distClient);
//distClient.Subscribe("RevealObject");
//distClient.Subscribe("SubplatformLaunch");
//distClient.Subscribe("WeaponLaunch");
//distClient.Subscribe("SubplatformDock");
//distClient.Subscribe("TimeTick");
//distClient.Subscribe("ResetSimulation");
//distClient.Subscribe("StateChange");
blackboard.RegisterClient(ref bbClient);
bbClient.Subscribe("PhysicalObject", "ID", true, false);
bbClient.Subscribe("PhysicalObject", "ParentObjectID", true, true);
bbClient.Subscribe("PhysicalObject", "OwnerID", true, false);
bbClient.Subscribe("PhysicalObject", "DockedToParent", true, true);
bbClient.Subscribe("PhysicalObject", "ChildObjects", true, true);
bbClient.Subscribe("PhysicalObject", "DockedObjects", true, true);
bbClient.Subscribe("PhysicalObject", "DockedWeapons", true, true);
bbClient.Subscribe("PhysicalObject", "LaunchStarted", true, true);
bbClient.Subscribe("PhysicalObject", "LaunchEndTime", true, true);
bbClient.Subscribe("PhysicalObject", "LaunchDestinationLocation", true, true);
bbClient.Subscribe("PhysicalObject", "LaunchDone", true, false);
bbClient.Subscribe("PhysicalObject", "LaunchDuration", true, false);
bbClient.Subscribe("PhysicalObject", "DockingStarted", true, true);
bbClient.Subscribe("PhysicalObject", "DockingEndTime", true, true);
bbClient.Subscribe("PhysicalObject", "LaunchIsWeapon", true, true);
bbClient.Subscribe("PhysicalObject", "LaunchWeaponTargetID", true, true);
bbClient.Subscribe("PhysicalObject", "DockingDuration", true, false);
bbClient.Subscribe("PhysicalObject", "IsWeapon", true, false);
bbClient.Subscribe("PhysicalObject", "ClassName", true, false);
objectProxies = new Dictionary <string, SimulationObjectProxy>();
}
//[STAThread]
static void Main(string[] args)
{
string hostname = args[0];
int port = Int32.Parse(args[1]);
string simModelName = args[2];
SimulationModelReader smr = new SimulationModelReader();
SimulationModelInfo simModelInfo = smr.readModel(simModelName);
SimulationEventDistributor dist = new SimulationEventDistributor(ref simModelInfo);
SimulationEventDistributorClient cc = new SimulationEventDistributorClient();
dist.RegisterClient(ref cc);
cc.Subscribe("ALL");
ScenarioReader scenarioReader = new ScenarioReader();
QueueManager queueManager = QueueManager.UniqueInstance();
c = new NetworkClient();
c.Connect(hostname, port);
EventListener myEL = EventListener.UniqueInstance(c);
int t = 0;
int dt = simModelInfo.simulationExecutionModel.updateFrequency;
SimulationEvent tick = SimulationEventFactory.BuildEvent(ref simModelInfo, "TimeTick");
((IntegerValue)tick["Time"]).value = t;
ConsoleKeyInfo cki;
//Console.TreatControlCAsInput = false; //This explodes my code for some reason, but is in Gabe's client code and works fine, what does it do?
Console.CancelKeyPress += new ConsoleCancelEventHandler(MyExitHandler);
List<SimulationEvent> events = null;
while (c.IsConnected() && queueManager.count() > 0)
{
//Read incoming events queue
//if any events deal with a conditional event, remove the conditional
//event from the conditional list, and place it onto the event queue
//if a unit dies, remove them from the event queue and condition list
while (c.IsConnected() && !(queueManager.eventsAtTime(t)))
{
events = c.GetEvents();
foreach (SimulationEvent e in events)
{
if (e.eventType == "MoveDone")
c.PutEvent(myEL.MoveDoneReceived(e, simModelInfo, tick));
System.Console.WriteLine(SimulationEventFactory.XMLSerialize(e));
}
((IntegerValue)tick["Time"]).value = t;
c.PutEvent(tick);
//Console.WriteLine("Sending...");
//Console.WriteLine(SimulationEventFactory.XMLSerialize(tick));
Thread.Sleep(dt);
t += dt;
}
if (c.IsConnected())
{
QueueManager.sendEventsAtTime(t, c);
((IntegerValue)tick["Time"]).value = t;
c.PutEvent(tick);
//Console.WriteLine("Sending...");
//Console.WriteLine(SimulationEventFactory.XMLSerialize(e));
t += dt;
}
}
while (c.IsConnected())
{
((IntegerValue)tick["Time"]).value = t;
c.PutEvent(tick);
//Console.WriteLine("Sending...");
//Console.WriteLine(SimulationEventFactory.XMLSerialize(tick));
Thread.Sleep(dt);
t += dt;
}
}
