Exemplo n.º 1
0
        /// <summary>
        /// Gets events but ignores all but timer ticke
        /// </summary>
        /// <param name="r">The event</param>
        public void EventGetter(RootEventType r)
        {
            if (r.GetType() == typeof(TickEventType))
            {
                thisTimer = r.Time;
                wait = true;
            }

        }
Exemplo n.º 2
0
 public static void SecondarySendBeforeStartup(RootEventType r)
 {
     secondaryImmediateQueue.Enqueue(r);
 }
Exemplo n.º 3
0
        /// <summary>
        /// This method receives a ScenCon event, and transforms the
        /// data into a valid SimCore event.  At this point, the 
        /// event is sent out to the network, and received by those
        /// objects subscribing to those types of events.
        /// Parameter:
        /// sendingEvent: A base ScenCon event, using GetType we can
        /// find out what type of event it is, and based on that info
        /// we can create the correct SimCore event to distribute.
        /// <param name="sendingEvent">
        /// <br><B>Sending event</B> is a Dennis style event, whose info gets converted
        /// and packaged in a Gabe styled event, and then added to the outgoing queue.
        /// </br></param>
        /// </summary>
        public static void SendEvent(RootEventType sendingEvent)
        {
            //This will discover the RootEventType's actual Type of event,
            //and then based on that, will break out the information into 
            //a simulation model event, and then putEvent to the NetworkClient
            string eventType;
            eventType = sendingEvent.GetType().Name.ToString();
            SimulationEvent e = null;
            Dictionary<string, DataValue> myAtt;

            switch (eventType)
            {
                case "StartupCompleteNotice":
                    SendStartupCompleteEvent();
                    break;

                /******************New Object Event Type Creation ******************************/
                case "Create_EventType":
                    SendCreateEvent((Create_EventType)sendingEvent);
                    break; //Break from New Event Type

                /******************Move Object Event Type Creation******************************/
                case "Move_EventType":
                    SendMoveEvent((Move_EventType)sendingEvent);
                    break;
                /*****************Update Tag Event Type ***************/
                case "UpdateTagType":
                    SendUpdateTagEvent((UpdateTagType)sendingEvent);
                    break;

                /******************Tick Event Type Creation*************************************/
                case "TickEventType":
                    e = SimulationEventFactory.BuildEvent(ref simModelInfo, "TimeTick");
                    e["Time"] = DataValueFactory.BuildInteger(sendingEvent.Time);//ConvertInteger(sendingEvent.Timer);
                    e["SimulationTime"] = DataValueFactory.BuildString(((TickEventType)sendingEvent).SimulationTime);
                    latestTick = sendingEvent.Time;
                    server.PutEvent(e);
                    break;

                /******************Attack Object Event Type Creation****************************/
                case "AttackObjectEvent":
                    e = SimulationEventFactory.BuildEvent(ref simModelInfo, "AttackObject");

                    try
                    {
                        e["ObjectID"] = DataValueFactory.BuildString(((AttackObjectEvent)sendingEvent).UnitID);//ConvertString(((AttackObjectEvent)sendingEvent).UnitID);
                        e["TargetObjectID"] = DataValueFactory.BuildString(((AttackObjectEvent)sendingEvent).TargetObjectID);//ConvertString(((AttackObjectEvent)sendingEvent).TargetObjectID);
                        e["CapabilityName"] = DataValueFactory.BuildString(((AttackObjectEvent)sendingEvent).CapabilityName);//ConvertString(((AttackObjectEvent)sendingEvent).CapabilityName);
                        e["Time"] = DataValueFactory.BuildInteger(sendingEvent.Time);//(sendingEvent.Timer);
                    }
                    catch
                    {
                        throw new Exception("Missing required members of Attack Object Event");
                    }
                    server.PutEvent(e);
                    break;

                /******************Playfield Event Entered *************************************/
                case "PlayfieldEventType":
                    e = SimulationEventFactory.BuildEvent(ref simModelInfo, "Playfield");

                    try
                    {
                        e["MapDataFile"] = DataValueFactory.BuildString(((PlayfieldEventType)sendingEvent).MapFileName);//ConvertString(((PlayfieldEventType)sendingEvent).MapFileName);
                        e["IconLibrary"] = DataValueFactory.BuildString(((PlayfieldEventType)sendingEvent).IconLibrary);//ConvertString(((PlayfieldEventType)sendingEvent).IonLibrary);
                        e["UTMZone"] = DataValueFactory.BuildString(((PlayfieldEventType)sendingEvent).UTMZone); //ConvertString(((PlayfieldEventType)sendingEvent).UTMZone);


                        //e["UTMNorthing"] = DataValueFactory.BuildDouble(((PlayfieldEventType)sendingEvent).VerticalScale);
                        //e["UTMEasting"] = DataValueFactory.BuildDouble(((PlayfieldEventType)sendingEvent).HorizontalScale);
                        e["VerticalScale"] = DataValueFactory.BuildDouble(((PlayfieldEventType)sendingEvent).VerticalScale);
                        e["HorizontalScale"] = DataValueFactory.BuildDouble(((PlayfieldEventType)sendingEvent).HorizontalScale);


                        e["Time"] = DataValueFactory.BuildInteger(sendingEvent.Time);//ConvertInteger(sendingEvent.Timer);
                        e["Name"] = DataValueFactory.BuildString(((PlayfieldEventType)sendingEvent).ScenarioName);//ConvertString(((PlayfieldEventType)sendingEvent).ScenarioName);
                        string description = ((PlayfieldEventType)sendingEvent).Description;
                        description = description.Replace("\n", " ");
                        description = description.Replace("\t", " ");
                        e["Description"] = DataValueFactory.BuildString(description);//ConvertString(description);

                        e["DefaultDisplayLabels"] = DataValueFactory.BuildString(((PlayfieldEventType)sendingEvent).DisplayLabels);//ConvertString(description);
                        e["DefaultDisplayTags"] = DataValueFactory.BuildString(((PlayfieldEventType)sendingEvent).DisplayTags);//ConvertString(description);
                    }
                    catch
                    {
                        throw new Exception("Missing a required attribute for Playfield");
                    }
                    server.PutEvent(e);
                    break;

                /******************Decision Maker Entered **************************************/

                case "DecisionMakerType":
                    e = SimulationEventFactory.BuildEvent(ref simModelInfo, "NewObject");
                    myAtt = new Dictionary<string, DataValue>();

                    try
                    {
                        e["ObjectType"] = DataValueFactory.BuildString("DecisionMaker");
                        myAtt.Add("RoleName", DataValueFactory.BuildString(((DecisionMakerType)sendingEvent).Role));
                        myAtt.Add("TeamMember", DataValueFactory.BuildString(((DecisionMakerType)sendingEvent).Team));
                        myAtt.Add("Color", DataValueFactory.BuildInteger(((DecisionMakerType)sendingEvent).Chroma));
                        myAtt.Add("Briefing", DataValueFactory.BuildString(((DecisionMakerType)sendingEvent).Briefing));
                        myAtt.Add("CanTransfer", DataValueFactory.BuildBoolean(((DecisionMakerType)sendingEvent).HasTransferAuthority));
                        myAtt.Add("ReportsTo", DataValueFactory.BuildStringList(((DecisionMakerType)sendingEvent).Supervisors));
                        myAtt.Add("CanForceTransfer", DataValueFactory.BuildBoolean(((DecisionMakerType)sendingEvent).HasForcedTransferAuthority));
                        myAtt.Add("CanChat", DataValueFactory.BuildStringList(((DecisionMakerType)sendingEvent).ChatPartners));
                        myAtt.Add("CanWhiteboard", DataValueFactory.BuildStringList(((DecisionMakerType)sendingEvent).WhiteboardPartners));
                        myAtt.Add("CanSpeak", DataValueFactory.BuildStringList(((DecisionMakerType)sendingEvent).VoicePartners));
                        myAtt.Add("IsObserver", DataValueFactory.BuildBoolean(((DecisionMakerType)sendingEvent).IsObserver));
                        ////myAtt.Add("ComputerControlled", DataValueFactory.BuildBoolean(((DecisionMakerType)sendingEvent).ComputerControlled));
                        myAtt.Add("ComputerControlled", DataValueFactory.BuildBoolean(false));
                        e["ID"] = DataValueFactory.BuildString(((DecisionMakerType)sendingEvent).Identifier);
                        e["Time"] = DataValueFactory.BuildInteger(sendingEvent.Time);
                        e["Attributes"] = DataValueFactory.BuildAttributeCollection(myAtt);
                        
                    }
                    catch
                    {
                        throw new Exception("Missing a required attribute for Decision Maker");
                    }
                    server.PutEvent(e);
                    break;

                /*************** Reveal Event Entered ****************************/

                case "Reveal_EventType":
                    SendRevealEvent((Reveal_EventType)sendingEvent);
                    break;

                /*************** Random Seed Event Entered ****************************/
                case "RandomSeedType":
                    e = SimulationEventFactory.BuildEvent(ref simModelInfo, "RandomSeed");
                    try
                    {
                        e["Time"] = DataValueFactory.BuildInteger(sendingEvent.Time);//ConvertInteger(sendingEvent.Timer);
                        e["SeedValue"] = DataValueFactory.BuildInteger(((RandomSeedType)sendingEvent).seed);//ConvertInteger(((RandomSeedType)sendingEvent).seed);
                    }
                    catch
                    {
                        throw new Exception("Missing a required attribute for Random Seed.");
                    }
                    server.PutEvent(e);
                    break;

                /**********************************Team Definition Event *********************/

                case "TeamType":
                    e = SimulationEventFactory.BuildEvent(ref simModelInfo, "NewObject");

                    try
                    {
                        e["Time"] = DataValueFactory.BuildInteger(sendingEvent.Time);
                        myAtt = new Dictionary<string, DataValue>();
                        myAtt.Add("TeamName", DataValueFactory.BuildString(((TeamType)sendingEvent).Name));
                        List<string> hostilities = new List<string>();
                        for (int x = 0; x < ((TeamType)sendingEvent).Count(); x++)
                        {
                            hostilities.Add(((TeamType)sendingEvent)[x]);
                        }
                        StringListValue listOfHostiles = new StringListValue();
                        listOfHostiles.strings = hostilities;
                        myAtt.Add("TeamHostility", (DataValue)listOfHostiles);
                        e["Attributes"] = DataValueFactory.BuildAttributeCollection(myAtt);
                        e["ID"] = DataValueFactory.BuildString(((TeamType)sendingEvent).Name);
                        e["ObjectType"] = DataValueFactory.BuildString("Team");
                        //e["StateTable"] = DataValueFactory.BuildString(string.Empty);
                    }
                    catch
                    {
                        throw new Exception("Missing a required attribute for Team definition.");
                    }
                    server.PutEvent(e);
                    break;

                /**********************************Network Definition Event *********************/

                case "NetworkType":
                    e = SimulationEventFactory.BuildEvent(ref simModelInfo, "NewObject");

                    try
                    {
                        e["Time"] = DataValueFactory.BuildInteger(sendingEvent.Time);
                        myAtt = new Dictionary<string, DataValue>();
                        List<string> members = new List<string>();
                        for (int x = 0; x < ((NetworkType)sendingEvent).Count(); x++)
                        {
                            members.Add(((NetworkType)sendingEvent)[x]);
                        }
                        StringListValue listOfMembers = new StringListValue();
                        listOfMembers.strings = members;
                        myAtt.Add("DMMembers", (DataValue)listOfMembers);
                        e["Attributes"] = DataValueFactory.BuildAttributeCollection(myAtt);
                        e["ID"] = DataValueFactory.BuildString(((NetworkType)sendingEvent).Name);
                        e["ObjectType"] = DataValueFactory.BuildString("SensorNetwork");
                        //e["StateTable"] = DataValueFactory.BuildString(string.Empty);
                    }
                    catch
                    {
                        throw new Exception("Missing a required attribute for Network definition.");
                    }
                    server.PutEvent(e);
                    break;

                /******************* Region Definition ********************************************/

                case "RegionEventType":
 
                    e = SimulationEventFactory.BuildEvent(ref simModelInfo, "NewObject");

                    try
                    {
                        e["Time"] = DataValueFactory.BuildInteger(sendingEvent.Time);
                        myAtt = new Dictionary<string, DataValue>();
                        List<PolygonValue.PolygonPoint> listOfPoints = new List<PolygonValue.PolygonPoint>();
                        PolygonValue.PolygonPoint point;
                        foreach (PointType pt in ((RegionEventType)sendingEvent).Vertices)
                        {
                            point = new PolygonValue.PolygonPoint(pt.X, pt.Y);
                            listOfPoints.Add(point);
                        }
                        PolygonValue pointsList = new PolygonValue();
                        pointsList.points = listOfPoints;
                        myAtt.Add("Polygon", (DataValue)pointsList);
                        e["ObjectType"] = DataValueFactory.BuildString("LandRegion");
                        if (((RegionEventType)sendingEvent).End != null)
                        {
                            myAtt.Add("EndHeight", DataValueFactory.BuildDouble((double)((RegionEventType)sendingEvent).End));
                            e["ObjectType"] = DataValueFactory.BuildString("ScoringRegion");
                        }
                        if (((RegionEventType)sendingEvent).Start != null)
                        {
                            myAtt.Add("StartHeight", DataValueFactory.BuildDouble((double)((RegionEventType)sendingEvent).Start));
                        }

                        if (((RegionEventType)sendingEvent).ReferencePoint != null) {
                            PointType refPoint = ((RegionEventType)sendingEvent).ReferencePoint;
                            myAtt.Add("ReferencePoint", DataValueFactory.BuildLocation(refPoint.X,refPoint.Y,0,true));
                        }

                        if (((RegionEventType)sendingEvent).IsDynamicRegion != null)
                        {
                       
                            myAtt.Add("IsDynamicRegion", DataValueFactory.BuildBoolean((bool)((RegionEventType)sendingEvent).IsDynamicRegion));
                        }

                        if (((RegionEventType)sendingEvent).SpeedMultiplier != null)
                        {
                            myAtt.Add("SpeedMultiplier", DataValueFactory.BuildDouble((double)((RegionEventType)sendingEvent).SpeedMultiplier));
                            e["ObjectType"] = DataValueFactory.BuildString("ActiveRegion");
                        }
                        if (((RegionEventType)sendingEvent).BlocksMovement != null)
                        {
                            myAtt.Add("BlocksMovement", DataValueFactory.BuildBoolean((Boolean)((RegionEventType)sendingEvent).BlocksMovement));
                        }
                        //if (((RegionEventType)sendingEvent).BlocksMovement != null)
                        //{
                        //    myAtt.Add("BlocksMovement", DataValueFactory.BuildBoolean((Boolean)((RegionEventType)sendingEvent).BlocksMovement));
                        //}


                        List<string> sensorsBlocked = new List<string>();
                        if (
                            (((RegionEventType)sendingEvent).SensorsBlocked != null)
                            &&
                            (((RegionEventType)sendingEvent).SensorsBlocked.Count > 0))
                        {
                            //                string sensorBlocked;
                            for (int sensor = 0; sensor < ((RegionEventType)sendingEvent).SensorsBlocked.Count; sensor++)
                            {

                                sensorsBlocked.Add(((RegionEventType)sendingEvent).SensorsBlocked[sensor]);
                            }

                        }
                        StringListValue mySensorsBlocked = new StringListValue();
                        mySensorsBlocked.strings = sensorsBlocked;
                        myAtt.Add("BlocksSensorTypes", (DataValue)mySensorsBlocked);

                        myAtt.Add("IsVisible", DataValueFactory.BuildBoolean((Boolean)((RegionEventType)sendingEvent).IsVisible));
                        myAtt.Add("IsActive", DataValueFactory.BuildBoolean((Boolean)((RegionEventType)sendingEvent).IsActive));
 
                        myAtt.Add("DisplayColor", DataValueFactory.BuildInteger((int)((RegionEventType)sendingEvent).Chroma));
                        try
                        {
                            if (((RegionEventType)sendingEvent).ObstructedViewImage != "" && ((RegionEventType)sendingEvent).ObstructedViewImage != null)
                            {
                                myAtt.Add("ObstructedViewImage", DataValueFactory.BuildString(((RegionEventType)sendingEvent).ObstructedViewImage));
                            }
                        }catch(Exception ex)
                        {}
                        try
                        { 
                            myAtt.Add("ObstructionOpacity", DataValueFactory.BuildString(((RegionEventType)sendingEvent).ObstructionOpacity.ToString()));
                        }catch(Exception ex2)
                        {}

                        //e["BlocksSensorTypes"]=
                        e["ID"] = DataValueFactory.BuildString(((RegionEventType)sendingEvent).UnitID);
                        e["Attributes"] = DataValueFactory.BuildAttributeCollection(myAtt);
                    }
                    catch
                    {
                        throw new Exception("Missing a required attribute for Region definition");
                    }
                    server.PutEvent(e);

                    break;

                case "ActiveRegionUpdateType":
                    SendActiveRegionUpdateEvent((ActiveRegionUpdateType)sendingEvent);
                    break;
                case "WeaponLaunch_EventType":
                    SendWeaponLaunchEvent((WeaponLaunch_EventType)sendingEvent);
                    break;
                case "WeaponLaunchFailure_EventType":
                    SendWeaponLaunchFailureEvent((WeaponLaunchFailure_EventType)sendingEvent);
                    break;
                case "LaunchEventType":
                    SendLaunchEvent((LaunchEventType)sendingEvent);
                    break;
                case "WeaponLaunchEventType":
                    SendWeaponLaunchEvent((WeaponLaunchEventType)sendingEvent);
                    break;
                case "SubplatformLaunchType":
                    SendSubplatformLaunchEvent((SubplatformLaunchType)sendingEvent);
                    break;
                case "SubplatformDockType":
                    SendSubplatformDockEvent((SubplatformDockType)sendingEvent);
                    break;
                case "StateChangeEvent":
                    SendStateChangeEvent((StateChangeEvent)sendingEvent);
                    break;
                case "OpenChatRoomType":
                    SendOpenChatRoomEvent((OpenChatRoomType)sendingEvent);
                    break;
                case "CloseChatRoomType":
                    SendCloseChatRoomType((CloseChatRoomType)sendingEvent);
                    break;
                case "OpenWhiteboardRoomType":
                    SendOpenWhiteboardRoomEvent((OpenWhiteboardRoomType)sendingEvent);
                    break;
                case "OpenVoiceChannelType":
                    SendOpenVoiceChannelEvent((OpenVoiceChannelType)sendingEvent);
                    break;
                case "CloseVoiceChannelType":
                    SendCloseVoiceChannelType((CloseVoiceChannelType)sendingEvent);
                    break;
                    /*
                case "GrantVoiceAccessType":
                    SendAddToVoiceChannelEvent((GrantVoiceAccessType)sendingEvent);
                    break;
                case "RemoveVoiceAccessType":
                    SendRemoveFromVoiceChannelEvent((RemoveVoiceAccessType)sendingEvent);
                    break;
                    
                case "CreateChatRoomFailureType":
                    SendCreateChatRoomFailureType((CreateChatRoomFailureType)sendingEvent);
                    break;*/
                case "TransferEvent":
                    SendTransferEvent((TransferEvent)sendingEvent);
                    break;
                    case "EngramSettingType":
                    SendEngramValue(((EngramSettingType)sendingEvent));
                    break;
                case "ChangeEngramType":
                    SendEngramValue(((ChangeEngramType)sendingEvent));
                    break;
                case "ClientSideAssetTransferType":
                    e = SimulationEventFactory.BuildEvent(ref simModelInfo, "ClientSideAssetTransferAllowed");
                    try
                    {
                        e["Time"] = DataValueFactory.BuildInteger(sendingEvent.Time);//ConvertInteger(sendingEvent.Timer);
                        e["EnableAssetTransfer"] = DataValueFactory.BuildBoolean(((ClientSideAssetTransferType)sendingEvent).assetTransferEnabled);//ConvertInteger(((RandomSeedType)sendingEvent).seed);
                    }
                    catch
                    {
                        throw new Exception("Missing a required attribute for ClientSideAssetTransferType");
                    }
                    server.PutEvent(e);
                    break;
                case "ClientSideStartingLabelVisibleType":
                    /* AD: TODO
                    e = SimulationEventFactory.BuildEvent(ref simModelInfo, "ClientSideAssetTransferAllowed");
                    try
                    {
                        e["Time"] = DataValueFactory.BuildInteger(sendingEvent.Time);//ConvertInteger(sendingEvent.Timer);
                        e["EnableAssetTransfer"] = DataValueFactory.BuildBoolean(((ClientSideAssetTransferType)sendingEvent).assetTransferEnabled);//ConvertInteger(((RandomSeedType)sendingEvent).seed);
                    }
                    catch
                    {
                        throw new Exception("Missing a required attribute for ClientSideAssetTransferType");
                    }
                    server.PutEvent(e);
                     */
                    break;
                case "ClientSideRangeRingVisibilityType":
                    e = SimulationEventFactory.BuildEvent(ref simModelInfo, "ClientSideRangeRingDisplayLevel");
                    try
                    {
                        e["Time"] = DataValueFactory.BuildInteger(sendingEvent.Time);
                        e["Value"] = DataValueFactory.BuildString(((ClientSideRangeRingVisibilityType)sendingEvent).clientSideRangeRingVisibility);
                    }
                    catch
                    {
                        throw new Exception("Missing a required attribute for ClientSideRangeRingVisibilityType");
                    }
                    server.PutEvent(e);
                    break;
                case "SendChatMessageType":
                    SendChatMessageType scm = (SendChatMessageType)sendingEvent;
                    /* Done in Timer...  
                       * if (!ChatRooms.IsRoom(scm.RoomName))
                           break;  */

                    try
                    {
                        e = SimulationEventFactory.BuildEvent(ref simModelInfo, "TextChatRequest");
                        e["ChatBody"] = DataValueFactory.BuildString(scm.Message);
                        e["UserID"] = DataValueFactory.BuildString(scm.Sender);
                        e["TargetUserID"] = DataValueFactory.BuildString(scm.RoomName);
                    }
                    catch
                    {
                        throw new Exception("Missing a required attribute for SendChatMessage");
                    }
                    server.PutEvent(e);

                    break;
                case "SendVoiceMessageType":
                    SendVoiceMessageType svm = (SendVoiceMessageType)sendingEvent;
                    try
                    {
                        e = SimulationEventFactory.BuildEvent(ref simModelInfo, "PlayVoiceMessage");
                        e["Channel"] = DataValueFactory.BuildString(svm.ChannelName);
                        e["File"] = DataValueFactory.BuildString(svm.FilePath);
                        e["Time"] = DataValueFactory.BuildInteger(svm.Time);
                    }
                    catch
                    {
                        throw new Exception("Missing a required attribute for SendVoiceMessage");
                    }
                    server.PutEvent(e);

                    break;

                case "SendVoiceMessageToUserType":
                    SendVoiceMessageToUserType svmtu = (SendVoiceMessageToUserType)sendingEvent;
                    try
                    {
                        e = SimulationEventFactory.BuildEvent(ref simModelInfo, "PlayVoiceMessageToUser");
                        e["DecisionMakerID"] = DataValueFactory.BuildString(svmtu.DecisionMakerID);
                        e["File"] = DataValueFactory.BuildString(svmtu.FilePath);
                        e["Time"] = DataValueFactory.BuildInteger(svmtu.Time);
                    }
                    catch
                    {
                        throw new Exception("Missing a required attribute for SendVoiceMessageToUser");
                    }
                    server.PutEvent(e);

                    break;

                case "SystemMessage":
                    SystemMessage sm = (SystemMessage)sendingEvent;
                    e = SimulationEventFactory.BuildEvent(ref simModelInfo, "SystemMessage");
                    e["PlayerID"] = DataValueFactory.BuildString(sm.Addressee);
                    e["Message"] = DataValueFactory.BuildString(sm.Message);
                    e["TextColor"] = DataValueFactory.BuildInteger(sm.TextColor);
                    e["DisplayMode"] = DataValueFactory.BuildString(sm.DisplayMode);
                    server.PutEvent(e);
                    break;

                case "ClassificationsType":
                    e = SimulationEventFactory.BuildEvent(ref simModelInfo, "InitializeClassifications");
                    try
                    {
                        e["Time"] = DataValueFactory.BuildInteger(sendingEvent.Time);
                        e["Classifications"] = DataValueFactory.BuildStringList(((ClassificationsType)sendingEvent).classifications);
                    }
                    catch
                    {
                        throw new Exception("Missing a required attribute for ClientSideRangeRingVisibilityType");
                    }
                    server.PutEvent(e);
                    break;
                case "ForkReplayEventType":
                    server.PutEvent(((ForkReplayEventType)sendingEvent).Event);
                    break;
                /******************No valid event entered***************************************/
                /******************Very Basic Event Type Creation*******************************/
                case "RootEventType":
                    throw new Exception("RootEventType events should not be created");

                /******************Base Scenario Event Type Creation****************************/
                case "ScenarioEventType":
                    throw new Exception("ScenarioEventType events should not be created");  
                default:
                    //What should it do in this case? Nothing?
                    Console.Out.Write("In EventCommunicator: Missing event type to send: " + eventType);
                    break;
            }
        }