/// <summary> /// Releases a room reference. /// The related room instance will be removed from the cache if /// no more references to the room exists. /// </summary> /// <param name="roomReference"> /// The room reference to relaease. /// </param> public void ReleaseRoomReference(RoomReference roomReference) { Room room = null; lock (this.SyncRoot) { RoomInstance roomInstance; if (!this.roomInstances.TryGetValue(roomReference.Room.Name, out roomInstance)) { return; } roomInstance.ReleaseReference(roomReference); if (roomInstance.ReferenceCount <= 0) { if (log.IsDebugEnabled) { log.DebugFormat("Removing room instance: roomId={0}", roomReference.Room.Name); } this.roomInstances.Remove(roomInstance.Room.Name); roomInstance.Room.Dispose(); room = roomInstance.Room; } } if (room != null) { this.OnRoomRemoved(room); } }
/// <summary> /// Adds a reference to the room instance. /// </summary> /// <param name="ownerPeer"> /// The peer that holds this reference. /// </param> /// <returns> /// a new <see cref="RoomReference"/> /// </returns> public RoomReference AddReference(PeerBase ownerPeer) { var reference = new RoomReference(this.roomFactory, this.Room, ownerPeer); this.references.Add(reference.Id, reference); if (log.IsDebugEnabled) { log.DebugFormat( "Created room instance reference: roomName={0}, referenceCount={1}", this.Room.Name, this.ReferenceCount); } if (this.logQueue.Log.IsDebugEnabled) { this.logQueue.Add( new LogEntry( "AddReference", string.Format( "RoomName={0}, ReferenceCount={1}, OwnerPeer={2}", this.Room.Name, this.ReferenceCount, ownerPeer))); } return(reference); }
/// <summary> /// Releases a reference from this instance. /// </summary> /// <param name="reference"> /// The room reference. /// </param> public void ReleaseReference(RoomReference reference) { this.references.Remove(reference.Id); if (log.IsDebugEnabled) { log.DebugFormat("Removed room instance reference: roomName={0}, referenceCount={1}", this.Room.Name, this.ReferenceCount); } }
/// <summary> /// Adds a reference to the room instance. /// </summary> /// <returns> /// a new <see cref="RoomReference"/> /// </returns> public RoomReference AddReference() { var reference = new RoomReference(this.roomFactory, this.Room); this.references.Add(reference.Id, reference); if (log.IsDebugEnabled) { log.DebugFormat("Created room instance reference: roomName={0}, referenceCount={1}", this.Room.Name, this.ReferenceCount); } return(reference); }
/// <summary> /// Tries to get room reference for a room with the specified id. /// </summary> /// <param name="roomId"> /// The room id. /// </param> /// <param name="ownerPeer"> /// The peer that holds this reference. /// </param> /// <param name="roomReference"> /// When this method returns true, contains a new <see cref="RoomReference"/> for the room /// with the specified room id; otherwise, set to null. /// </param> /// <returns> /// True if the cache contains a room with the specified room id; otherwise, false. /// </returns> public bool TryGetRoomReference(string roomId, PeerBase ownerPeer, out RoomReference roomReference) { lock (this.SyncRoot) { RoomInstance roomInstance; if (!this.roomInstances.TryGetValue(roomId, out roomInstance)) { roomReference = null; return(false); } roomReference = roomInstance.AddReference(ownerPeer); return(true); } }
/// <summary> /// Releases a room reference. /// The related room instance will be removed from the cache if /// no more references to the room exists. /// </summary> /// <param name="roomReference"> /// The room reference to relaease. /// </param> public void ReleaseRoomReference(RoomReference roomReference) { Room room; lock (this.SyncRoot) { RoomInstance roomInstance; if (!this.RoomInstances.TryGetValue(roomReference.Room.Name, out roomInstance)) { return; } roomInstance.ReleaseReference(roomReference); // if there are still references to the room left // the room stays into the cache if (roomInstance.ReferenceCount > 0) { return; } // ask the room implementation if the room should be // removed automaticly from the cache var shouldRemoveRoom = roomInstance.Room.BeforeRemoveFromCache(); if (shouldRemoveRoom == false) { return; } this.RoomInstances.Remove(roomInstance.Room.Name); room = roomInstance.Room; } if (room == null) { // the room hast not been removed from the cache return; } if (log.IsDebugEnabled) { log.DebugFormat("Removed room instance: roomId={0}", room.Name); } room.Dispose(); this.OnRoomRemoved(room); }
/// <summary> /// Tries to create a new room. /// </summary> /// <param name="roomName"> /// The room id. /// </param> /// <param name="ownerPeer"> /// The peer that holds this reference. /// </param> /// <param name="roomReference"> /// When this method returns true, contains a new <see cref="RoomReference"/> for the room /// with the specified room id; otherwise, set to null. /// </param> /// <param name="args"> /// Optionally arguments used for room creation. /// </param> /// <returns> /// False if the cache contains a room with the specified room id; otherwise, true. /// </returns> public bool TryCreateRoom(string roomName, PeerBase ownerPeer, out RoomReference roomReference, params object[] args) { lock (this.SyncRoot) { if (this.roomInstances.ContainsKey(roomName)) { roomReference = null; return(false); } Room room = this.CreateRoom(roomName, args); var roomInstance = new RoomInstance(this, room); this.roomInstances.Add(roomName, roomInstance); roomReference = roomInstance.AddReference(ownerPeer); return(true); } }
/// <summary> /// Tries to create a new room. /// </summary> /// <param name="roomName">The room id.</param> /// <param name="roomReference"> /// When this method returns true, contains a new <see cref="RoomReference"/> for the room /// with the specified room id; otherwise, set to null. /// </param> /// <param name="args"> /// Optionally arguments used for room creation. /// </param> /// <returns> /// False if the cache contains a room with the specified room id; otherwise, true. /// </returns> public bool TryCreateRoom(string roomName, out RoomReference roomReference, params object[] args) { lock (this.syncRoot) { if (this.roomInstances.ContainsKey(roomName)) { roomReference = null; return false; } Room room = this.CreateRoom(roomName, args); var roomInstance = new RoomInstance(this, room); this.roomInstances.Add(roomName, roomInstance); roomReference = roomInstance.AddReference(); return true; } }
/// <summary> /// Releases a reference from this instance. /// </summary> /// <param name="reference"> /// The room reference. /// </param> public void ReleaseReference(RoomReference reference) { this.references.Remove(reference.Id); if (log.IsDebugEnabled) { log.DebugFormat( "Removed room instance reference: roomName={0}, referenceCount={1}", this.Room.Name, this.ReferenceCount); } if (this.logQueue.Log.IsDebugEnabled) { this.logQueue.Add( new LogEntry( "ReleaseReference", string.Format( "RoomName={0}, ReferenceCount={1}, OwnerPeer={2}", this.Room.Name, this.ReferenceCount, reference.OwnerPeer))); } }
/// <summary> /// Handles the <see cref = "LeaveRequest" /> to leave a <see cref = "LiteGame" />. /// </summary> /// <param name = "operationRequest"> /// The operation request to handle. /// </param> /// <param name = "sendParameters"> /// The send Parameters. /// </param> protected virtual void HandleLeaveOperation(OperationRequest operationRequest, SendParameters sendParameters) { // check if the peer have a reference to game if (this.RoomReference == null) { if (log.IsDebugEnabled) { log.DebugFormat("Received leave operation on peer without a game: peerId={0}", this.ConnectionId); } return; } // enqueue the leave operation into game queue. this.RoomReference.Room.EnqueueOperation(this, operationRequest, sendParameters); // release the reference to the game // the game cache will recycle the game instance if no // more refrences to the game are left. this.RoomReference.Dispose(); // finally the peers state is set to null to indicate // that the peer is not attached to a room anymore. this.RoomReference = null; }
/// <summary> /// Handles the <see cref = "JoinRequest" /> to enter a <see cref = "LiteGame" />. /// This method removes the peer from any previously joined room, finds the room intended for join /// and enqueues the operation for it to handle. /// </summary> /// <param name = "operationRequest"> /// The operation request to handle. /// </param> /// <param name = "sendParameters"> /// The send Parameters. /// </param> protected virtual void HandleJoinOperation(OperationRequest operationRequest, SendParameters sendParameters) { // create join operation var joinRequest = new JoinRequest(this.Protocol, operationRequest); if (this.ValidateOperation(joinRequest, sendParameters) == false) { return; } // remove peer from current game this.RemovePeerFromCurrentRoom(); // get a game reference from the game cache // the game will be created by the cache if it does not exists already RoomReference gameReference = this.GetRoomReference(joinRequest); // save the game reference in the peers state this.RoomReference = gameReference; // finally enqueue the operation into game queue gameReference.Room.EnqueueOperation(this, operationRequest, sendParameters); }
/// <summary> /// Initializes a new instance of the <see cref = "LiteLobbyGame" /> class. /// </summary> /// <param name = "gameName"> /// The name of the game. /// </param> /// <param name = "lobbyName"> /// The name of the lobby for the game. /// </param> public LiteLobbyGame(string gameName, string lobbyName) : base(gameName) { // get the reference to the lobby this.lobbyReference = LiteLobbyRoomCache.Instance.GetRoomReference(lobbyName, null); }
protected virtual bool TryGetRoomReference(string gameId, out RoomReference roomReference) { return GameCache.Instance.TryGetRoomReference(gameId, this, out roomReference); }
/// <summary> /// Adds a reference to the room instance. /// </summary> /// <param name="ownerPeer"> /// The peer that holds this reference. /// </param> /// <returns> /// a new <see cref="RoomReference"/> /// </returns> public RoomReference AddReference(PeerBase ownerPeer) { var reference = new RoomReference(this.roomFactory, this.Room, ownerPeer); this.references.Add(reference.Id, reference); if (log.IsDebugEnabled) { log.DebugFormat( "Created room instance reference: roomName={0}, referenceCount={1}", this.Room.Name, this.ReferenceCount); } if (this.logQueue.Log.IsDebugEnabled) { this.logQueue.Add( new LogEntry( "AddReference", string.Format( "RoomName={0}, ReferenceCount={1}, OwnerPeer={2}", this.Room.Name, this.ReferenceCount, ownerPeer))); } return reference; }
/// <summary> /// Tries to get room reference for a room with the specified id. /// </summary> /// <param name="roomId"> /// The room id. /// </param> /// <param name="ownerPeer"> /// The peer that holds this reference. /// </param> /// <param name="roomReference"> /// When this method returns true, contains a new <see cref="RoomReference"/> for the room /// with the specified room id; otherwise, set to null. /// </param> /// <returns> /// True if the cache contains a room with the specified room id; otherwise, false. /// </returns> public bool TryGetRoomReference(string roomId, PeerBase ownerPeer, out RoomReference roomReference) { lock (this.SyncRoot) { RoomInstance roomInstance; if (!this.RoomInstances.TryGetValue(roomId, out roomInstance)) { roomReference = null; return false; } roomReference = roomInstance.AddReference(ownerPeer); return true; } }
protected override bool TryCreateRoom(string gameId, out RoomReference roomReference) { return GameCache.Instance.TryCreateRoom(gameId, this, out roomReference); }
/// <summary> /// Releases a room reference. /// The related room instance will be removed from the cache if /// no more references to the room exists. /// </summary> /// <param name="roomReference"> /// The room reference to relaease. /// </param> public void ReleaseRoomReference(RoomReference roomReference) { Room room = null; lock (this.syncRoot) { RoomInstance roomInstance; if (!this.roomInstances.TryGetValue(roomReference.Room.Name, out roomInstance)) { return; } roomInstance.ReleaseReference(roomReference); if (roomInstance.ReferenceCount <= 0) { if (log.IsDebugEnabled) { log.DebugFormat("Removing room instance: roomId={0}", roomReference.Room.Name); } this.roomInstances.Remove(roomInstance.Room.Name); roomInstance.Room.Dispose(); room = roomInstance.Room; } } if (room != null) { this.OnRoomRemoved(room); } }
/// <summary> /// Adds a reference to the room instance. /// </summary> /// <returns> /// a new <see cref="RoomReference"/> /// </returns> public RoomReference AddReference() { var reference = new RoomReference(this.roomFactory, this.Room); this.references.Add(reference.Id, reference); if (log.IsDebugEnabled) { log.DebugFormat("Created room instance reference: roomName={0}, referenceCount={1}", this.Room.Name, this.ReferenceCount); } return reference; }
/// <summary> /// Called when client disconnects. /// Ensures that disconnected players leave the game <see cref = "Room" />. /// The player is not removed immediately but a message is sent to the room. This avoids /// threading issues by making sure the player remove is not done concurrently with operations. /// </summary> protected override void OnDisconnect(DisconnectReason reasonCode, string reasonDetail) { if (log.IsDebugEnabled) { log.DebugFormat("OnDisconnect: conId={0}, reason={1}, reasonDetail={2}", this.ConnectionId, reasonCode, reasonDetail); } if (this.RoomReference == null) { return; } var message = new RoomMessage((byte)GameMessageCodes.RemovePeerFromGame, this); this.RoomReference.Room.EnqueueMessage(message); this.RoomReference.Dispose(); this.RoomReference = null; }
/// <summary> /// Checks if the the state of peer is set to a reference of a room. /// If a room refrence is present the peer will be removed from the related room and the reference will be disposed. /// Disposing the reference allows the associated room factory to remove the room instance if no more references to the room exists. /// </summary> protected virtual void RemovePeerFromCurrentRoom() { // check if the peer already joined another game if (this.RoomReference != null) { // remove peer from his current game. var message = new RoomMessage((byte)GameMessageCodes.RemovePeerFromGame, this); this.RoomReference.Room.EnqueueMessage(message); // release room reference this.RoomReference.Dispose(); this.RoomReference = null; } }