public IList <IChatAspect> Load(RoomReference reference) { return(_chatRepository .FindByRoom(reference.Code) .Select(_chatAspectMapper.Map) .ToList()); }
/// <summary> /// Joins the peer to a <see cref = "LiteLobbyGame" />. /// Called by <see cref = "HandleJoinOperation">HandleJoinOperation</see>. /// Overridden to inject custom discussion rooms /// </summary> /// <param name = "joinOperation"> /// The join operation. /// </param> /// <param name = "sendParameters"> /// The send Parameters. /// </param> protected override void HandleJoinGameWithLobby(JoinRequest joinOperation, SendParameters sendParameters) { _dbId = (int)joinOperation.ActorProperties[(byte)ActProps.DbId]; var devType = (int)joinOperation.ActorProperties[(byte)ActProps.DevType]; handleOnlineStatus(_photonPer, _dbId, true, devType); // remove the peer from current game if the peer // allready joined another game this.RemovePeerFromCurrentRoom(); // get a game reference from the game cache // the game will be created by the cache if it does not exists allready RoomReference gameReference = DiscussionGameCache.Instance.GetRoomReference(joinOperation.GameId, joinOperation.LobbyId); // save the game reference in peers state this.RoomReference = gameReference; // enqueue the operation request into the games execution queue gameReference.Room.EnqueueOperation(this, joinOperation.OperationRequest, sendParameters); ////no base.HandleJoinGameWithLobby(), we've duplicated all its code here RoomReference lobbyReference = DiscussionLobbyCache.Instance.GetRoomReference(joinOperation.LobbyId); var discLobby = lobbyReference.Room as DiscussionLobby; if (discLobby != null) { discLobby.SaveRoomName(joinOperation.GameId); } }
public IRoomAspect Load(RoomReference reference) { var roomEntity = _roomRepository.FindById(reference.Code); var participants = _participantRepository.FindByRoom(reference.Code); return(_roomAspectMapper.Map(roomEntity, participants)); }
public void Create(string loginToken, LearningRoomModel model) { var login = _loginTokenGateway.Get(loginToken); var roomReference = new RoomReference(Guid.NewGuid().ToString()); var roomAspct = new RoomAspect { Reference = roomReference, CreatedBy = login.OpenId, CreatedOn = DateTime.Parse(model.CreatedOn), EndDate = DateTime.Parse(model.EndDate), LearningContent = model.LearningContent, Place = model.Place, ParticipantCount = model.ParticipantCount, StartDate = DateTime.Parse(model.StartDate), Title = model.Title, Participants = new List <Participant> { new Participant { Reference = new ParticipantReference(Guid.NewGuid().ToString()), IsDeleted = false, Room = roomReference, User = login.OpenId } } }; _learningRoomSynchronizor.Add(new LearningRoomDomain(roomAspct)); }
public void NewRoom(ref RoomReference roomReference) { this.roomReference = roomReference; SetupExits(); SetupObjects(); }
/// <summary> /// Joins the peer to a <see cref = "LiteLobbyGame" />. /// Called by <see cref = "HandleJoinOperation">HandleJoinOperation</see>. /// </summary> /// <param name = "joinOperation"> /// The join operation. /// </param> /// <param name = "sendParameters"> /// The send Parameters. /// </param> protected virtual void HandleJoinGameWithLobby(JoinRequest joinOperation, SendParameters sendParameters) { // remove the peer from current game if the peer // allready joined another game this.RemovePeerFromCurrentRoom(); RoomReference gameReference = null; if (joinOperation.ActorNr == 0) { // get a game reference from the game cache // the game will be created by the cache if it does not exists allready gameReference = LiteLobbyGameCache.Instance.GetRoomReference(joinOperation.GameId, this, joinOperation.LobbyId); } else { if (!LiteLobbyGameCache.Instance.TryGetRoomReference(joinOperation.GameId, this, out gameReference)) { SendOperationResponse( new OperationResponse { OperationCode = joinOperation.OperationRequest.OperationCode, ReturnCode = -1, DebugMessage = "the specified game is not exists." }, sendParameters); return; } } // save the game reference in peers state this.RoomReference = gameReference; // enqueue the operation request into the games execution queue gameReference.Room.EnqueueOperation(this, joinOperation.OperationRequest, sendParameters); }
protected virtual void HandleLeaveOperation(OperationRequest operationRequest, SendParameters sendParameters) { // check if the peer have a reference to game if (RoomReference == null) { if (Log.IsDebugEnabled) { Log.DebugFormat("Received leave operation on peer without a game: peerId={0}", ConnectionId); } return; } // enqueue the leave operation into game queue. 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. RoomReference.Dispose(); // finally the peers state is set to null to indicate // that the peer is not attached to a room anymore. RoomReference = null; }
public ILearningRoomWithChats Load(RoomReference reference) { var roomAspect = _roomAspectLoader.Load(reference); var chatsAspects = _chatAspectLoader.Load(reference); return(new LearningRoomWithChats(roomAspect) { ChatAspects = chatsAspects }); }
public ILearningRoomWithSignIn Load(RoomReference reference) { var roomAspect = _roomAspectLoader.Load(reference); var signInAspects = _signInAspectLoader.Load(reference); return(new LearningRoomWithSignIn(roomAspect) { SignIns = signInAspects }); }
public void NewLevel() { TunnelBP tunnelBP; RoomReference firstLeftTunnelRoom; RoomReference firstRightTunnelRoom; //create both tunnels traveling left and right int[][] leftTunnel = SetupTunnel(); int[][] rightTunnel = SetupTunnel(); //this is the setup for the core blueprint do { tunnelBP = SetupCoreBlueprint(); }while(tunnelBP.levelBP == null); coreRoomReference = tunnelBP.roomReference; tunnelBP.roomReference = null; tunnelBP.levelBP = null; //this is to setup the left tunnel blueprint //tunnelBP = SetupTunnelBlueprint(true, leftTunnel, levelBlueprint, coreRoomReference); do { tunnelBP = SetupTunnelBlueprint(true, leftTunnel, levelBlueprint, coreRoomReference); }while(tunnelBP.levelBP == null); firstLeftTunnelRoom = tunnelBP.roomReference; coreRoomReference.children.Add(firstLeftTunnelRoom); levelBlueprint = tunnelBP.levelBP; tunnelBP.roomReference = null; tunnelBP.levelBP = null; //this is to setup the right tunnel blueprint //tunnelBP = SetupTunnelBlueprint(false, rightTunnel, levelBlueprint, coreRoomReference); do { tunnelBP = SetupTunnelBlueprint(false, rightTunnel, levelBlueprint, coreRoomReference); }while(tunnelBP.levelBP == null); firstRightTunnelRoom = tunnelBP.roomReference; coreRoomReference.children.Add(firstRightTunnelRoom); levelBlueprint = tunnelBP.levelBP; tunnelBP.roomReference = null; tunnelBP.levelBP = null; if (debugMode) { //DebugRoomReference(coreRoomReference); } //Takes the first room reference and constructs the level from it ConstructLevel(coreRoomReference); }
private void broadcastOnlineListChanged() { RoomReference lobbyReference = DiscussionLobbyCache.Instance.GetRoomReference(DISCUSSION_LOBBY); var dLobby = lobbyReference.Room as DiscussionLobby; if (dLobby != null) { dLobby.AllRoomsBroadcast(null, new OperationRequest(), new SendParameters(), (byte)DiscussionEventCode.InstantUserPlusMinus); } }
private static bool DisposeRoomReference(RoomReference r) { if (r == null) { return(true); } // release the reference to the game // the game cache will recycle the game instance if no // more refrences to the game are left. r.Dispose(); return(false); }
public RoomReference(int x, int y, int type, int[] exits, int entrance, int roomsFirstExit, int roomsSecondExit, RoomReference parent) { this.x = x; this.y = y; this.type = type; this.exits[0] = exits[0]; this.exits[1] = exits[1]; this.exits[2] = exits[2]; this.exits[3] = exits[3]; this.entrance = entrance; this.exitReferences[0] = roomsFirstExit; this.exitReferences[1] = roomsSecondExit; this.parent = parent; }
protected virtual void RemovePeerFromCurrentRoom() { // check if the peer already joined another game if (RoomReference != null) { // remove peer from his current game. var message = new RoomMessage((byte)GameMessageCodes.RemovePeerFromGame, this); RoomReference.Room.EnqueueMessage(message); // release room reference RoomReference.Dispose(); RoomReference = null; } }
/// <summary> /// Joins the peer to a <see cref = "LiteLobby" />. /// Called by <see cref = "HandleJoinOperation">HandleJoinOperation</see>. /// </summary> /// <param name = "joinRequest"> /// The join operation. /// </param> /// <param name = "sendParameters"> /// The send Parameters. /// </param> protected virtual void HandleJoinLobby(JoinRequest joinRequest, SendParameters sendParameters) { // remove the peer from current game if the peer // allready joined another game this.RemovePeerFromCurrentRoom(); // get a lobby reference from the game cache // the lobby will be created by the cache if it does not exists allready RoomReference lobbyReference = LiteLobbyRoomCache.Instance.GetRoomReference(joinRequest.GameId); // save the lobby(room) reference in peers state this.RoomReference = lobbyReference; // enqueue the operation request into the games execution queue lobbyReference.Room.EnqueueOperation(this, joinRequest.OperationRequest, sendParameters); }
TunnelBP SetupCoreBlueprint() { levelBlueprint = new int[levelWidth, levelHeight]; levelBlueprint[levelWidth / 2, levelHeight / 2] = 1; int[] newExits = new int[4]; newExits[1] = 1; newExits[3] = 1; RoomReference roomReference = new RoomReference(levelWidth / 2, levelHeight / 2, 1, newExits, 0, 3, 1, null); if (debugMode) { DebugBlueprint(1, levelWidth / 2, levelHeight / 2); } //leave this here for debug purposes, shows where the display was called from return(new TunnelBP(levelBlueprint, roomReference)); }
public async Task CreateChatMessage(string loginToken, string roomId, string message) { var login = _loginTokenGateway.Get(loginToken); var roomReference = new RoomReference(roomId, CacheField.Room); var learningRoom = _learningRoomGateway.Load(roomReference); learningRoom.ChatAspects.Add(new ChatAspect { Reference = new ChatReference(Guid.NewGuid().ToString()), Room = roomReference, Content = message, CreatedBy = login.OpenId, CreatedOn = DateTimeUtil.GetNow() }); await Task.Run(() => _learningRoomWithChatsSynchronizor.Update(learningRoom)); }
/// <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; }
//recursively display the children of the room references? void DebugRoomReference(RoomReference roomRef) { if (roomRef.children.Count == 0) { Debug.Log("Room Type: " + roomRef.type); Debug.Log("End of path"); } else if (roomRef.children.Count == 1) { Debug.Log("Room Type: " + roomRef.type); DebugRoomReference(roomRef.children[0]); } else if (roomRef.children.Count == 2) { Debug.Log("Room Type: " + roomRef.type); DebugRoomReference(roomRef.children[0]); DebugRoomReference(roomRef.children[1]); } }
//Removes a powered up room from the wave spawn list and adds its children to the list in its place. public void PowerUpRoom(RoomReference roomRef) { if (transformerUpgradeCost == transformerUpgradeTally) { transformerUpgradeTally = 0; transformerUpgradeCost++; } else { transformerUpgradeTally++; } waveSpawnRooms.Remove(roomRef); foreach (RoomReference child in roomRef.children) { waveSpawnRooms.Add(child); } }
public void AllRoomsBroadcast(LitePeer peer, OperationRequest operationRequest, SendParameters sendParameters, byte EventCode) { foreach (string roomName in roomList) { RoomReference rr = DiscussionGameCache.Instance.GetRoomReference(roomName); DiscussionRoom discussionRoom = rr.Room as DiscussionRoom; if (discussionRoom != null) { discussionRoom.Broadcast(peer, operationRequest, sendParameters, EventCode, BroadcastTo.RoomAll); } } BroadcastLobby(operationRequest, sendParameters, EventCode); }
protected virtual void HandleJoinOperation(OperationRequest operationRequest, SendParameters sendParameters) { // create join operation var joinRequest = new JoinRequest(Protocol, operationRequest); if (ValidateOperation(joinRequest, sendParameters) == false) { return; } // remove peer from current game RemovePeerFromCurrentRoom(); // get a game reference from the game cache // the game will be created by the cache if it does not exists already var gameReference = GetRoomReference(joinRequest); // save the game reference in the peers state RoomReference = gameReference; // finally enqueue the operation into game queue gameReference.Room.EnqueueOperation(this, operationRequest, sendParameters); }
//overritten to inject discussion lobby cache /// <summary> /// Joins the peer to a <see cref = "LiteLobby" />. /// Called by <see cref = "HandleJoinOperation">HandleJoinOperation</see>. /// </summary> /// <param name = "joinRequest"> /// The join operation. /// </param> /// <param name = "sendParameters"> /// The send Parameters. /// </param> protected override void HandleJoinLobby(JoinRequest joinRequest, SendParameters sendParameters) { _dbId = (int)joinRequest.ActorProperties[(byte)ActProps.DbId]; var devType = (int)joinRequest.ActorProperties[(byte)ActProps.DevType]; handleOnlineStatus(_photonPer, _dbId, true, devType); // remove the peer from current game if the peer // allready joined another game this.RemovePeerFromCurrentRoom(); // get a lobby reference from the game cache // the lobby will be created by the cache if it does not exists allready RoomReference lobbyReference = DiscussionLobbyCache.Instance.GetRoomReference(joinRequest.GameId); // save the lobby(room) reference in peers state this.RoomReference = lobbyReference; // enqueue the operation request into the games execution queue lobbyReference.Room.EnqueueOperation(this, joinRequest.OperationRequest, sendParameters); lobbyReference.Room.EnqueueOperation(this, new OperationRequest((byte)DiscussionOpCode.NotifyLeaveUser), sendParameters); }
void ConstructLevel(RoomReference roomRef) { //what I need to do is take the core rooms reference //if its type is zero place the room at its coordantes //add the room itsself to its reference. //ensure the rooms exits are correct based on its parents exit //I NEED EACH ROOM REFERENCE TO HAVE A CLEAR UNDERSTANDING OF ITS OWN EXIT TYPES, 1 OR 2 //checks if the room is the core, in which case has a custom placement if (roomRef.type == 1) { roomRef.room = Instantiate(CoreRoom, new Vector3(roomRef.x * roomWidth, roomRef.y * roomHeight, 0), Quaternion.identity, RoomContainer.transform); roomRef.isRoomPowered = true; } else { //This block of statments checks what exits are being used and selects from the opproperate list to use for the room. if (roomRef.exits[0] != 0 && roomRef.exits[1] != 0 && roomRef.exits[2] != 0) { roomRef.room = Instantiate(URDRooms[Random.Range(0, URDRooms.Length)], new Vector3(roomRef.x * roomWidth, roomRef.y * roomHeight, 0), Quaternion.identity, RoomContainer.transform); } else if (roomRef.exits[1] != 0 && roomRef.exits[2] != 0 && roomRef.exits[3] != 0) { roomRef.room = Instantiate(RDLRooms[Random.Range(0, RDLRooms.Length)], new Vector3(roomRef.x * roomWidth, roomRef.y * roomHeight, 0), Quaternion.identity, RoomContainer.transform); } else if (roomRef.exits[0] != 0 && roomRef.exits[2] != 0 && roomRef.exits[3] != 0) { roomRef.room = Instantiate(UDLRooms[Random.Range(0, UDLRooms.Length)], new Vector3(roomRef.x * roomWidth, roomRef.y * roomHeight, 0), Quaternion.identity, RoomContainer.transform); } else if (roomRef.exits[0] != 0 && roomRef.exits[1] != 0 && roomRef.exits[3] != 0) { roomRef.room = Instantiate(URLRooms[Random.Range(0, URLRooms.Length)], new Vector3(roomRef.x * roomWidth, roomRef.y * roomHeight, 0), Quaternion.identity, RoomContainer.transform); } else if (roomRef.exits[0] != 0 && roomRef.exits[3] != 0) { roomRef.room = Instantiate(ULRooms[Random.Range(0, ULRooms.Length)], new Vector3(roomRef.x * roomWidth, roomRef.y * roomHeight, 0), Quaternion.identity, RoomContainer.transform); } else if (roomRef.exits[0] != 0 && roomRef.exits[2] != 0) { roomRef.room = Instantiate(UDRooms[Random.Range(0, UDRooms.Length)], new Vector3(roomRef.x * roomWidth, roomRef.y * roomHeight, 0), Quaternion.identity, RoomContainer.transform); } else if (roomRef.exits[0] != 0 && roomRef.exits[1] != 0) { roomRef.room = Instantiate(URRooms[Random.Range(0, URRooms.Length)], new Vector3(roomRef.x * roomWidth, roomRef.y * roomHeight, 0), Quaternion.identity, RoomContainer.transform); } else if (roomRef.exits[3] != 0 && roomRef.exits[2] != 0) { roomRef.room = Instantiate(LDRooms[Random.Range(0, LDRooms.Length)], new Vector3(roomRef.x * roomWidth, roomRef.y * roomHeight, 0), Quaternion.identity, RoomContainer.transform); } else if (roomRef.exits[3] != 0 && roomRef.exits[1] != 0) { roomRef.room = Instantiate(LRRooms[Random.Range(0, LRRooms.Length)], new Vector3(roomRef.x * roomWidth, roomRef.y * roomHeight, 0), Quaternion.identity, RoomContainer.transform); } else if (roomRef.exits[2] != 0 && roomRef.exits[1] != 0) { roomRef.room = Instantiate(DRRooms[Random.Range(0, DRRooms.Length)], new Vector3(roomRef.x * roomWidth, roomRef.y * roomHeight, 0), Quaternion.identity, RoomContainer.transform); } if (roomRef.room == null) { Debug.LogWarning("The f***s happened here?"); Debug.Break(); } if (roomRef.room != null) { roomRef.room.GetComponent <Room>().NewRoom(ref roomRef); } } if (roomRef.children.Count == 0) { } else if (roomRef.children.Count == 1) { ConstructLevel(roomRef.children[0]); } else if (roomRef.children.Count == 2) { ConstructLevel(roomRef.children[0]); ConstructLevel(roomRef.children[1]); } }
protected virtual bool TryCreateRoom(string gameId, out RoomReference roomReference, params object[] args) { return(HiveGameCache.Instance.TryCreateRoom(gameId, this, out roomReference, args)); }
protected virtual bool TryGetRoomReference(string gameId, out RoomReference roomReference) { return(GameCache.Instance.TryGetRoomReference(gameId, this, out roomReference)); }
public ILearningRoom Load(RoomReference reference) { var roomAspect = _roomAspectLoader.Load(reference); return(new LearningRoomDomain(roomAspect)); }
protected override bool TryGetRoomReference(string gameId, out RoomReference roomReference) { return(this.application.GameCache.TryGetRoomReference(gameId, this, out roomReference)); }
protected override bool TryCreateRoom(string gameId, out RoomReference roomReference, params object[] args) { return(this.application.GameCache.TryCreateRoom(gameId, this, out roomReference, args)); }
public IList <ISignInAspect> Load(RoomReference reference) { var signInEntities = _signInRepository.FindByRoom(reference.Code); return(signInEntities.Select(_signInAspectMapper.Map).ToList()); }