Ejemplo n.º 1
0
        /// <summary>
        /// Coordinates all the processing for each time slice
        /// </summary>
        /// <param name="updateIncrement"></param>
        public static void NextTimeSlice()
        {


            /*
             * Initially the only items that would be named in events would be actual units.
             * Now that other things (ActiveRegions,for example) can also appear in events
             * it is necessary to allow UnitFActs to know those names too, to keep various checks on
             * object name legality from failing
             */
            /* 1. Process the incoming list of events from below */
            // Which units are currently on the incoming list?
            List<string> unitList = IncomingList.AffectedUnits();
            for (int i = 0; i < unitList.Count; i++)
            {
                List<IncomingItemType> eventList = IncomingList.Retrieve(unitList[i]);


                /* do things with these events */
                for (int j = 0; j < eventList.Count; j++)
                {
                    ScenarioEventType thisItem = eventList[j].TheEvent;
                    Coordinator.debugLogger.Writeline("Timer", "Time: " + timer + " Unit " + unitList[i] + " has incoming " + thisItem.GetType().ToString(), "test");

                    if (UnitFacts.AnyDead(thisItem.AllUnits))
                    {
                        continue;
                    }
                    Boolean launchedByOwner;
                    switch (thisItem.GetType().ToString())
                    {

                        case name_Space + "MoveComplete_Event":
                            {
                                Coordinator.debugLogger.Writeline("Timer", "Unit " + thisItem.UnitID + " MoveComplete discovered at t=" + timer.ToString(), "test");
                                // scan happenings list for matches                          
                                VerifyMatch = ActionMatch;
                                SeekHappening(thisItem.UnitID, "MoveComplete_Event");


                                SeekSpeciesHappening(thisItem, "MoveComplete_Event");

                            }
                            break;
                        case name_Space + "StateChangeNotice":
                            string newState = ((StateChangeNotice)thisItem).NewState;
                            Coordinator.debugLogger.Writeline("Timer", "Unit " + thisItem.UnitID + " StateChange to " + newState + " discovered at t=" + timer.ToString(), "test");

                            VerifyMatch = StateMatch;
                            List<string> affectedUnitList = new List<string>();
                            if ("Dead" != newState)
                            {
                                affectedUnitList.Add(thisItem.UnitID);

                                UnitFacts.CurrentUnitStates[thisItem.UnitID] = newState;// newState;

                            }
                            else              // Purge queues if the new state is "Dead"
                            {

                                affectedUnitList = SubplatformRecords.DeepDockedList(thisItem.UnitID);
                            }
                            for (int someUnit = 0; someUnit < affectedUnitList.Count; someUnit++)
                            {
                                if ("Dead" == newState)
                                {
                                    UnitFacts.CurrentUnitStates[affectedUnitList[someUnit]] = "Dead";// newState;
                                    //first drop all timer events involving this unit
                                    TimerQueueClass.FlushOneUnit(affectedUnitList[someUnit]);
                                }
                                SeekHappening(affectedUnitList[someUnit], newState);

                                //Then if dead, remove all happening events involving this unit
                                if ("Dead" == newState)
                                {
                                    HappeningList.FlushOneUnit(affectedUnitList[someUnit]);
                                    Coordinator.debugLogger.Writeline("Timer", " stateChangeEvent for  " + affectedUnitList[someUnit], "test");
                                }
                                SeekSpeciesHappening(thisItem, newState);
                            }
                            break;
                        case name_Space + "AttackSuccessfulNotice":
                            AttackSuccessfulNotice asn = (AttackSuccessfulNotice)thisItem;
                            for (int asi = 0; asi < AttackSuccessfulList.Happenings.Count; asi++)
                            {

                                AttackSuccessfulCompletionType tryThisEvent = AttackSuccessfulList.Happenings[asi];
                                if (tryThisEvent.Matches(asn))
                                {
                                    if (tryThisEvent.DoThisList.Count > 0)
                                        AttackSuccessfulCompletionType.EnqueueEvents(asn.UnitID, asn.Target, tryThisEvent.DoThisList);

                                    break;
                                }
                            }
                            break;
                        case name_Space + "AttackObjectRequestType":

                            Coordinator.debugLogger.Writeline("Timer", "Attack request for  " + thisItem.UnitID + "attack Request discovered at t=" + timer.ToString(), "test");

                            AttackObjectRequestType recastAOR = (AttackObjectRequestType)thisItem;

                            if (ApprovalsList.AttackApproved(recastAOR))
                            {
                                string attacker = recastAOR.UnitID;
                                string target = recastAOR.TargetObjectID;
                                AttackObjectEvent attack = new AttackObjectEvent(attacker, target, recastAOR.CapabilityName);
                                attack.AddOtherUnit(target);
                                TimerQueueClass.Add(1 + (int)(TimerTicker.Timer / 1000/*Coordinator.UpdateIncrement*/), attack);
                            }
                            else
                                TimerQueueClass.Add(1 + (int)(TimerTicker.Timer / 1000), new SystemMessage(1, recastAOR.UnitID, "Attack against " + recastAOR.TargetObjectID + " failed."));


                            break;

                        case name_Space + "WeaponLaunchRequestType":
                            WeaponLaunchRequestType recastWL = (WeaponLaunchRequestType)thisItem;
                            string unitID = recastWL.UnitID;
                            string weaponID = recastWL.WeaponID;
                            string targetID = recastWL.TargetObjectID;
                            Coordinator.debugLogger.Writeline("Timer", "Weapon Launch request for  " + unitID + " using " + weaponID + " Attack Request discovered at t=" + timer.ToString(), "test");

                            string platformOwner = UnitFacts.Data[unitID].Owner;
                            string weaponOwner = UnitFacts.Data[weaponID].Owner;
                            launchedByOwner = SpeciesType.GetSpecies(UnitFacts.Data[weaponID].Species).LaunchedByOwner;
                            //   )
                            if (
                               SubplatformRecords.IsLaunchableWeapon(unitID, weaponID)
                               &&
                               (
                               (platformOwner == recastWL.DecisionMaker)
                               ||
                               (weaponOwner == recastWL.DecisionMaker) && launchedByOwner
                                )
                               )
                            {
                                // validate attack
                                DecisionMakerType targetDM = DecisionMakerType.GetDM(UnitFacts.GetDM(targetID));
                                if (
                                    (launchedByOwner && UnitFacts.HostileTo(DecisionMakerType.GetDM(platformOwner).Team, targetDM.Team))
                                    ||
                                    (UnitFacts.HostileTo(DecisionMakerType.GetDM(weaponOwner).Team, targetDM.Team))
                                    //Removed !launchedByOwner from second statement
                                    )
                                {
                                    //NB. THe code that builds and sends the event was missing from here. It was last seen in rev 232.
                                    // its removeal was probably an accident?
                                    // build event to send down
                                    WeaponLaunch_EventType wEvent = new WeaponLaunch_EventType(unitID, targetID, weaponID);
                                    TimerQueueClass.Add(1 + (int)(timer / 1000), wEvent);
                                    // replace by new platform handling       

                                }
                            }
                            else
                            {
                                //need to throw an event back to ViewPro to re-allocate weapon
                                String reason = "";
                                if (!UnitFacts.Data.ContainsKey(unitID))
                                {
                                    reason = "Platform object is unknown by the system.";
                                }
                                else if (UnitFacts.Data[unitID].Owner != recastWL.DecisionMaker)
                                {
                                    reason = "Requesting DM does not own the Platform object.";
                                }

                                WeaponLaunchFailure_EventType failEvent = new WeaponLaunchFailure_EventType(weaponID, unitID, reason);
                                failEvent.Time = (int)(timer / 1000/*Coordinator.UpdateIncrement*/);
                                TimerQueueClass.Add(1 + (int)(timer / 1000/*Coordinator.UpdateIncrement*/), failEvent);
                            }
                            break;

                        case name_Space + "SubplatformLaunchRequestType":
                            SubplatformLaunchRequestType recastSL = (SubplatformLaunchRequestType)thisItem;
                            string childID = recastSL.UnitID;
                            string requestor = recastSL.Requestor;
                            string parentID = recastSL.ParentUnit;
                            LocationType destination = recastSL.Destination;
                            Coordinator.debugLogger.Writeline("Timer", "Subplatform Launch request for  " + childID + " from " + parentID + "  discovered at t=" + timer.ToString(), "test");
                            launchedByOwner = SpeciesType.GetSpecies(UnitFacts.Data[childID].Species).LaunchedByOwner;

                            if (
                             (UnitFacts.Data[parentID].Owner == requestor)
                             ||
                             (UnitFacts.Data[childID].Owner == requestor) && launchedByOwner
                             )
                            {
                                // build event to send down
                                SubplatformLaunchType slEvent = new SubplatformLaunchType(childID, parentID, destination);
                                TimerQueueClass.Add(1 + (int)(timer / 1000), slEvent);


                            }
                            /**/

                            break;
                        case name_Space + "SubplatformDockRequestType":
                            SubplatformDockRequestType recastSD = (SubplatformDockRequestType)thisItem;
                            string orphanID = recastSD.UnitID;
                            string dockRequestor = recastSD.Requestor;
                            string adopterID = recastSD.ParentUnit;

                            Coordinator.debugLogger.Writeline("Timer", "Subplatform Dock request for  " + orphanID + " from " + adopterID + "  discovered at t=" + timer.ToString(), "test");

                            if ("" != adopterID)
                            {
                                if (UnitFacts.Data.ContainsKey(orphanID)
                                    && UnitFacts.Data.ContainsKey(adopterID)
                                    && ((UnitFacts.Data[orphanID].Owner == dockRequestor)
                                    //     && (UnitFacts.Data[adopterID].Owner == dockRequestor)
                                        )
                                    && SpeciesType.GetSpecies(UnitFacts.GetSpecies(adopterID)).CanHaveSubplatform(UnitFacts.GetSpecies(orphanID))
                                    )
                                {
                                    /* for dock to any object*/
                                    SubplatformDockType sdEvent = new SubplatformDockType(orphanID, adopterID);
                                    TimerQueueClass.Add(1 + (int)(timer / 1000), sdEvent);



                                }
                            }// if  the parent is "" just ignore the request
                            else
                                TimerQueueClass.Add(1 + (int)(TimerTicker.Timer / 1000), new SystemMessage(1, dockRequestor, "Docking of " + orphanID + "to " + adopterID + " failed."));

                            break;
                        case name_Space + "MoveObjectRequestType":
                            // does this dM control this object
                            MoveObjectRequestType recastMove = (MoveObjectRequestType)thisItem;

                            Coordinator.debugLogger.Writeline("Timer", "Move request for  " + thisItem.UnitID + " discovered at t=" + timer.ToString(), "test");


                            if (UnitFacts.Data.ContainsKey(recastMove.UnitID) && (UnitFacts.Data[recastMove.UnitID].Owner == recastMove.DecisionMaker))
                            {
                                Move_EventType mover = new Move_EventType(recastMove.UnitID, TimerTicker.Timer, recastMove.Destination, recastMove.Throttle);
                                TimerQueueClass.Add(1 + (int)(TimerTicker.Timer / 1000/*Coordinator.UpdateIncrement*/), mover);
                            }
                            else
                                TimerQueueClass.Add(1 + (int)(TimerTicker.Timer / 1000), new SystemMessage(1, recastMove.DecisionMaker, "Move of " + recastMove.UnitID + " denied."));

                            break;

                        case name_Space + "TransferObjectRequest":
                            Boolean transferred = false;
                            TransferObjectRequest recastTransferRequest = (TransferObjectRequest)thisItem;
                            /*
                              * Transfer is allowed when
                              * (1) requestor is owner of asset and has transfer authority
                              * (2) owner of unit is  subordinate of requestor, who has forced transfer authority
                              * Unit is in a stealable state
                              * * */
                            DecisionMakerType unitDM = DecisionMakerType.GetDM(UnitFacts.GetDM(recastTransferRequest.UnitID));
                            DecisionMakerType requestingDM = DecisionMakerType.GetDM(recastTransferRequest.Requestor);
                            DecisionMakerType receivingDM = DecisionMakerType.GetDM(recastTransferRequest.Recipient);

                            // To know if stealable, need current state
                            Boolean inStealableState = false;
                            Dictionary<string, StateBody> allStates = StatesForUnits.GetExpandedStatesOf(recastTransferRequest.UnitID);
                            if (allStates.ContainsKey(recastTransferRequest.State))
                            {
                                StateBody thisState = allStates[recastTransferRequest.State];
                                inStealableState = thisState.Parameters.ContainsKey("Stealable");
                            }


                            if ((unitDM.Identifier == requestingDM.Identifier) && (requestingDM.HasTransferAuthority)
                                ||// does the path from requestor to unit contain and forced transfers?
                                (requestingDM.CanForceTransferOf(unitDM)
                                ||
                            (
                                inStealableState && (recastTransferRequest.Requestor == receivingDM.Identifier))))
                            {


                                if (receivingDM.CanOwn(recastTransferRequest.UnitID))
                                    transferred = UnitFacts.ChangeDM(recastTransferRequest.UnitID, recastTransferRequest.Recipient);
                            }
                            if (transferred)
                            {
                                TransferEvent confirmation = new TransferEvent(recastTransferRequest.UnitID, UnitFacts.GetDM(recastTransferRequest.UnitID), recastTransferRequest.Recipient);
                                EventCommunicator.SendEvent(confirmation);
                                VerifyMatch = ActionMatch;
                                SeekHappening(thisItem.UnitID, "TransferObject");
                                SeekSpeciesHappening(thisItem, "TransferObject");

                                //Note: Event here is successful transfer, not request
                            }
                            else
                                TimerQueueClass.Add(1 + (int)(TimerTicker.Timer / 1000), new SystemMessage(1, recastTransferRequest.Requestor, "Transfer of " + recastTransferRequest.UnitID + " to " + recastTransferRequest.Recipient + " denied."));

                            break;


                        case name_Space + "SelfDefenseAttackNotice":
                            /*
                             * Notice: Assuming that self-defense only against enemy and that the condition is satisfied
                             * by the attack, without any attention to who the enemy is.  Will surely need a "Team" level happenings queue in time
                             */
                            {
                                Coordinator.debugLogger.Writeline("Timer", "Unit " + thisItem.UnitID + " SelfDefenseAttackNotice discovered at t=" + timer.ToString(), "test");
                                // scan happenings list for matches    
                                VerifyMatch = ActionMatch;
                                SeekHappening(thisItem.UnitID, "SelfDefenseAttackNotice");




                                SeekSpeciesHappening(thisItem, "SelfDefenseAttackNotice");
                                break;
                            }// 
Ejemplo n.º 2
0
        public static void EnqueueEvents(string unitID, string target, List<object> doThese)
        {
            object performer;
            //     List<ScenarioEventType> newEventList = this.DoThisList;
            List<ScenarioEventType> newEventList = new List<ScenarioEventType>();
            for (int doThis = 0; doThis < doThese.Count; doThis++)
            {
                performer = doThese[doThis];

                switch (performer.GetType().Name.ToString())
                {
                    case "OpenChatRoomType":
                        newEventList.Add(new OpenChatRoomType((OpenChatRoomType)(doThese[doThis])));
                        break;
                    case "CloseChatRoomType":
                        newEventList.Add(new CloseChatRoomType((CloseChatRoomType)(doThese[doThis])));
                        break;
                    case "OpenWhiteboardRoomType":
                        newEventList.Add(new OpenWhiteboardRoomType((OpenWhiteboardRoomType)(doThese[doThis])));
                        break;
                    /*
            case "AddChattersType":
                newEventList.Add(new AddChattersType((AddChattersType)(this.DoThisList[doThis])));
                break;
            case "DropChattersType":
                newEventList.Add(new DropChattersType((DropChattersType)(this.DoThisList[doThis])));
                break;
                    */
                    case "Reveal_EventType":
                        newEventList.Add(new Reveal_EventType((Reveal_EventType)(doThese[doThis])));
                        break;
                    case "SubplatformLaunchType":
                        newEventList.Add(new SubplatformLaunchType((SubplatformLaunchType)(doThese[doThis])));
                        break;
                    case "SubplatformDockType":
                        newEventList.Add(new SubplatformDockType((SubplatformDockType)(doThese[doThis])));
                        break;
                    case "WeaponLaunch_EventType":
                        newEventList.Add(new WeaponLaunch_EventType((WeaponLaunch_EventType)(doThese[doThis])));
                        break;
                    case "Move_EventType":
                        newEventList.Add(new Move_EventType((Move_EventType)(doThese[doThis])));
                        break;
                    case "StateChangeEvent":
                        newEventList.Add(new StateChangeEvent((StateChangeEvent)(doThese[doThis])));
                        break;
                    case "TransferEvent":
                        TransferEvent te = new TransferEvent((TransferEvent)(doThese[doThis]));
                        te.Substitute(unitID, target);
                        newEventList.Add(te);
                        break;
                    case "LaunchEventType":
                        newEventList.Add(new LaunchEventType((LaunchEventType)(doThese[doThis])));
                        break;
                    case "AttackObjectEvent":
                        newEventList.Add(new AttackObjectEvent((AttackObjectEvent)(doThese[doThis])));
                        break;
                    case "ChangeEngramType":
                        newEventList.Add(new ChangeEngramType((ChangeEngramType)(doThese[doThis])));
                        break;
                    case "RemoveEngramEvent":
                        newEventList.Add(new RemoveEngramEvent((RemoveEngramEvent)(doThese[doThis])));
                        break;

                    default:
                        Coordinator.debugLogger.LogError("Scenario reader", "Unknown happening event type for " + performer.ToString());
                        break;
                }



            }
            for (int k = 0; k < newEventList.Count; k++)
            {
                ScenarioEventType newEvent = newEventList[k];
                if ("UNIT" == newEvent.UnitID)
                {
                    newEvent.UnitID = unitID;
                }
                else if ("TARGET" == newEvent.UnitID)
                {
                    newEvent.UnitID = target;
                }





                int index = newEvent.AllUnits.IndexOf("UNIT");
                if (-1 < index)
                {
                    newEvent.AllUnits[index] = unitID;
                }
                index = newEvent.AllUnits.IndexOf("TARGET");
                if (-1 < index)
                {
                    newEvent.AllUnits[index] = target;
                }
                if (null != newEvent.Range)
                {
                    EngramRange r = newEvent.Range;
                    if ("UNIT" == r.Unit)
                    {
                        r.Unit = unitID;
                    }
                    else if ("TARGET" == r.Unit)
                    {
                        r.Unit = target;
                    }

                }
                newEvent.Time = (1 + newEvent.Time) + (int)(TimerTicker.Timer / 1000/*Coordinator.UpdateIncrement*/);
                TimerQueueClass.Add(newEvent.Time, newEvent);
            }
        }
Ejemplo n.º 3
0
        /// <summary>
        /// Creates the class (one instance only) that parses a scenario and puts events on queues
        /// </summary>
        /// <param name="scenarioFile"></param>
        public ScenarioToQueues(string scenarioFile, string schemaFile)
        {

    

            TimerQueueClass timerQueue = new TimerQueueClass();
            // Extract fields from the XML file (and schema)
            // see http://weblogs.asp.net/dbrowning/articles/114561.aspx  
            // paths to xml/xsd
            // const string path = @"C:\Documents and Settings\dgeller\My Documents\Visual Studio 2005\Projects\";
            //const string scenarioFile = path + @"DDD\Scenario.xml";
            // const string xsdPath = path + @"XMLTrial\XMLTrial\ScenarioSchema.xsd";




            FileStream fs;
            Boolean returnVal;
//            ScenarioToQueues.schemaFile = schemaFile;

            //    try
            //  {
            returnVal = ValidateScenario(scenarioFile);
            // }
            /*    catch (System.Exception e)
                {

                    string message = "Failed to validate schema. " + e.Message;
                    Coordinator.debugLogger.LogException("Scenario Reader", message);
                    throw new ApplicationException(message, e);
                }*/

            if (!returnVal)
            {
                return;
            }


            try
            {
                fs = File.Open(scenarioFile, FileMode.Open);
            }
            catch (System.Exception e)
            {
                string message = "Could not open scenario file on pass 2." + e.Message;
                Coordinator.debugLogger.LogException("Scenario Reader", message);
                throw new ApplicationException(message, e);
            }

            /// XmlReader readerTwo;
            try
            {
                XmlSchemaSet sc = new XmlSchemaSet();
                sc.Add(null, ScenarioToQueues.namedSchemaFile);//+".xsd");
                XmlReaderSettings readerSettings = new XmlReaderSettings();

                // readerSettings.ValidationType = ValidationType.Schema;
                readerSettings.IgnoreWhitespace = true;
                // makes no difference ?!               readerSettings.IgnoreWhitespace = true;
                //   readerSettings.ValidationEventHandler += new ValidationEventHandler(SchemaValidationHandler);

                reader = XmlReader.Create(fs, readerSettings);
                parser.SetReader(reader);

            }
            catch (System.Exception e)
            {
                fs.Close();
                string message = "Could not open schema file. " + e.Message;
                Coordinator.debugLogger.LogException("Scenario Reader", message);
                throw new ApplicationException(message, e);

            }

            //Build reverse dictionary of commnds->stage
            //This lets us enforce moving through the commands in a prescribed order
            Dictionary<string, int> stages = new Dictionary<string, int>();
            string[][] stageMembers = parser.StageMembers();
            for (int level = 0; level < stageMembers.Length; level++)
            {
                for (int member = 0; member < stageMembers[level].Length; member++)
                {
                    stages[stageMembers[level][member]] = level;
                }
            }
            int currentStage = 0;
            string scenarioName = "";
            string description = "";


            reader.Read(); // opens, gets to xml declaration
            reader.Read();
            try
            {
                if ("Scenario" == reader.Name) // only Scenario can be top level
                {
                    reader.Read(); // pass by "Scenario"

                    while (!reader.EOF && !((XmlNodeType.EndElement == reader.NodeType) && ("Scenario" == reader.Name)))
                    {

                        //Coordinator.debugLogger.Writeline(".");

                        switch (reader.NodeType)
                        {

                            case XmlNodeType.Element:
                                Coordinator.debugLogger.Writeline("ScenarioToQueues", "ELEMENT " + reader.Name, "test");
                                if (stages.ContainsKey(reader.Name))
                                {
                                    if (stages[reader.Name] < currentStage) 
                                        throw new ApplicationException("Command " + reader.Name + " out of sequence.");
                                    currentStage = stages[reader.Name];
                                    //NB, if command is not found in stages it will be trapped in the switch's default
                                }
                                switch (reader.Name)
                                {

                                    case "ScenarioName":
                                        scenarioName = parser.pGetString();
                                        break;
                                    case "Description":
                                        description = parser.pGetString();
                                        break;
                                    case "ClientSideAssetTransfer":
                                        ClientSideAssetTransferType assetTransfers = new ClientSideAssetTransferType(parser.pGetBoolean());
                                        TimerQueueClass.SendBeforeStartup(assetTransfers);
                                        Coordinator.debugLogger.Writeline("ScenarioToQueues", " ClientSideAssetTransferType ", "test");
                                        break;
                                    case "ClientSideStartingLabelVisible":
                                        ClientSideStartingLabelVisibleType labelsVisible = new ClientSideStartingLabelVisibleType(parser.pGetBoolean());
                                        TimerQueueClass.SendBeforeStartup(labelsVisible);
                                        Coordinator.debugLogger.Writeline("ScenarioToQueues", " ClientSideStartingLabelVisibleType ", "test");
                                        break;
                                    case "ClientSideRangeRingVisibility":
                                        ClientSideRangeRingVisibilityType rangeRingVisibility = new ClientSideRangeRingVisibilityType(parser.pGetString());
                                        TimerQueueClass.SendBeforeStartup(rangeRingVisibility);
                                        Coordinator.debugLogger.Writeline("ScenarioToQueues", "ClientSideRangeRingVisibilityType", "test");
                                        break;
                                    case "Playfield":
                                        // except for the optional name/description
                                        // Playfield must be first scenario item sent
                                        // enforced by schema
                                        string errorText = string.Empty;
                                        string imgLibPath = string.Empty;
                                        string mapFilePath = string.Empty;
                                        string hostname = Aptima.Asim.DDD.CommonComponents.ServerOptionsTools.ServerOptions.HostName;
                                        pPlayfieldType pDefine = parser.pGetPlayfield();
                                        PlayfieldEventType playfield = new PlayfieldEventType(pDefine);
                                        playfield.ScenarioName = scenarioName;
                                        playfield.Description = description;
                                        if (playfield.IconLibrary.EndsWith(".dll"))
                                        {
                                            imgLibPath = String.Format(@"\\{0}\{1}", ServerOptions.DDDClientPath, playfield.IconLibrary); //icon library does include dll extension
                                        }
                                        else
                                        {
                                            imgLibPath = String.Format(@"\\{0}\{1}.dll", ServerOptions.DDDClientPath, playfield.IconLibrary); //icon library doesnt include dll extension
                                        }
                                        mapFilePath = String.Format(@"\\{0}\MapLib\{1}", ServerOptions.DDDClientPath, playfield.MapFileName); //map file includes file extension

                                        //check image library path
                                        if (!File.Exists(imgLibPath))
                                        {
                                            if (System.Windows.Forms.MessageBox.Show(String.Format("The server was not able to locate the image library in {0}.  There is a chance that clients connecting to this machine will have a similar issue locating this file.  If you'd still like to run the simulation, click Yes.  If you'd like to stop the server, click No.", imgLibPath), "File not found", System.Windows.Forms.MessageBoxButtons.YesNo, System.Windows.Forms.MessageBoxIcon.Information) == System.Windows.Forms.DialogResult.Yes)
                                            {//User wants to continue

                                            }
                                            else
                                            { //user wants to stop server
                                                throw new Exception("User Cancelled server process.  Server was unable to locate the image library at " + imgLibPath);
                                                return;
                                            }
                                        }

                                        //check map file path
                                        if (!File.Exists(mapFilePath))
                                        {
                                            if (System.Windows.Forms.MessageBox.Show(String.Format("The server was not able to locate the map file in {0}.  There is a chance that clients connecting to this machine will have a similar issue locating this file.  If you'd still like to run the simulation, click Yes.  If you'd like to stop the server, click No.", mapFilePath), "File not found", System.Windows.Forms.MessageBoxButtons.YesNo, System.Windows.Forms.MessageBoxIcon.Information) == System.Windows.Forms.DialogResult.Yes)
                                            {//User wants to continue

                                            }
                                            else
                                            { //user wants to stop server
                                                throw new Exception("User Cancelled server process.  Server was unable to locate the map file at " + mapFilePath);
                                                return;
                                            }
                                        }
                                        TimerQueueClass.SendBeforeStartup(playfield);
                                        Coordinator.debugLogger.Writeline("ScenarioToQueues", "Playfield", "test");
                                        
                                        TimerQueueClass.SendBeforeStartup(new RandomSeedType());
                                        break;
                                    case "LandRegion":
                                        pLandRegionType region = parser.pGetLandRegion();
                                        RegionEventType regionEvent = new RegionEventType(region);

                                        TimerQueueClass.SendBeforeStartup(regionEvent);
                                        Coordinator.debugLogger.Writeline("ScenarioToQueues", " LandRegion " + regionEvent.UnitID, "test");

                                        break;
                                    /*
                                case "ScoringRegion":
                                    pScoringRegionType regionS = parser.pGetScoringRegion();
                                    RegionEventType regionEventS = new RegionEventType(regionS);
                                    TimerQueueClass.SendBeforeStartup(regionEventS);
                                    Coordinator.debugLogger.Writeline("ScenarioToQueues", " ScoringRegion " + regionEventS.UnitID, "test");
                                    break;
                                    */
                                    case "ActiveRegion":
                                        pActiveRegionType regionA = parser.pGetActiveRegion();
                                        RegionEventType regionEventA = new RegionEventType(regionA);
                                        if (!NameLists.activeRegionNames.New(regionA.ID, regionEventA)) throw new ApplicationException("Duplicate active region name " + regionA.ID);
                                        TimerQueueClass.SendBeforeStartup(regionEventA);
                                        Coordinator.debugLogger.Writeline("ScenarioToQueues", " ActiveRegion " + regionEventA.UnitID, "test");
                                        break;
                                    case "Team":
                                        pTeamType team = parser.pGetTeam();
                                        TeamType teamEvent = new TeamType(team);
                                        for (int i = 0; i < teamEvent.Count(); i++)
                                        {
                                            UnitFacts.AddEnemy(teamEvent.Name, teamEvent.GetEnemy(i));

                                        }
                                        Coordinator.debugLogger.Writeline("ScenarioToQueues", " Team " + team.Name.ToString(), "test");
                                        if (!NameLists.teamNames.New(team.Name, teamEvent)) throw new ApplicationException("Duplicate team name " + team.Name);

                                        TimerQueueClass.SendBeforeStartup(teamEvent);
                                        break;
                                    case "DecisionMaker":
                                        DecisionMakerType decisionMaker = new DecisionMakerType(parser.pGetDecisionMaker());
                                        UnitFacts.AddDM(decisionMaker.Identifier, decisionMaker.Chroma, decisionMaker.Team);
                                        TimerQueueClass.SendBeforeStartup(decisionMaker);
                                        Coordinator.debugLogger.Writeline("ScenarioToQueues", "Decision Maker ", "test");
                                        break;
                                    case "Network":
                                        NetworkType network = new NetworkType(parser.pGetNetwork());
                                        NetworkTable.AddNetwork(network);
                                        TimerQueueClass.SendBeforeStartup(network);
                                        Coordinator.debugLogger.Writeline("ScenarioToQueues", "Network ", "test");
                                        break;


                                    case "Sensor":
                                        //sensor follows Playfield
                                        pSensor sen = parser.pGetSensor();
                                        // if Attribute is "all" there will be one cone; only extent is filled in from parser
                                        if (sen.Attribute == "All")
                                        {
                                            sen.Cones[0].Spread = 360;
                                            sen.Cones[0].Level = "Total";
                                        }
                                        SensorTable.Add(sen.Name, new SensorType(sen.Attribute, sen.IsEngram, sen.TypeIfEngram, sen.Cones));

                                        Coordinator.debugLogger.Writeline("ScenarioToQueues", " Sensor " + sen.Name.ToString(), "test");

                                        break;
                                    /*    case "TimeToRemove":
                                                Defaults.DefaultTimeToRemove = parser.pGetInt();
                                                break;
                                     */
                                    case "Classifications":
                                        ClassificationsType classifications = new ClassificationsType(parser.pGetClassifications());
                                        TimerQueueClass.SendBeforeStartup(classifications);
                                        Coordinator.debugLogger.Writeline("ScenarioToQueues", " Classifications ", "test");
                                        break;
                                    case "TimeToAttack":
                                        Defaults.DefaultTimeToAttack = parser.pGetInt()*1000;
                                        break;

                                    case "Genus":
                                        pGenusType g = parser.pGetGenus();
                                        if (!NameLists.speciesNames.New(g.Name, g))
                                            throw new ApplicationException("Duplicate use of genus name " + g.Name);
  
                                        Genealogy.Add(g.Name);


                                        Coordinator.debugLogger.Writeline("ScenarioToQueues", "Genus " + g.Name, "test");
                                        // StartupForUnits.Add(genus);
                                        break;

                                    case "Species":
                                        // Genus and species come after playfield


                                        pSpeciesType s = parser.pGetSpecies();
                                        SpeciesType species = new SpeciesType(s);
                                        if (!NameLists.speciesNames.New(species.Name, species))
                                            throw new ApplicationException("Duplicate use of species name " + species.Name);
                                        Genealogy.Add(species.Name, species.BasedOn);
                                        if (species.IsWeapon)
                                        {
                                            WeaponTable.Add(species.Name);
                                        }

                                        WorkStates.Clear();
                                        WorkStates.Add(species.States);
                                        StatesForUnits.AddStatesOf(species.Name, WorkStates.CollapseStates(species.Name, species.BasedOn));
                                        Coordinator.debugLogger.Writeline("ScenarioToQueues", "Species " + s.Name, "test");
                                        // StartupForUnits.Add(species);
                                        break;

                                    case "Create_Event":
                                        //string newId;
                                     //   Create_EventType platformCreate;//used for sub platforms
                                        pCreateType c = parser.pGetCreate();
                                        Create_EventType createEvent = new Create_EventType(c);
                                        Genealogy.Add(createEvent.UnitID, createEvent.UnitBase);
                                        createEvent.Genus = Genealogy.GetGenus(createEvent.UnitID);
                                        UnitFacts.AddUnit(createEvent.UnitID, createEvent.Owner,createEvent.UnitBase);
                                        createEvent.Parameters = new ObjectDictionary();

                                        SpeciesType speciesInfo = (SpeciesType)NameLists.speciesNames[createEvent.UnitBase];

                                        foreach (KeyValuePair<string, StateBody> kvp in StatesForUnits.StateTable[createEvent.UnitBase])
                                        {
                                            string stateName = kvp.Key;
                                            ExtendedStateBody extended = new ExtendedStateBody(kvp.Value);
                                            
                                            //end species dependent atts
                                            createEvent.Parameters.Add(stateName, (object)extended);
                                            //               EngramDependants.Add(createEvent.UnitID, extended);

                                           
                                        }

                                        


                                        //       TimerQueueClass.Add(1, createEvent);
                                        NameLists.unitNames.New(createEvent.UnitID, null);
                                        TimerQueueClass.SecondarySendBeforeStartup(createEvent);
                                        UnitFacts.CurrentUnitStates.Add(createEvent.UnitID, "");
                                        Coordinator.debugLogger.Writeline("ScenarioToQueues", "createEvent for " + createEvent.UnitID, "test");
                                  
                                        //for some reason this docs everyone at time 1.  this seems to be the heart of the bug
                                        /*
                                        for (int i = 0; i < createEvent.Subplatforms.Count;i++ )
                                   {
                                       SubplatformDockType dockNotice = new SubplatformDockType(createEvent.Subplatforms[i], createEvent.UnitID);
                                       dockNotice.Time = 1;
                                       TimerQueueClass.SecondarySendBeforeStartup(dockNotice);

                                   }
                                         */
                                   break;
                                    case "Reveal_Event":
                                        pRevealType r = parser.pGetReveal();
                                        Reveal_EventType revealEvent = new Reveal_EventType(r);
                                        revealEvent.Genus = Genealogy.GetGenus(revealEvent.UnitID);
                                        if (r.Time > 1)
                                        {
                                            TimerQueueClass.Add(r.Time, revealEvent);
                                        }
                                        else
                                        {
                                            TimerQueueClass.SecondarySendBeforeStartup(revealEvent);
                                        }
                                        Coordinator.debugLogger.Writeline("ScenarioToQueues", "revealEvent for  " + revealEvent.UnitID + " at time" + r.Time.ToString(), "test");
                                        RevealDocked(r.UnitID, r.Time);
                                        break;

                                    case "Move_Event":
                                        pMoveType m = parser.pGetMove();
                                        if (!UnitFacts.IsAUnit(m.UnitID)) throw new ApplicationException("Cannot move non-exsitant unit " + m.UnitID);
                                        Move_EventType moveEvent = new Move_EventType(m);
                                        TimerQueueClass.Add(moveEvent.Time, moveEvent);
                                        Coordinator.debugLogger.Writeline("ScenarioToQueues", " moveEvent for  " + moveEvent.UnitID, "test");
                                        break;
                                    case "Completion_Event":
                                        HappeningCompletionType completionType = new HappeningCompletionType(parser.pGetHappeningCompletion());
                                        HappeningList.Add(completionType);
                                        break;
                                    case "Species_Completion_Event":
                                        pSpeciesCompletionType sct = parser.pGetSpeciesCompletion();
                                        SpeciesCompletionType speciesCompletion = new SpeciesCompletionType(sct);
                                        SpeciesHappeningList.Add(speciesCompletion);
                                        break;
                                    case "Reiterate":
                                        ReiterateType reiterate = new ReiterateType(parser.pGetReiterate());
                                        Move_EventType mQueued = (Move_EventType)(reiterate.ReiterateList[0]);
                                        Move_EventType mQCopy = (Move_EventType)(reiterate.ReiterateList[0]);
                                        mQueued.Range = reiterate.Range;
                                        mQueued.Time = reiterate.Time;
                                        TimerQueueClass.Add(mQueued.Time, mQueued);

                                        Coordinator.debugLogger.Writeline("ScenarioToQueues", " moveEvent from reiterate for  " + mQueued.UnitID, "test");
                                        reiterate.ReiterateList.RemoveAt(0);
                                        reiterate.ReiterateList.Add(mQCopy);
                                        HappeningCompletionType envelope = new HappeningCompletionType(reiterate);
                                        HappeningList.Add(envelope);
                                        break;
                                    case "StateChange_Event":
                                        StateChangeEvent change = new StateChangeEvent(parser.pGetStateChange());
                                        if (!UnitFacts.IsAUnit(change.UnitID)) throw new ApplicationException("State change event references unknown unit " + change.UnitID);
                                        if (!StatesForUnits.UnitHasState(change.UnitID, change.NewState)) throw new ApplicationException("State chage for " + change.UnitID + " refers to unknwon state " + change.NewState);
                                        for (int i = 0; i < change.Except.Count; i++)
                                        {
                        //                    if (!StatesForUnits.UnitHasState(Genealogy.GetBase(change.UnitID), change.Except[i])) throw new ApplicationException("State change for " + change.UnitID + " refers to unknown state " + change.Except);
                                            if (!StatesForUnits.UnitHasState(change.UnitID, change.Except[i])) throw new ApplicationException("State change for " + change.UnitID + " refers to unknown state " + change.Except);
                            
                                        }
                                        for (int i = 0; i < change.From.Count; i++)
                                        {
                            //                if (!StatesForUnits.UnitHasState(Genealogy.GetBase(change.UnitID), change.From[i])) throw new ApplicationException("State change for " + change.UnitID + " refers to unknown state " + change.From);
                                            if (!StatesForUnits.UnitHasState(change.UnitID, change.From[i])) throw new ApplicationException("State change for " + change.UnitID + " refers to unknown state " + change.From);
                               
                                        }
                                        TimerQueueClass.Add(change.Time, change);
                                        break;
                                    case "Transfer_Event":
                                        TransferEvent t = new TransferEvent(parser.pGetTransfer());

                                        if (!UnitFacts.IsDM(t.From)) throw new ApplicationException("Transfer event references unknown DM (from) " + t.From);
                                        if (!UnitFacts.IsDM(t.To)) throw new ApplicationException("Transfer event references unknown DM (to) " + t.To);
                                        if (!UnitFacts.IsAUnit(t.UnitID)) throw new ApplicationException("Transfer event references unknown unit " + t.UnitID);
                                        TimerQueueClass.Add(t.Time, t);
                                        break;
                                    case "Launch_Event":
                                        LaunchEventType launch = new LaunchEventType(parser.pGetLaunch());
                                        if (!UnitFacts.IsAUnit(launch.UnitID)) throw new ApplicationException("Cannot launch from non-existent unit " + launch.UnitID);
                                        TimerQueueClass.Add(launch.Time, launch);


                                        break;
                                    case "WeaponLaunch_Event":

                                        WeaponLaunchEventType weaponLaunch = new WeaponLaunchEventType(parser.pGetWeaponLaunch());
                                        if (!UnitFacts.IsAUnit(weaponLaunch.UnitID)) throw new ApplicationException("Cannot launch from non-existent unit " + weaponLaunch.UnitID);
                                        TimerQueueClass.Add(weaponLaunch.Time, weaponLaunch);


                                        break;
                                    case "DefineEngram":
                                        pDefineEngramType defineEngram = parser.pGetDefineEngram();
                                        Engrams.Create(defineEngram.Name, defineEngram.EngramValue, defineEngram.Type);
                                        TimerQueueClass.SendBeforeStartup(new EngramSettingType(defineEngram.Name, "", defineEngram.EngramValue, defineEngram.Type));
                                        break;
                                    case "ChangeEngram":
                                        ChangeEngramType changeEngram = new ChangeEngramType(parser.pGetChangeEngram());
                                        if (!Engrams.ValidUpdate(changeEngram.Name, changeEngram.EngramValue))
                                            throw new ApplicationException("Illegal value " + changeEngram.EngramValue + " for engram " + changeEngram.Name);
                                        TimerQueueClass.Add(changeEngram.Time, changeEngram);
                                        //  Engrams.SendUpdate(changeEngram.Name);
                                        break;
                                    case "RemoveEngram":
                                        RemoveEngramEvent removeEngram = new RemoveEngramEvent(parser.pGetRemoveEngram());
                                        TimerQueueClass.Add(removeEngram.Time, removeEngram);
                                        break;
                                    //These chat commands are those from the scenario only;
                                    // thos from client are handled immediately
                                    case "OpenChatRoom":
                                        OpenChatRoomType openChatRoom = new OpenChatRoomType(parser.pGetOpenChatRoom());
                                        TimerQueueClass.Add(openChatRoom.Time, openChatRoom);
                                        break;
                                    case "CloseChatRoom":
                                        CloseChatRoomType closeChatRoom = new CloseChatRoomType(parser.pGetCloseChatRoom());

                                        TimerQueueClass.Add(closeChatRoom.Time, closeChatRoom);
                                        break;
                                    /* Not implemented yet 
                                       case "DropChatters":
                                           DropChattersType dropChatters = new DropChattersType(parser.pGetDropChatters());
                                           TimerQueueClass.Add(dropChatters.Time, dropChatters);
                                           break;
                                       case "AddChatters":
                                           AddChattersType addChatters = new AddChattersType(parser.pGetAddChatters());
                                           TimerQueueClass.Add(addChatters.Time, addChatters);
                                           break;

                                   */
                                    case "OpenWhiteboardRoom":
                                        OpenWhiteboardRoomType openWhiteboardRoom = new OpenWhiteboardRoomType(parser.pGetOpenWhiteboardRoom());
                                        TimerQueueClass.Add(openWhiteboardRoom.Time, openWhiteboardRoom);
                                        break;
                                    case "OpenVoiceChannel":
                                        OpenVoiceChannelType openVoiceChannel = new OpenVoiceChannelType(parser.pGetOpenVoiceChannel());
                                        TimerQueueClass.Add(openVoiceChannel.Time, openVoiceChannel);
                                        break;
                                    case "CloseVoiceChannel":
                                        CloseVoiceChannelType closeVoiceChannel = new CloseVoiceChannelType(parser.pGetCloseVoiceChannel());
                                        TimerQueueClass.Add(closeVoiceChannel.Time, closeVoiceChannel);
                                        break;
                                        /*
                                         //Removed before 4.1
                                    case "GrantVoiceChannelAccess":
                                        GrantVoiceAccessType grantVoiceChannelAccess = new GrantVoiceAccessType(parser.pGetGrantVoiceChannelAccess());
                                        TimerQueueClass.Add(grantVoiceChannelAccess.Time, grantVoiceChannelAccess);
                                        break;
                                    case "RemoveVoiceChannelAccess":
                                        RemoveVoiceAccessType removeVoiceChannelAccess = new RemoveVoiceAccessType(parser.pGetRemoveVoiceChannelAccess());
                                        TimerQueueClass.Add(removeVoiceChannelAccess.Time, removeVoiceChannelAccess);
                                        break;
                                        */
                                    case "Rule":
                                        pScoringRuleType srt = parser.pGetScoringRule();
                                        ScoringRuleType scoreRule = new ScoringRuleType(srt);
                                        if (!NameLists.ruleNames.New(srt.Name, scoreRule)) throw new ApplicationException("Duplicate scoring rule name " + srt.Name);
                                        ScoringRules.Add(scoreRule);
                                        break;
                                    case "Score":
                                        pScoreType pst = parser.pGetScore();
                                        ScoreType st = new ScoreType(pst);
                                        if (!NameLists.scoreNames.New(pst.Name, st)) throw new ApplicationException("Duplicate score name " + pst.Name);
                                        Scores.Register(st);
                                        break;

                                    case "FlushEvents":
                                        FlushEvents flush = new FlushEvents(parser.pGetFlushEventsType());
                                        TimerQueueClass.Add(flush.Time, flush);
                                        break;

                                    case "SendChatMessage":
                                        SendChatMessageType sendChat = new SendChatMessageType(parser.pGetSendChatMessage());
                                        if (!UnitFacts.IsDM(sendChat.Sender) && !("EXP" == sendChat.Sender))
                                            throw new ApplicationException("In SendChatMessage, '" + sendChat.Sender + "' is not a valid DM name.");
                            // Note: Can't validate chat room name at parse time; it might not have been created yet
                                        TimerQueueClass.Add(sendChat.Time,sendChat);
                                        break;
                                    case "Apply":
                                        ApplyType apply = new ApplyType(parser.pGetApply());
                                        //what does this do?
                                        TimerQueueClass.Add(apply.Time, apply);
                                        break;
                                    case "SendVoiceMessage":
                                        SendVoiceMessageType playVoiceMessage = new SendVoiceMessageType(parser.pGetSendVoiceMessage());
                                        //what does this do?
                                        TimerQueueClass.Add(playVoiceMessage.Time, playVoiceMessage);
                                        break;
                                    case "SendVoiceMessageToUser":
                                        SendVoiceMessageToUserType playVoiceMessageToUser = new SendVoiceMessageToUserType(parser.pGetSendVoiceMessageToUser());
                                        //what does this do?
                                        TimerQueueClass.Add(playVoiceMessageToUser.Time, playVoiceMessageToUser);
                                        break;
                                    default:
                                        throw new ApplicationException("ScenarioToQueues: Unknown Scenario Element is *" + reader.Name);


                                }//switch
                                break;
                            default:
                                Coordinator.debugLogger.Writeline("ScenarioToQueues", "Unhandled or out-of-sequence XML tag " + reader.Value, "test");
                                reader.Read();
                                break;



                        } //switch

                    } //while
                    // All of scenario processed. Now do last things

                    //verify that the Chat, Whiteboard, and Voice lists contain only DMs and make them symmetric.
                    List<string> allDMs = UnitFacts.GetAllDms();
                    for (int i = 0; i < allDMs.Count; i++)
                    {
                        DecisionMakerType thisDM = DecisionMakerType.GetDM(allDMs[i]);

                        for (int j = 0; j < thisDM.ChatPartners.Count; j++)
                        {
                            if (!allDMs.Contains(thisDM.ChatPartners[j]))
                                throw new ApplicationException("Unknown decision maker name '" + thisDM.ChatPartners[j] + "' found as chat partner of '" + allDMs[i] + "'");
                            DecisionMakerType partnerDM = DecisionMakerType.GetDM(thisDM.ChatPartners[j]);
                            if (!partnerDM.ChatPartners.Contains(allDMs[i]))
                                partnerDM.MayChatWith(allDMs[i]);
                        }

                        for (int j = 0; j < thisDM.WhiteboardPartners.Count; j++)
                        {
                            if (!allDMs.Contains(thisDM.WhiteboardPartners[j]))
                                throw new ApplicationException("Unknown decision maker name '" + thisDM.WhiteboardPartners[j] + "' found as whiteboard partner of '" + allDMs[i] + "'");
                            DecisionMakerType partnerDM = DecisionMakerType.GetDM(thisDM.WhiteboardPartners[j]);
                            if (!partnerDM.WhiteboardPartners.Contains(allDMs[i]))
                                partnerDM.MayWhiteboardWith(allDMs[i]);
                        }

                        for (int j = 0; j < thisDM.VoicePartners.Count; j++)
                        {
                            if (!allDMs.Contains(thisDM.ChatPartners[j]))
                                throw new ApplicationException("Unknown decision maker name '" + thisDM.VoicePartners[j] + "' found as voice partner of '" + allDMs[i] + "'");
                            DecisionMakerType partnerDM = DecisionMakerType.GetDM(thisDM.VoicePartners[j]);
                            if (!partnerDM.VoicePartners.Contains(allDMs[i]))
                                partnerDM.MaySpeakWith(allDMs[i]);
                        }

                    }

                    // Add networks for DMs that have none
                    List<string> dmList = UnitFacts.GetAllDms();
                    for (int nextDM = 0; nextDM < dmList.Count; nextDM++)
                    {
                        if (!NetworkTable.IsNetworkMember(dmList[nextDM]))
                        {
                            string netName = "Network-For-" + dmList[nextDM];
                            NetworkTable.AddMember(netName, dmList[nextDM]);
                            NetworkType newNet = new NetworkType(netName);
                            newNet.Add(dmList[nextDM]);
                            TimerQueueClass.SendBeforeStartup(newNet);
                            Coordinator.debugLogger.Writeline("ScenarioToQueues", "Network ", "test");

                        }
                    }
                    //AD: Don't create default chat room, user should have control of this
                    // Create the detault Broadcast chatroom
                    //OpenChatRoomType broadcastChatRoom = new OpenChatRoomType(1, "", "Broadcast", dmList);
                    //TimerQueueClass.SendBeforeStartup(broadcastChatRoom);

                }//if
            }
            catch (System.Exception e)
            {
                if (e.Message.StartsWith("User Cancelled"))
                {//This means a missing map or icon library, and the user wanted to stop the server.  Do not write to error log, just stop the server. 
                    throw e;
                }
                string message = "Failure in Parsing Control for next tag=" + reader.Name + " : " + e.Message;
                Coordinator.debugLogger.LogException("ScenarioReader", message);
                throw new ApplicationException(message, e);
            }
            finally
            {
                reader.Close();
                fs.Close();
                // Coordinator.debugLogger.Writeline("ScenarioToQueues", "Done", "general");
            }
        }//
Ejemplo n.º 4
0
 public TransferEvent(TransferEvent t)
     : base(t.UnitID, t.Time)
 {
     this.from = t.From;
     this.to = t.To;
 }
Ejemplo n.º 5
0
     private static void SendTransferEvent(TransferEvent incoming)
        {
            SimulationEvent e = SimulationEventFactory.BuildEvent(ref simModelInfo, "TransferObject");

            try
            {
                e["Time"] = DataValueFactory.BuildInteger(incoming.Time);//ConvertInteger(incoming.Timer);
                e["UserID"] = DataValueFactory.BuildString(incoming.To);
                e["DonorUserID"] = DataValueFactory.BuildString(incoming.From);
                e["ObjectID"] = DataValueFactory.BuildString(incoming.UnitID);
            }
            catch (SystemException ev)
            {
                throw new Exception("Missing a required attribute for Transfer notice.", ev);

            }
            server.PutEvent(e);

        }