public IList <IChatAspect> Load(RoomReference reference)
 {
     return(_chatRepository
            .FindByRoom(reference.Code)
            .Select(_chatAspectMapper.Map)
            .ToList());
 }
Ejemplo n.º 2
0
        /// <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);
            }
        }
Ejemplo n.º 3
0
        public IRoomAspect Load(RoomReference reference)
        {
            var roomEntity   = _roomRepository.FindById(reference.Code);
            var participants = _participantRepository.FindByRoom(reference.Code);

            return(_roomAspectMapper.Map(roomEntity, participants));
        }
Ejemplo n.º 4
0
        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));
        }
Ejemplo n.º 5
0
    public void NewRoom(ref RoomReference roomReference)
    {
        this.roomReference = roomReference;

        SetupExits();
        SetupObjects();
    }
Ejemplo n.º 6
0
        /// <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);
        }
Ejemplo n.º 7
0
        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
            });
        }
Ejemplo n.º 9
0
        public ILearningRoomWithSignIn Load(RoomReference reference)
        {
            var roomAspect    = _roomAspectLoader.Load(reference);
            var signInAspects = _signInAspectLoader.Load(reference);

            return(new LearningRoomWithSignIn(roomAspect)
            {
                SignIns = signInAspects
            });
        }
Ejemplo n.º 10
0
    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);
    }
Ejemplo n.º 11
0
        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);
        }
Ejemplo n.º 13
0
 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;
 }
Ejemplo n.º 14
0
        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;
            }
        }
Ejemplo n.º 15
0
        /// <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);
        }
Ejemplo n.º 16
0
    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));
    }
Ejemplo n.º 17
0
        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));
        }
Ejemplo n.º 18
0
        /// <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;
        }
Ejemplo n.º 19
0
 //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]);
     }
 }
Ejemplo n.º 20
0
    //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);
        }
    }
Ejemplo n.º 21
0
 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);
 }
Ejemplo n.º 22
0
        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);
        }
Ejemplo n.º 23
0
        //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);
        }
Ejemplo n.º 24
0
    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));
 }
Ejemplo n.º 26
0
 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));
        }
Ejemplo n.º 28
0
 protected override bool TryGetRoomReference(string gameId, out RoomReference roomReference)
 {
     return(this.application.GameCache.TryGetRoomReference(gameId, this, out roomReference));
 }
Ejemplo n.º 29
0
 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());
        }