// Add class to control spell's
        public PlayerDetails(Actor actor)
        {
            level = 1;
            xp = 0;

            life = ConfigGame.lifeMax;
            lifeMax = ConfigGame.lifeMax;

            mana = ConfigGame.manaMax;
            manaMax = ConfigGame.manaMax;

            regLife = ConfigGame.regLife;
            regMana = ConfigGame.regMana;

            gold = ConfigGame.initialGold;

            isReady = false;
            resetStatistics();
        }
        /// <summary>
        ///   Helper method of <see cref = "HandleRaiseEventOperation" />.
        ///   Stores an event for new actors.
        /// </summary>
        /// <param name = "actor">
        ///   The actor.
        /// </param>
        /// <param name = "raiseEventRequest">
        ///   The raise event request.
        /// </param>
        /// <returns>
        ///   True if <see cref = "RaiseEventRequest.Cache" /> is valid.
        /// </returns>
        protected bool UpdateEventCache(Actor actor, RaiseEventRequest raiseEventRequest)
        {
            CustomEvent customEvent;

            switch (raiseEventRequest.Cache)
            {
                case (byte)CacheOperation.AddToRoomCache:
                    customEvent = new CustomEvent(actor.ActorNr, raiseEventRequest.EvCode, raiseEventRequest.Data) { Cache = raiseEventRequest.Cache };
                    this.eventCache.AddEvent(customEvent);
                    return true;

                case (byte)CacheOperation.AddToRoomCacheGlobal:
                    customEvent = new CustomEvent(0, raiseEventRequest.EvCode, raiseEventRequest.Data) { Cache = raiseEventRequest.Cache };
                    this.eventCache.AddEvent(customEvent);
                    return true;

                case (byte)CacheOperation.MergeCache:
                    {
                        EventCache eventCache;
                        if (!this.eventCacheOld.TryGetValue(actor.ActorNr, out eventCache))
                        {
                            eventCache = new EventCache();
                            this.eventCacheOld.Add(actor.ActorNr, eventCache);
                        }

                        Hashtable @event;
                        if (eventCache.TryGetValue(raiseEventRequest.EvCode, out @event))
                        {
                            // null events are removed
                            if (raiseEventRequest.Data == null)
                            {
                                eventCache.Remove(raiseEventRequest.EvCode);
                            }
                            else
                            {
                                // merge or delete
                                foreach (DictionaryEntry pair in raiseEventRequest.Data)
                                {
                                    // null values are removed
                                    if (pair.Value == null)
                                    {
                                        @event.Remove(pair.Key);
                                    }
                                    else
                                    {
                                        @event[pair.Key] = pair.Value;
                                    }
                                }
                            }
                        }
                        else if (raiseEventRequest.Data != null)
                        {
                            // new
                            @event = raiseEventRequest.Data;
                            eventCache.Add(raiseEventRequest.EvCode, @event);
                        }

                        return true;
                    }

                case (byte)CacheOperation.RemoveCache:
                    {
                        EventCache eventCache;
                        if (!this.eventCacheOld.TryGetValue(actor.ActorNr, out eventCache))
                        {
                            return true;
                        }

                        eventCache.Remove(raiseEventRequest.EvCode);
                        return true;
                    }

                case (byte)CacheOperation.ReplaceCache:
                    {
                        EventCache eventCache;
                        if (!this.eventCacheOld.TryGetValue(actor.ActorNr, out eventCache))
                        {
                            eventCache = new EventCache();
                            this.eventCacheOld.Add(actor.ActorNr, eventCache);
                        }

                        eventCache.Remove(raiseEventRequest.EvCode);
                        if (raiseEventRequest.Data != null)
                        {
                            Hashtable @event = raiseEventRequest.Data;
                            eventCache.Add(raiseEventRequest.EvCode, @event);
                        }

                        return true;
                    }

                default:
                    {
                        return false;
                    }
            }
        }
        /// <summary>
        ///   Tries to add a <see cref = "LitePeer" /> to this game instance.
        /// </summary>
        /// <param name = "peer">
        ///   The peer to add.
        /// </param>
        /// <param name = "actor">
        ///   When this method returns this out param contains the <see cref = "Actor" /> associated with the <paramref name = "peer" />.
        /// </param>
        /// <returns>
        ///   Returns true if no actor exists for the specified peer and a new actor for the peer has been successfully added. 
        ///   The actor parameter is set to the newly created <see cref = "Actor" /> instance.
        ///   Returns false if an actor for the specified peer already exists. 
        ///   The actor paramter is set to the existing <see cref = "Actor" /> for the specified peer.
        /// </returns>
        protected virtual bool TryAddPeerToGame(LitePeer peer, out Actor actor)
        {
            // check if the peer already exists in this game
            actor = this.Actors.GetActorByPeer(peer);
            if (actor != null)
            {
                return false;
            }

            // create new actor instance
            actor = new Actor(peer);
            this.actorNumberCounter++;
            actor.ActorNr = this.actorNumberCounter;
            this.Actors.Add(actor);

            if (Log.IsDebugEnabled)
            {
                Log.DebugFormat("Actor added: {0} to game: {1}", actor.ActorNr, this.Name);
            }

            return true;
        }
 /// <summary>
 ///   Sends a <see cref = "LeaveEvent" /> to all <see cref = "Actor" />s.
 /// </summary>
 /// <param name = "peer">
 ///   The peer.
 /// </param>
 /// <param name = "leaveRequest">
 /// The <see cref="LeaveRequest"/> sent by the peer or null if the peer have been disconnected without sending a leave request.
 /// </param>
 protected virtual void PublishLeaveEvent(Actor actor, LeaveRequest leaveRequest)
 {
     if (this.Actors.Count > 0 && actor != null)
     {
         IEnumerable<int> actorNumbers = this.Actors.GetActorNumbers();
         var leaveEvent = new LeaveEvent(actor.ActorNr, actorNumbers.ToArray());
         this.PublishEvent(leaveEvent, this.Actors, new SendParameters());
     }
 }
 /// <summary>
 /// Sends the complete list of games to one actor in the lobby.
 /// </summary>
 /// <param name="actor">
 /// The actor.
 /// </param>
 private void PublishGameList(Actor actor)
 {
     // Room list needs to be cloned because it is serialized in other thread and is changed at the same time
     var customEvent = new CustomEvent(actor.ActorNr, (byte)LiteLobbyEventCode.GameList, (Hashtable)this.roomList.Clone());
     this.PublishEvent(customEvent, actor, new SendParameters { Unreliable = true });
 }
 /// <summary>
 /// This override disables the event publishing.
 /// </summary>
 /// <param name="peer">
 /// The peer.
 /// </param>
 /// <param name="leaveOperation">
 /// The leave operation.
 /// </param>
 protected override void PublishLeaveEvent(Actor actor, LeaveRequest leaveOperation)
 {
     // lobbies don't publish a leave event to the clients
 }
Beispiel #7
0
 public void addPlayer(Actor actor)
 {
     listPlayers.Add(new PlayerDetails(actor));
 }
Beispiel #8
0
 public void removePlayer(Actor actor)
 {
     PlayerDetails remove = listPlayers.Find(e => e.actor == actor);
     listPlayers.Remove(remove);
 }
Beispiel #9
0
 /// <summary>
 ///   Publishes an event to a single actor on a specified channel.
 /// </summary>
 /// <param name = "e">
 ///   The event to publish.
 /// </param>
 /// <param name = "actor">
 ///   The <see cref = "Actor" /> who should receive the event.
 /// </param>
 /// <param name = "sendParameters">
 ///   The send Parameters.
 /// </param>
 protected void PublishEvent(LiteEventBase e, Actor actor, SendParameters sendParameters)
 {
     var eventData = new EventData(e.Code, e);
     actor.Peer.SendEvent(eventData, sendParameters);
 }
Beispiel #10
0
        /// <summary>
        ///   Helper method of <see cref = "HandleRaiseEventOperation" />.
        ///   Stores an event for new actors.
        /// </summary>
        /// <param name = "actor">
        ///   The actor.
        /// </param>
        /// <param name = "raiseEventRequest">
        ///   The raise event request.
        /// </param>
        /// <param name="msg">
        ///   Contains an error message if the method returns false.
        /// </param>
        /// <returns>
        ///   True if <see cref = "RaiseEventRequest.Cache" /> is valid.
        /// </returns>
        protected bool UpdateEventCache(Actor actor, RaiseEventRequest raiseEventRequest, out string msg)
        {
            msg = null;
            CustomEvent customEvent;

            switch (raiseEventRequest.Cache)
            {
                case (byte)CacheOperation.DoNotCache:
                    return true;

                case (byte)CacheOperation.AddToRoomCache:
                    customEvent = new CustomEvent(actor.ActorNr, raiseEventRequest.EvCode, raiseEventRequest.Data);
                    this.eventCache.AddEvent(customEvent);
                    return true;

                case (byte)CacheOperation.AddToRoomCacheGlobal:
                    customEvent = new CustomEvent(0, raiseEventRequest.EvCode, raiseEventRequest.Data);
                    this.eventCache.AddEvent(customEvent);
                    return true;
            }

            // cache operations for the actor event cache currently only working with hashtable data
            Hashtable eventData;
            if (raiseEventRequest.Data == null || raiseEventRequest.Data is Hashtable)
            {
                eventData = (Hashtable)raiseEventRequest.Data;
            }
            else
            {
                msg = string.Format("Cache operation '{0}' requires a Hashtable as event data.", raiseEventRequest.Cache);
                return false;
            }


            switch (raiseEventRequest.Cache)
            {
                case (byte)CacheOperation.MergeCache:
                    this.actorEventCache.MergeEvent(actor.ActorNr, raiseEventRequest.EvCode, eventData);
                    return true;

                case (byte)CacheOperation.RemoveCache:
                    this.actorEventCache.RemoveEvent(actor.ActorNr, raiseEventRequest.EvCode);
                    return true;

                case (byte)CacheOperation.ReplaceCache:
                    this.actorEventCache.ReplaceEvent(actor.ActorNr, raiseEventRequest.EvCode, eventData);
                    return true;

                default:
                msg = string.Format("Unknown cache operation '{0}'.", raiseEventRequest.Cache);
                    return false;
            }
        }