Ejemplo n.º 1
0
        public virtual bool OpRaiseEvent(byte eventCode, bool sendReliable, object customEventContent, byte channelId,
                                         EventCaching cache, int[] targetActors, ReceiverGroup receivers, byte interestGroup, bool forwardToWebhook)
        {
            var opParameters = new Dictionary <byte, object> {
                [ParameterCode.Code] = eventCode
            };

            if (customEventContent != null)
            {
                opParameters[ParameterCode.Data] = customEventContent;
            }
            if (cache != EventCaching.DoNotCache)
            {
                opParameters[ParameterCode.Cache] = (byte)cache;
            }
            if (receivers != ReceiverGroup.Others)
            {
                opParameters[ParameterCode.ReceiverGroup] = (byte)receivers;
            }
            if (interestGroup != 0)
            {
                opParameters[ParameterCode.Group] = interestGroup;
            }
            if (targetActors != null)
            {
                opParameters[ParameterCode.ActorList] = targetActors;
            }
            if (forwardToWebhook)
            {
                opParameters[ParameterCode.EventForward] = true; //TURNBASED
            }

            return(OpCustom(OperationCode.RaiseEvent, opParameters, sendReliable, channelId, false));
        }
Ejemplo n.º 2
0
    public override bool OpRaiseEvent(byte eventCode, Hashtable evData, bool sendReliable, byte channelId, EventCaching cache, ReceiverGroup receivers)
    {
        if (PhotonNetwork.offlineMode)
        {
            return false;
        }

        return base.OpRaiseEvent(eventCode, evData, sendReliable, channelId, cache, receivers);
    }
Ejemplo n.º 3
0
    public override bool OpRaiseEvent(byte eventCode, Hashtable evData, bool sendReliable, byte channelId, int[] targetActors, EventCaching cache)
    {
        if (PhotonNetwork.offlineMode)
        {
            return false;
        }

        return base.OpRaiseEvent(eventCode, evData, sendReliable, channelId, targetActors, cache);
    }
Ejemplo n.º 4
0
        /// <summary>
        /// Calls operation RaiseEvent on the server, with full control of event-caching and the target receivers.
        /// </summary>
        /// <remarks>
        /// This method is described in one of its overloads.
        ///
        /// The cache parameter defines if and how this event will be cached server-side. Per event-code, your client
        /// can store events and update them and will send cached events to players joining the same room.
        ///
        /// The option EventCaching.DoNotCache matches the default behaviour of RaiseEvent.
        /// The option EventCaching.MergeCache will merge the costomEventContent into existing one.
        /// Values in the customEventContent Hashtable can be null to remove existing values.
        ///
        /// With the receivers parameter, you can chose who gets this event: Others (default), All (includes you as sender)
        /// or MasterClient. The MasterClient is the connected player with the lowest ActorNumber in this room.
        /// This player could get some privileges, if needed.
        ///
        /// Read more about Cached Events in the DevNet: http://doc.exitgames.com
        /// </remarks>
        /// <param name="eventCode">Identifies this type of event (and the content). Your game's event codes can start with 0.</param>
        /// <param name="customEventContent">Custom data you want to send along (use null, if none).</param>
        /// <param name="sendReliable">If this event has to arrive reliably (potentially repeated if it's lost).</param>
        /// <param name="channelId">Number of channel to use (starting with 0).</param>
        /// <param name="cache">Events can be cached (merged and removed) for players joining later on.</param>
        /// <param name="receivers">Controls who should get this event.</param>
        /// <returns>If operation could be enqueued for sending.</returns>
        public virtual bool OpRaiseEvent(byte eventCode, Hashtable customEventContent, bool sendReliable, byte channelId, EventCaching cache, ReceiverGroup receivers)
        {
            Dictionary<byte, object> opParameters = new Dictionary<byte, object>();
            opParameters[(byte)LiteOpKey.Data] = customEventContent;
            opParameters[(byte)LiteOpKey.Code] = (byte)eventCode;

            if (cache != EventCaching.DoNotCache)
            {
               opParameters[(byte)LiteOpKey.Cache] = (byte)cache;
            }

            if (receivers != ReceiverGroup.Others)
            {
                opParameters[(byte)LiteOpKey.ReceiverGroup] = (byte)receivers;
            }

            return this.OpCustom((byte)LiteOpCode.RaiseEvent, opParameters, sendReliable, channelId, false);
        }
Ejemplo n.º 5
0
        public virtual bool OpRaiseEvent(byte eventCode, bool sendReliable, object customEventContent, byte channelId, EventCaching cache, int[] targetActors, ReceiverGroup receivers, byte interestGroup)
        {
            Dictionary <byte, object> customOpParameters = new Dictionary <byte, object>();

            customOpParameters[(byte)244] = (object)eventCode;
            if (customEventContent != null)
            {
                customOpParameters[(byte)245] = customEventContent;
            }
            if (cache != EventCaching.DoNotCache)
            {
                customOpParameters[(byte)247] = (object)cache;
            }
            if (receivers != ReceiverGroup.Others)
            {
                customOpParameters[(byte)246] = (object)receivers;
            }
            if ((int)interestGroup != 0)
            {
                customOpParameters[(byte)240] = (object)interestGroup;
            }
            if (targetActors != null)
            {
                customOpParameters[(byte)252] = (object)targetActors;
            }
            return(this.OpCustom((byte)253, customOpParameters, sendReliable, channelId, false));
        }
Ejemplo n.º 6
0
        ///<summary>
        /// Calls operation RaiseEvent on the server, with full control of event-caching and the target receivers.
        /// </summary>
        /// <remarks>
        /// This method is described in one of its overloads.

        /// The cache parameter defines if and how this event will be cached server-side. Per event-code, your client
        /// can store events and update them and will send cached events to players joining the same room.

        /// The option EventCaching.DoNotCache matches the default behaviour of RaiseEvent.
        /// The option EventCaching.MergeCache will merge the costomEventContent into existing one.
        /// Values in the customEventContent Hashtable can be null to remove existing values.

        /// With the receivers parameter, you can chose who gets this event: Others (default), All (includes you as sender)
        /// or MasterClient. The MasterClient is the connected player with the lowest ActorNumber in this room.
        /// This player could get some privileges, if needed.

        /// Read more about Cached Events in the DevNet: http://doc.exitgames.com
        /// </remarks>
        /// <param name="eventCode">Identifies this type of event (and the content). Your game's event codes can start with 0.</param>
        /// <param name="customEventContent">Custom data you want to send along (use null, if none).</param>
        /// <param name="sendReliable">If this event has to arrive reliably (potentially repeated if it's lost).</param>
        /// <param name="channelId">Number of channel to use (starting with 0).</param>
        /// <param name="cache">Events can be cached (merged and removed) for players joining later on.</param>
        /// <param name="receivers">Controls who should get this event.</param>
        /// <returns>If operation could be enqueued for sending.</returns>
        public virtual bool OpRaiseEvent(byte eventCode, bool sendReliable, object customEventContent, byte channelId, EventCaching cache, int[] targetActors, ReceiverGroup receivers, byte interestGroup)
        {
            Dictionary <byte, object> opParameters = new Dictionary <byte, object>();

            opParameters[0xf4] = eventCode;
            if (customEventContent != null)
            {
                opParameters[0xf5] = customEventContent;
            }
            if (cache != EventCaching.DoNotCache)
            {
                opParameters[0xf7] = (byte)cache;
            }
            if (receivers != ReceiverGroup.Others)
            {
                opParameters[0xf6] = (byte)receivers;
            }
            if (interestGroup != 0)
            {
                opParameters[240] = interestGroup;
            }
            if (targetActors != null)
            {
                opParameters[0xfc] = targetActors;
            }
            return(this.OpCustom(0xfd, opParameters, sendReliable, channelId, false));
        }
Ejemplo n.º 7
0
        /// <summary>
        /// Used in a room to raise (send) an event to the other players.
        /// Multiple overloads expose different parameters to this frequently used operation.
        /// </summary>
        /// <param name="eventCode">Code for this "type" of event (use a code per "meaning" or content).</param>
        /// <param name="evData">Data to send. Hashtable that contains key-values of Photon serializable datatypes.</param>
        /// <param name="sendReliable">Use false if the event is replaced by a newer rapidly. Reliable events add overhead and add lag when repeated.</param>
        /// <param name="channelId">The "channel" to which this event should belong. Per channel, the sequence is kept in order.</param>
        /// <param name="targetActors">Defines the target players who should receive the event (use only for small target groups).</param>
        /// <param name="cache">Use EventCaching options to store this event for players who join.</param>
        /// <returns>If the operation could be sent (has to be connected).</returns>
        public virtual bool OpRaiseEvent(byte eventCode, Hashtable evData, bool sendReliable, byte channelId, int[] targetActors, EventCaching cache)
        {
            if (this.DebugOut >= DebugLevel.INFO)
            {
                this.Listener.DebugReturn(DebugLevel.INFO, "OpRaiseEvent()");
            }

            Dictionary <byte, object> opParameters = new Dictionary <byte, object>();

            opParameters[ParameterCode.Data] = evData;
            opParameters[ParameterCode.Code] = (byte)eventCode;

            if (cache != EventCaching.DoNotCache)
            {
                opParameters[ParameterCode.Cache] = (byte)cache;
            }

            if (targetActors != null)
            {
                opParameters[ParameterCode.ActorList] = targetActors;
            }

            return(this.OpCustom(OperationCode.RaiseEvent, opParameters, sendReliable, channelId));
        }
Ejemplo n.º 8
0
    /// <summary>
    /// Used in a room to raise (send) an event to the other players. 
    /// Multiple overloads expose different parameters to this frequently used operation.
    /// </summary>
    /// <param name="eventCode">Code for this "type" of event (use a code per "meaning" or content).</param>
    /// <param name="evData">Data to send. Hashtable that contains key-values of Photon serializable datatypes.</param>
    /// <param name="sendReliable">Use false if the event is replaced by a newer rapidly. Reliable events add overhead and add lag when repeated.</param>
    /// <param name="channelId">The "channel" to which this event should belong. Per channel, the sequence is kept in order.</param>
    /// <param name="targetActors">Defines the target players who should receive the event (use only for small target groups).</param>
    /// <param name="cache">Use EventCaching options to store this event for players who join.</param>
    /// <returns>If the operation could be sent (has to be connected).</returns>
    public virtual bool OpRaiseEvent(byte eventCode, Hashtable evData, bool sendReliable, byte channelId, int[] targetActors, EventCaching cache)
    {
        if (this.DebugOut >= DebugLevel.INFO)
        {
            this.Listener.DebugReturn(DebugLevel.INFO, "OpRaiseEvent()");
        }

        Dictionary<byte, object> opParameters = new Dictionary<byte, object>();
        opParameters[ParameterCode.Data] = evData;
        opParameters[ParameterCode.Code] = (byte)eventCode;

        if (cache != EventCaching.DoNotCache)
        {
            opParameters[ParameterCode.Cache] = (byte)cache;
        }

        if (targetActors != null)
        {
            opParameters[ParameterCode.ActorList] = targetActors;
        }

        return this.OpCustom(OperationCode.RaiseEvent, opParameters, sendReliable, channelId);
    }
Ejemplo n.º 9
0
 public virtual bool OpRaiseEvent(byte eventCode, bool sendReliable, object customEventContent, byte channelId,
                                  EventCaching cache, int[] targetActors, ReceiverGroup receivers, byte interestGroup)
 {
     return(OpRaiseEvent(eventCode, sendReliable, customEventContent, channelId, cache, targetActors, receivers,
                         interestGroup, false));
 }
Ejemplo n.º 10
0
 public virtual bool OpRaiseEvent(byte eventCode, Hashtable evData, bool sendReliable, byte channelId,
                                  EventCaching cache, ReceiverGroup receivers)
 {
     return(OpRaiseEvent(eventCode, sendReliable, evData, channelId, cache, null, receivers, 0, false));
 }
Ejemplo n.º 11
0
        public virtual bool OpRaiseEvent(byte eventCode, bool sendReliable, object customEventContent, byte channelId, EventCaching cache, int[] targetActors, ReceiverGroup receivers, byte interestGroup, bool forwardToWebhook)
        {
            Dictionary<byte, object> opParameters = new Dictionary<byte, object>();
            opParameters[(byte)ParameterCode.Code] = (byte)eventCode;

            if (customEventContent != null)
            {
                opParameters[(byte)ParameterCode.Data] = customEventContent;
            }
            if (cache != EventCaching.DoNotCache)
            {
                opParameters[(byte)ParameterCode.Cache] = (byte)cache;
            }
            if (receivers != ReceiverGroup.Others)
            {
                opParameters[(byte)ParameterCode.ReceiverGroup] = (byte)receivers;
            }
            if (interestGroup != 0)
            {
                opParameters[(byte)ParameterCode.Group] = (byte)interestGroup;
            }
            if (targetActors != null)
            {
                opParameters[(byte)ParameterCode.ActorList] = targetActors;
            }
            if (forwardToWebhook)
            {
                opParameters[(byte) ParameterCode.EventForward] = true; //TURNBASED
            }

            return this.OpCustom((byte)OperationCode.RaiseEvent, opParameters, sendReliable, channelId, false);
        }
Ejemplo n.º 12
0
 public virtual bool OpRaiseEvent(byte eventCode, bool sendReliable, object customEventContent, byte channelId, EventCaching cache, int[] targetActors, ReceiverGroup receivers, byte interestGroup)
 {
     return OpRaiseEvent(eventCode, sendReliable, customEventContent, channelId, cache, targetActors, receivers, interestGroup, false);
 }
Ejemplo n.º 13
0
 public virtual bool OpRaiseEvent(byte eventCode, Hashtable evData, bool sendReliable, byte channelId, EventCaching cache, ReceiverGroup receivers)
 {
     return this.OpRaiseEvent(eventCode, sendReliable, evData, channelId, cache, null, receivers, 0, false);
 }
Ejemplo n.º 14
0
 public virtual bool OpRaiseEvent(byte eventCode, Hashtable evData, bool sendReliable, byte channelId, int[] targetActors, EventCaching cache)
 {
     return this.OpRaiseEvent(eventCode, sendReliable, evData, channelId, cache, targetActors, ReceiverGroup.Others, 0, false);
 }
Ejemplo n.º 15
0
    public override bool OpRaiseEvent(byte eventCode, bool sendReliable, object customEventContent, byte channelId, EventCaching cache, int[] targetActors, ReceiverGroup receivers, byte interestGroup)
    {
        if (PhotonNetwork.offlineMode)
        {
            return false;
        }

        return base.OpRaiseEvent(eventCode, sendReliable, customEventContent, channelId, cache, targetActors, receivers, interestGroup);
    }
Ejemplo n.º 16
0
    /// <summary>
    /// Send an event with custom code/type and any content to the other players in the same room.
    /// </summary>
    /// <remarks>This override explicitly uses another parameter order to not mix it up with the implementation for Hashtable only.</remarks>
    /// <param name="eventCode">Identifies this type of event (and the content). Your game's event codes can start with 0.</param>
    /// <param name="sendReliable">If this event has to arrive reliably (potentially repeated if it's lost).</param>
    /// <param name="customEventContent">Any serializable datatype (including Hashtable like the other OpRaiseEvent overloads).</param>
    /// <param name="channelId">Command sequence in which this command belongs. Must be less than value of ChannelCount property. Default: 0.</param>
    /// <param name="cache">Affects how the server will treat the event caching-wise. Can cache events for players joining later on or remove previously cached events. Default: DoNotCache.</param>
    /// <param name="targetActors">List of ActorNumbers (in this room) to send the event to. Overrides caching. Default: null.</param>
    /// <param name="receivers">Defines a target-player group. Default: Others.</param>
    /// <param name="interestGroup">Defines to which interest group the event is sent. Players can subscribe or unsibscribe to groups. Group 0 is always sent to all. Default: 0.</param>
    /// <returns>If operation could be enqueued for sending. Sent when calling: Service or SendOutgoingCommands.</returns>
    public virtual bool OpRaiseEvent(byte eventCode, bool sendReliable, object customEventContent, byte channelId, EventCaching cache, int[] targetActors, ReceiverGroup receivers, byte interestGroup)
    {
        Dictionary <byte, object> opParameters = new Dictionary <byte, object>();

        opParameters[(byte)LiteOpKey.Code] = (byte)eventCode;

        if (customEventContent != null)
        {
            opParameters[(byte)LiteOpKey.Data] = customEventContent;
        }
        if (cache != EventCaching.DoNotCache)
        {
            opParameters[(byte)LiteOpKey.Cache] = (byte)cache;
        }
        if (receivers != ReceiverGroup.Others)
        {
            opParameters[(byte)LiteOpKey.ReceiverGroup] = (byte)receivers;
        }
        if (interestGroup != 0)
        {
            opParameters[(byte)LiteOpKey.Group] = (byte)interestGroup;
        }
        if (targetActors != null)
        {
            opParameters[(byte)LiteOpKey.ActorList] = targetActors;
        }

        return(this.OpCustom((byte)LiteOpCode.RaiseEvent, opParameters, sendReliable, channelId, false));
    }
Ejemplo n.º 17
0
    /// <summary>
    /// Send an event with custom code/type and any content to the other players in the same room.
    /// </summary>
    /// <remarks>This override explicitly uses another parameter order to not mix it up with the implementation for Hashtable only.</remarks>
    /// <param name="eventCode">Identifies this type of event (and the content). Your game's event codes can start with 0.</param>
    /// <param name="sendReliable">If this event has to arrive reliably (potentially repeated if it's lost).</param>
    /// <param name="customEventContent">Any serializable datatype (including Hashtable like the other OpRaiseEvent overloads).</param>
    /// <param name="channelId">Command sequence in which this command belongs. Must be less than value of ChannelCount property. Default: 0.</param>
    /// <param name="cache">Affects how the server will treat the event caching-wise. Can cache events for players joining later on or remove previously cached events. Default: DoNotCache.</param>
    /// <param name="targetActors">List of ActorNumbers (in this room) to send the event to. Overrides caching. Default: null.</param>
    /// <param name="receivers">Defines a target-player group. Default: Others.</param>
    /// <param name="interestGroup">Defines to which interest group the event is sent. Players can subscribe or unsibscribe to groups. Group 0 is always sent to all. Default: 0.</param>
    /// <returns>If operation could be enqueued for sending. Sent when calling: Service or SendOutgoingCommands.</returns>
    public virtual bool OpRaiseEvent(byte eventCode, bool sendReliable, object customEventContent, byte channelId, EventCaching cache, int[] targetActors, ReceiverGroup receivers, byte interestGroup)
    {
        Dictionary<byte, object> opParameters = new Dictionary<byte, object>();
        opParameters[(byte)LiteOpKey.Code] = (byte)eventCode;

        if (customEventContent != null)
        {
            opParameters[(byte)LiteOpKey.Data] = customEventContent;
        }
        if (cache != EventCaching.DoNotCache)
        {
            opParameters[(byte)LiteOpKey.Cache] = (byte)cache;
        }
        if (receivers != ReceiverGroup.Others)
        {
            opParameters[(byte)LiteOpKey.ReceiverGroup] = (byte)receivers;
        }
        if (interestGroup != 0)
        {
            opParameters[(byte)LiteOpKey.Group] = (byte)interestGroup;
        }
        if (targetActors != null)
        {
            opParameters[(byte)LiteOpKey.ActorList] = targetActors;
        }

        return this.OpCustom((byte)LiteOpCode.RaiseEvent, opParameters, sendReliable, channelId, false);
    }
Ejemplo n.º 18
0
 public virtual bool OpRaiseEvent(byte eventCode, Hashtable evData, bool sendReliable, byte channelId,
                                  int[] targetActors, EventCaching cache)
 {
     return(OpRaiseEvent(eventCode, sendReliable, evData, channelId, cache, targetActors,
                         ReceiverGroup.Others, 0, false));
 }
Ejemplo n.º 19
0
    /// <summary>
    /// Used in a room to raise (send) an event to the other players. 
    /// Multiple overloads expose different parameters to this frequently used operation.
    /// </summary>
    /// <param name="eventCode">Code for this "type" of event (use a code per "meaning" or content).</param>
    /// <param name="evData">Data to send. Hashtable that contains key-values of Photon serializable datatypes.</param>
    /// <param name="sendReliable">Use false if the event is replaced by a newer rapidly. Reliable events add overhead and add lag when repeated.</param>
    /// <param name="channelId">The "channel" to which this event should belong. Per channel, the sequence is kept in order.</param>
    /// <param name="cache">Use EventCaching options to store this event for players who join.</param>
    /// <param name="receivers">ReceiverGroup defines to which group of players the event is passed on.</param>
    /// <returns>If the operation could be sent (has to be connected).</returns>
    public virtual bool OpRaiseEvent(byte eventCode, Hashtable evData, bool sendReliable, byte channelId, EventCaching cache, ReceiverGroup receivers)
    {
        if (this.DebugOut >= DebugLevel.INFO)
        {
            this.Listener.DebugReturn(DebugLevel.INFO, "OpRaiseEvent()");
        }

        Dictionary<byte, object> opParameters = new Dictionary<byte, object>();
        opParameters[ParameterCode.Data] = evData;
        opParameters[ParameterCode.Code] = (byte)eventCode;

        if (receivers != ReceiverGroup.Others)
        {
            opParameters[ParameterCode.ReceiverGroup] = (byte)receivers;
        }

        if (cache != EventCaching.DoNotCache)
        {
            opParameters[ParameterCode.Cache] = (byte)cache;
        }

        return this.OpCustom((byte)OperationCode.RaiseEvent, opParameters, sendReliable, channelId);
    }
Ejemplo n.º 20
0
        public virtual bool OpRaiseEvent(byte eventCode, Hashtable customEventContent, bool sendReliable, byte channelId, EventCaching cache, ReceiverGroup receivers)
        {
            Dictionary <byte, object> customOpParameters = new Dictionary <byte, object>();

            customOpParameters[(byte)245] = (object)customEventContent;
            customOpParameters[(byte)244] = (object)eventCode;
            if (cache != EventCaching.DoNotCache)
            {
                customOpParameters[(byte)247] = (object)cache;
            }
            if (receivers != ReceiverGroup.Others)
            {
                customOpParameters[(byte)246] = (object)receivers;
            }
            return(this.OpCustom((byte)253, customOpParameters, sendReliable, channelId, false));
        }
Ejemplo n.º 21
0
        /// <summary>
        /// Used in a room to raise (send) an event to the other players.
        /// Multiple overloads expose different parameters to this frequently used operation.
        /// </summary>
        /// <param name="eventCode">Code for this "type" of event (use a code per "meaning" or content).</param>
        /// <param name="evData">Data to send. Hashtable that contains key-values of Photon serializable datatypes.</param>
        /// <param name="sendReliable">Use false if the event is replaced by a newer rapidly. Reliable events add overhead and add lag when repeated.</param>
        /// <param name="channelId">The "channel" to which this event should belong. Per channel, the sequence is kept in order.</param>
        /// <param name="cache">Use EventCaching options to store this event for players who join.</param>
        /// <param name="receivers">ReceiverGroup defines to which group of players the event is passed on.</param>
        /// <returns>If the operation could be sent (has to be connected).</returns>
        public virtual bool OpRaiseEvent(byte eventCode, Hashtable evData, bool sendReliable, byte channelId, EventCaching cache, ReceiverGroup receivers)
        {
            if (this.DebugOut >= DebugLevel.INFO)
            {
                this.Listener.DebugReturn(DebugLevel.INFO, "OpRaiseEvent()");
            }

            Dictionary <byte, object> opParameters = new Dictionary <byte, object>();

            opParameters[ParameterCode.Data] = evData;
            opParameters[ParameterCode.Code] = (byte)eventCode;

            if (receivers != ReceiverGroup.Others)
            {
                opParameters[ParameterCode.ReceiverGroup] = (byte)receivers;
            }

            if (cache != EventCaching.DoNotCache)
            {
                opParameters[ParameterCode.Cache] = (byte)cache;
            }

            return(this.OpCustom((byte)OperationCode.RaiseEvent, opParameters, sendReliable, channelId));
        }
Ejemplo n.º 22
0
        ///<summary>
        /// Calls operation RaiseEvent on the server, with full control of event-caching and the target receivers.
        /// </summary>
        /// <remarks>
        /// This method is described in one of its overloads.

        /// The cache parameter defines if and how this event will be cached server-side. Per event-code, your client
        /// can store events and update them and will send cached events to players joining the same room.

        /// The option EventCaching.DoNotCache matches the default behaviour of RaiseEvent.
        /// The option EventCaching.MergeCache will merge the costomEventContent into existing one.
        /// Values in the customEventContent Hashtable can be null to remove existing values.

        /// With the receivers parameter, you can chose who gets this event: Others (default), All (includes you as sender)
        /// or MasterClient. The MasterClient is the connected player with the lowest ActorNumber in this room.
        /// This player could get some privileges, if needed.

        /// Read more about Cached Events in the DevNet: http://doc.exitgames.com
        /// </remarks>
        /// <param name="eventCode">Identifies this type of event (and the content). Your game's event codes can start with 0.</param>
        /// <param name="customEventContent">Custom data you want to send along (use null, if none).</param>
        /// <param name="sendReliable">If this event has to arrive reliably (potentially repeated if it's lost).</param>
        /// <param name="channelId">Number of channel to use (starting with 0).</param>
        /// <param name="cache">Events can be cached (merged and removed) for players joining later on.</param>
        /// <param name="receivers">Controls who should get this event.</param>
        /// <returns>If operation could be enqueued for sending.</returns>
        public virtual bool OpRaiseEvent(byte eventCode, Hashtable customEventContent, bool sendReliable, byte channelId, EventCaching cache, ReceiverGroup receivers)
        {
            Dictionary <byte, object> opParameters = new Dictionary <byte, object>();

            opParameters[0xf5] = customEventContent;
            opParameters[0xf4] = eventCode;
            if (cache != EventCaching.DoNotCache)
            {
                opParameters[0xf7] = (byte)cache;
            }
            if (receivers != ReceiverGroup.Others)
            {
                opParameters[0xf6] = (byte)receivers;
            }
            return(this.OpCustom(0xfd, opParameters, sendReliable, channelId, false));
        }