Example #1
0
 public Controller(int RoomSize)
 {
     for (int i = 0; i < RoomSize; i++)
     {
         RoomList.Add(new Room());
     }
 }
Example #2
0
        public RandomRoom CreateRoom(WaitUser[] members)
        {
            string roomID;

            do
            {
                // create a random string of 8 characters
                string chars       = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
                char[] stringChars = new char[8];
                Random random      = new Random();
                for (int i = 0; i < stringChars.Length; i++)
                {
                    stringChars[i] = chars[random.Next(chars.Length)];
                }
                roomID = new String(stringChars);
            } while (SearchRoom(roomID) != null);

            RandomRoom room = new RandomRoom
            {
                ID      = roomID,
                Members = members
            };

            RoomList.Add(room);
            return(room);
        }
Example #3
0
        /// <summary>
        /// Start the Room system.
        /// </summary>
        public override void Start()
        {
            SystemHost.UpdateSystemHost(this, "Starting...");
            RoomList.Add("main", new DefaultRoom());
            var num = LoadUserOwnedRooms();

            SystemHost.UpdateSystemHost(this, $"Loaded {num} user owned rooms");
            SystemHost.UpdateSystemHost(this, "Started");
        }
Example #4
0
        /// <summary>
        /// 更新部分
        /// </summary>
        private void RefreshSome(List <long> RoomsId)
        {
            _element.Dispatcher.BeginInvoke(new Action(() =>
            {
                foreach (var RoomId in RoomsId)
                {
                    RoomModel item       = Resources.GetRes().RoomsModel.Where(x => x.RoomId == RoomId).FirstOrDefault();
                    RoomStateModel model = RoomList.Where(x => x.RoomId == RoomId).FirstOrDefault();
                    if (null == model)
                    {
                        RoomStateModel newRoomStateModel = new RoomStateModel()
                        {
                            RoomId = item.RoomId, RoomNo = item.RoomNo, UseState = (null != item.PayOrder), OrderSession = item.OrderSession, PayOrder = item.PayOrder, OpenRoom = OpenRoom
                        };
                        RoomList.Add(newRoomStateModel);
                    }
                    else
                    {
                        if (null != item && null != model && model.OrderSession != item.OrderSession)
                        {
                            RoomStateModel oldModel = RoomList.Where(x => null != x.OrderSession && x.OrderSession.Equals(model.OrderSession, StringComparison.Ordinal)).FirstOrDefault();
                            int no = RoomList.Count;
                            if (null != oldModel)
                            {
                                no = RoomList.IndexOf(oldModel);
                                RoomList.RemoveAt(no);
                            }
                            RoomStateModel newRoomStateModel = new RoomStateModel()
                            {
                                RoomId = item.RoomId, RoomNo = item.RoomNo, UseState = (null != item.PayOrder), OrderSession = item.OrderSession, PayOrder = item.PayOrder, OpenRoom = OpenRoom
                            };
                            RoomList.Insert(no, newRoomStateModel);
                        }
                        else
                        {
                            if (null != model && item == null)
                            {
                                RoomStateModel oldModel = RoomList.Where(x => x.OrderSession.Equals(model.OrderSession, StringComparison.Ordinal)).FirstOrDefault();
                                if (null != oldModel)
                                {
                                    int no = RoomList.IndexOf(oldModel);
                                    if (-1 != no)
                                    {
                                        RoomList.RemoveAt(no);
                                    }
                                }
                            }
                        }
                    }
                }

                RefreshAll(true);
            }));
        }
Example #5
0
 public bool RegisterCell(string serial, CellRoom cell)
 {
     if (RoomMap.ContainsKey(serial))
     {
         string message = string.Format("Cell {0} is already exist", serial);
         ServerApp.Logger.Error(message);
         return(false);
     }
     RoomList.Add(cell);
     RoomMap[serial] = cell;
     return(true);
 }
Example #6
0
        private int LoadUserOwnedRooms()
        {
            var ret   = 0;
            var rooms = Room.manager.GetAll();

            foreach (var r in rooms)
            {
                var room = new UserOwnedRoom(r);
                RoomList.Add(room.Name.ToLower(), room);
                ret++;
            }
            return(ret);
        }
Example #7
0
        public async Task Init(Guid roomId)
        {
            try
            {
                _roomId = roomId;

                var roomModel = await _bookingService.GetRoomAsync(ApiPriority.UserInitiated, roomId);

                var roomReservations = await _bookingService.GetReservationsAsync(ApiPriority.UserInitiated, roomId);

                if (roomModel != null)
                {
                    // Room info
                    Title            = roomModel.Name;
                    AboutRoomTitle   = $"About {roomModel.Name}";
                    AboutRoomText    = roomModel.Description;
                    AboutRoomVisible = !string.IsNullOrWhiteSpace(roomModel.Description);
                    NumberOfPersons  = $"{roomModel.NumberOfGuests} Persons";

                    // Room images
                    var imageList = roomModel.Images.Select(roomModelImage => new BodySliderData(roomModelImage.Medium)).ToList();
                    foreach (var bodySliderData in imageList)
                    {
                        RoomList.Add(new BodySliderItemViewModel(bodySliderData, () =>
                        {
                            ShowViewModel <ImageZoomViewModel>(new { url = bodySliderData.ImageUrl });
                        }));
                    }

                    ImageUrl = roomModel.Header == null ? Defaults.RoomHeaderDefault : roomModel.Header.Medium;
                    // Check reservations at this current time
                    IsAvailable =
                        !roomReservations.Any(t => t.ReservationStart <DateTime.Now &&
                                                                       t.ReservationEnd> DateTime.Now);

                    var locationModel = await PlatformService.GetLocationAsync(ApiPriority.UserInitiated, roomModel.LocationId);

                    if (locationModel != null)
                    {
                        LocationName         = locationModel.Name;
                        AboutLocationTitle   = $"About {locationModel.Name}";
                        AboutLocationText    = locationModel.AboutText;
                        AboutLocationVisible = !string.IsNullOrWhiteSpace(locationModel.AboutText);
                    }
                }
            }
            catch (Exception ex)
            {
                ExceptionService.HandleException(ex);
            }
        }
        public async Task Init(Guid id)
        {
            try
            {
                _id = id;

                var myreservations = await _bookingService.GetMyReservationsAsync();

                var reservation = myreservations?.Reservations?.FirstOrDefault(r => r.Id == id);

                if (reservation != null)
                {
                    var roomModel = myreservations.Rooms?.FirstOrDefault(r => r.Id == reservation.RoomId);

                    if (roomModel != null)
                    {
                        ImageUrl        = roomModel.Header != null ? roomModel.Header.Large : Defaults.RoomHeaderDefault;
                        ReservationCode = reservation.ReservationCode;
                        Date            = reservation.ReservationStart.ToString("D");
                        Checkin         = reservation.ReservationStart.ToString("t");
                        Checkout        = reservation.ReservationEnd.ToString("t");
                        Room            = roomModel.Name;
                        IsPrivate       = reservation.IsPrivate;
                        Message         = reservation.Message;
                        Title           = reservation.Title;

                        foreach (var roomModelImage in roomModel.Images)
                        {
                            RoomList.Add(new BodySliderItemViewModel(new BodySliderData(roomModelImage.Medium), () =>
                            {
                                ShowViewModel <ImageZoomViewModel>(new { url = roomModelImage.Large });
                            }));
                        }

                        // Get location
                        var locationmodel = await PlatformService.GetLocationAsync(ApiPriority.UserInitiated, roomModel.LocationId);

                        Location = locationmodel?.Name;
                    }
                }
                else
                {
                    // TODO : Show some error?
                }
            }
            catch (Exception ex)
            {
                ExceptionService.HandleException(ex);
            }
        }
Example #9
0
        /// <summary>
        /// 第一次加载所有
        /// </summary>
        private void FirstLoad()
        {
            RoomList.Clear();

            foreach (var item in Resources.GetRes().RoomsModel.OrderByDescending(x => x.Order).ThenBy(x => x.RoomNo.Length).ThenBy(x => x.RoomNo))
            {
                RoomList.Add(new RoomStateModel()
                {
                    RoomId = item.RoomId, RoomNo = item.RoomNo, UseState = (null != item.PayOrder), OrderSession = item.OrderSession, PayOrder = item.PayOrder, OpenRoom = OpenRoom
                });
            }


            RefreshAll(false);
        }
Example #10
0
        public JsonResult CreateRoom(PlayerRoom room)
        {
            bool flag = roomList.Add(new PlayerRoom {
                TotalLimit = room.TotalLimit,
                Name       = room.Name,
                PlayerList = new List <Player>(),
            });

            if (flag)
            {
                var query       = roomList.FindAll(x => string.Equals(x.Name, room.Name));
                var queryPlayer = playerList.FindAll(x => string.Equals(x.ConnectionId, Context.ConnectionId));
                if (query != null && query.Count > 0)
                {
                    if (queryPlayer != null && queryPlayer.Count > 0)
                    {
                        queryPlayer.FirstOrDefault().RoomName = room.Name;
                        query.FirstOrDefault().PlayerList.Add(queryPlayer.FirstOrDefault());
                        Groups.Add(Context.ConnectionId, room.Name);
                        CurrentRoomList();
                        return(new JsonResult {
                            Data = new { result = true, data = JavaScriptObjectParser.Parse(roomList) }
                        });
                    }
                    else
                    {
                        return(new JsonResult {
                            Data = new { result = false }
                        });
                    }
                }
                else
                {
                    return(new JsonResult {
                        Data = new { result = false }
                    });
                }
            }
            else
            {
                return(new JsonResult {
                    Data = new { result = false }
                });
            }
        }
Example #11
0
        /// <summary>
        /// Create a new room if one with the provided name does not already exist.
        /// </summary>
        /// <param name="sender">Session of the user trying to create a room.</param>
        /// <param name="name">Name of the room to create.</param>
        /// <returns></returns>
        public static UserOwnedRoom CreateRoom(Session sender, string name)
        {
            var record = new Room()
            {
                Name        = name,
                Description = "",
                OwnerUserID = sender.User.ID
            };
            var room = RoomList.ContainsKey(name.ToLower()) ? null : new UserOwnedRoom(record);

            if (room != null)
            {
                var id = Room.manager.Create(room.Data);
                room.Data = Room.manager.Get(id);
                RoomList.Add(room.Name.ToLower(), room);
            }
            return(room);
        }
Example #12
0
    public IEnumerator CreateCorridors()
    {
        foreach (GeneratorRoom room in grid.RoomList)
        {
            roomList.Add(room);
        }

        while (roomList.Count > 0)
        {
            Vector2i room1Pos = roomList[0].location;
            Vector2i room2Pos = FindNearestInList(room1Pos);
            if (room2Pos.x != Vector2i.zero.x || room2Pos.y != Vector2i.zero.y)
            {
                grid.CreateCorridor(prefab, room1Pos, room2Pos);
            }

            yield return(0);
        }
    }
Example #13
0
    public GeneratorRoom CreateRoom(Vector2i chunkPos, GeneratorChunk groundPrefab, Vector2i roomSize, bool isSecure = false)
    {
        GeneratorRoom newRoom = new GeneratorRoom();
        GameObject    room    = new GameObject();

        room.transform.SetParent(parent.transform);
        Color testColor = new Color(Random.Range(0.0f, 1.0f), Random.Range(0.0f, 1.0f), Random.Range(0.0f, 1.0f), 1.0f);

        room.name = "Room";

        for (int i = 0; i < roomSize.y; i++)
        {
            for (int j = 0; j < roomSize.x; j++)
            {
                GeneratorChunk c = CreateChunk(chunkPos + new Vector2i(j, i), groundPrefab, testColor, room);
                newRoom.chunks.Add(c);
            }
        }

        if (isSecure)
        {
            newRoom.isSafe = true;
            room.name      = "SecureRoom";
            safeRoomList.Add(newRoom);
        }
        else
        {
            unSafeRoomList.Add(newRoom);
        }

        newRoom.location = chunkPos;
        newRoom.size     = roomSize;

        roomList.Add(newRoom);

        return(newRoom);
    }
Example #14
0
        public async Task CreateRoom()
        {
            var room = await httpClient.PostJsonAsync <Room>(@"api/room", new Room());

            RoomList.Add(room);
        }
Example #15
0
 public void AddSquareRoom(string IdSquareRoom, int posXInCompleteRoom, int posYInCompleteRoom)
 {
     RoomList.Add(new SquareRoom(this, IdSquareRoom, posXInCompleteRoom, posYInCompleteRoom));
 }
Example #16
0
    private void Generate()
    {
        // create initial room point
        // always will be room 1
        Room startRoom = new Room("Rooms/room1");

        startRoom.MinimapRoomCoordinates = new Vector2((float)Math.Round((double)(maxWidth / 2)), (float)Math.Round((double)(maxHeight / 2)));    // start in middle
        startRoom.Visited = true;
        RoomList.Add(startRoom);
        _currentAmtOfRooms++;

        // set some properties
        // tile size is 32x32.  We need to adjust room width and height so we don't get the extra space around the room that holds
        // the collisions for the passages.
        RoomWidth  = startRoom.GetRoomWidth() - (2 * tileSize);
        RoomHeight = startRoom.GetRoomHeight() - (2 * tileSize);

        while (true)
        {
            // out of rooms
            if (_maxRooms - _currentAmtOfRooms <= 0)
            {
                break;
            }
            if (_currentRoomIndex >= RoomList.Count)
            {
                break;
            }

            CurrentRoom = RoomList[_currentRoomIndex];
            // randomly choose amount of directions to branch depending on which
            // is less: max rooms left to place or connections possible for room
            //int maxPossibleConnections = Math.Min(_maxRooms - _currentAmtOfRooms, CurrentRoom.GetPossibleConnectionCount(RoomList));
            int maxPossibleConnections = Math.Min(_maxRooms - _currentAmtOfRooms, GetPossibleConnectionsCount());

            // if we can't connect, go to next room
            if (maxPossibleConnections <= 0)
            {
                _currentRoomIndex++;
                continue;
            }

            // generated max amount of rooms
            if (maxPossibleConnections == 0)
            {
                break;
            }

            int todoConnections = XeldaGame.rand.Next(1, maxPossibleConnections + 1);
            // for each needed room, generate and connect the rooms
            for (int i = 0; i < todoConnections; i++)
            {
                Direction dir        = GetRandomDirectionForConnection(CurrentRoom);
                int       roomNumber = XeldaGame.rand.Next(1, _maxRoomTemplates + 1);
                Room      room       = new Room("Rooms/room" + roomNumber, dir, RoomList.IndexOf(CurrentRoom));
                room.Visited = false;
                SetDebugRoomPosition(CurrentRoom, room, dir);
                RoomList.Add(room);
                _currentAmtOfRooms++;
                CurrentRoom.ConnectThisToNewRoom(dir, RoomList.IndexOf(room));
            }

            // treat list like queue and go to next node and build off of that.
            _currentRoomIndex++;
        }

        // set CurrentRoom back to 0 so player starts at first node.
        CurrentRoom = RoomList[0];

        // first room of dungeon should have no mobs
        CurrentRoom.ClearMobsFromRoom();

        // tell each room to add walls to block passages that have no adjacent room to connect
        foreach (Room room in RoomList)
        {
            room.AddPassageWalls();
        }
    }
Example #17
0
    public void RoomGen(int minRoomSize, int maxRoomSize)
    {
        bool failed  = false;
        int  width   = rand.Next(minRoomSize, maxRoomSize);
        int  heigth  = rand.Next(minRoomSize, maxRoomSize);
        int  x       = rand.Next(1, mapWidth - width - 1);
        int  y       = rand.Next(1, mapHeight - heigth - 1);
        Room newRoom = new Room(x, y, width, heigth);

        //Debug.Log($"Room x:{x} Room y:{y}");
        foreach (Room other in RoomList)
        {
            if (newRoom.Intercept(other))
            {
                failed = true;
                //Debug.Log("intercept");
                break;
            }
        }
        if (!failed)
        {
            RoomList.Add(newRoom);
            //Debug.Log($"room center:{newRoom.Center.x}, {newRoom.Center.y}");
            for (int rX = newRoom.X1; rX <= newRoom.X2; rX++)
            {
                for (int rY = newRoom.Y1; rY <= newRoom.Y2; rY++)
                {
                    int rando = rY % 5;
                    MapArr[rY, rX] = "ground" + rando;
                }
            }
        }
        if (RoomList.Count > 1)
        {
            int x1 = RoomList[RoomList.Count - 1].Center.x;
            int y1 = RoomList[RoomList.Count - 1].Center.y;
            int x2 = RoomList[RoomList.Count - 2].Center.x;
            int y2 = RoomList[RoomList.Count - 2].Center.y;

            int coin_flip = rand.Next(0, 2);
            if (coin_flip == 0)
            {
                for (int i = Math.Min(x1, x2); i <= Math.Max(x1, x2); i++)
                {
                    MapArr[y1, i] = "ground" + i % 5;
                }
                for (int j = Math.Min(y1, y2); j <= Math.Max(y1, y2); j++)
                {
                    MapArr[j, x2] = "ground" + j % 5;
                }
                //MapArr[RoomList[RoomList.Count - 1].Center.y, RoomList[RoomList.Count - 1].Center.x] = "defaultWater";
            }
            else if (coin_flip == 1)
            {
                for (int j = Math.Min(y1, y2); j <= Math.Max(y1, y2); j++)
                {
                    MapArr[j, x1] = "ground" + j % 5;
                }
                for (int i = Math.Min(x1, x2); i <= Math.Max(x1, x2); i++)
                {
                    MapArr[y2, i] = "ground" + i % 5;
                }
                //MapArr[RoomList[RoomList.Count - 1].Center.y, RoomList[RoomList.Count - 1].Center.x] = "defaultWater";
            }
            foreach (Vector2Int vec in RoomList[RoomList.Count - 1].WaterList)
            {
                MapArr[vec.y, vec.x] = "defaultWater";
            }
        }
    }
Example #18
0
        void _serverConnection_DataReceived(object sender, EventArgs e)
        {
            _context.Post(new SendOrPostCallback(delegate(object state)
            {
                try
                {
                    if (_serverConnection != null)
                    {
                        byte[] data = _serverConnection.ReadData();
                        while (data != null)
                        {
                            //parse data
                            ChatMessage msg = ChatMessage.Parse(data);
                            if (msg != null)
                            {
                                //handle data
                                if (msg.Name == "signinfailed")
                                {
                                    closeConnection();
                                    break;
                                }
                                else if (msg.Name == "signinsuccess")
                                {
                                    _retryCount          = 0;
                                    ChatConnectionStatus = ConnectionStatus.SignedIn;
                                }
                                else if (msg.Name == "txt")
                                {
                                    if (NewTextMessage != null)
                                    {
                                        NewTextMessage(this, msg.ID, msg.Parameters["msg"], Color.FromArgb(int.Parse(msg.Parameters["color"])));
                                    }
                                    if (Core.Settings.Default.ChatPlaySounds && _sndMessage != null)
                                    {
                                        _sndMessage.Play();
                                    }
                                }
                                else if (msg.Name == "usersinroom")
                                {
                                    bool newUser = false;
                                    int i        = 0;
                                    foreach (var x in UsersInRoomList)
                                    {
                                        x.present = false;
                                    }
                                    bool wasempty = UsersInRoomList.Count == 0;
                                    while (msg.Parameters.ContainsKey(string.Format("name{0}", i)))
                                    {
                                        string id        = msg.Parameters[string.Format("id{0}", i)];
                                        UserInRoomInfo c = (from x in UsersInRoomList where x.ID == id select x).FirstOrDefault();
                                        if (c == null)
                                        {
                                            c                = new UserInRoomInfo();
                                            c.ID             = id;
                                            c.Username       = msg.Parameters[string.Format("name{0}", i)];
                                            c.present        = true;
                                            c.FollowThisUser = false;
                                            c.SelectionCount = -1;
                                            if (msg.Parameters.ContainsKey(string.Format("sc{0}", i)))
                                            {
                                                string selCount = msg.Parameters[string.Format("sc{0}", i)];
                                                if (!string.IsNullOrEmpty(selCount))
                                                {
                                                    c.SelectionCount = int.Parse(selCount);
                                                }
                                            }
                                            c.CanBeFollowed  = bool.Parse(msg.Parameters[string.Format("cbf{0}", i)]);
                                            c.ActiveGeocache = msg.Parameters[string.Format("agc{0}", i)];
                                            UsersInRoomList.Add(c);
                                            if (!wasempty)
                                            {
                                                if (NewTextMessage != null)
                                                {
                                                    NewTextMessage(this, "-1", string.Format("{0} {1}", c.Username, Localization.TranslationManager.Instance.Translate("JoinedTheRoom") as string), Color.Black);
                                                }
                                            }
                                            newUser = true;
                                        }
                                        else
                                        {
                                            bool cbf         = c.CanBeFollowed;
                                            string agc       = c.ActiveGeocache;
                                            c.CanBeFollowed  = bool.Parse(msg.Parameters[string.Format("cbf{0}", i)]);
                                            c.ActiveGeocache = msg.Parameters[string.Format("agc{0}", i)];
                                            c.present        = true;
                                            c.UpdateText();
                                            if (cbf != c.CanBeFollowed || agc != c.ActiveGeocache)
                                            {
                                                if (UserInfoUpdate != null)
                                                {
                                                    UserInfoUpdate(this, c);
                                                }
                                            }
                                        }
                                        i++;
                                    }
                                    var rmList = from a in UsersInRoomList where !a.present select a;
                                    foreach (var x in rmList)
                                    {
                                        UsersInRoomList.Remove(x);
                                    }

                                    if (newUser && Core.Settings.Default.ChatPlaySounds && _sndWelcome != null)
                                    {
                                        _sndWelcome.Play();
                                    }
                                }
                                else if (msg.Name == "follow")
                                {
                                    UserInRoomInfo[] curUsr = UsersInRoomList.ToArray();
                                    UserInRoomInfo c        = (from x in curUsr where x.ID == msg.ID select x).FirstOrDefault();
                                    if (c != null)
                                    {
                                        c.CanBeFollowed  = bool.Parse(msg.Parameters["canfollow"]);
                                        c.ActiveGeocache = msg.Parameters["cache"];
                                        c.SelectionCount = -1;
                                        if (msg.Parameters.ContainsKey("selected"))
                                        {
                                            string selCount = msg.Parameters["selected"];
                                            if (!string.IsNullOrEmpty(selCount))
                                            {
                                                c.SelectionCount = int.Parse(selCount);
                                            }
                                        }

                                        if (c.FollowThisUser)
                                        {
                                            if (!c.CanBeFollowed)
                                            {
                                                c.FollowThisUser = false;
                                            }
                                        }
                                        c.UpdateText();
                                        if (UserInfoUpdate != null)
                                        {
                                            UserInfoUpdate(this, c);
                                        }
                                    }
                                }
                                else if (msg.Name == "rooms")
                                {
                                    RoomInfo[] curRms = RoomList.ToArray();
                                    foreach (var x in curRms)
                                    {
                                        x.present = false;
                                    }
                                    int i = 0;
                                    while (msg.Parameters.ContainsKey(string.Format("name{0}", i)))
                                    {
                                        string name = msg.Parameters[string.Format("name{0}", i)];
                                        RoomInfo c  = (from x in curRms where x.Name == name select x).FirstOrDefault();
                                        if (c == null)
                                        {
                                            c         = new RoomInfo();
                                            c.present = true;
                                            c.Name    = name;
                                            RoomList.Add(c);
                                        }
                                        else
                                        {
                                            c.present = true;
                                        }
                                        i++;
                                    }
                                    var rmList = from a in RoomList where !a.present select a;
                                    foreach (var x in rmList)
                                    {
                                        RoomList.Remove(x);
                                    }
                                }
                                else if (msg.Name == "reqsel")
                                {
                                    StringBuilder sb        = new StringBuilder();
                                    UserInRoomInfo[] curUsr = UsersInRoomList.ToArray();
                                    UserInRoomInfo c        = (from x in curUsr where x.ID == msg.ID select x).FirstOrDefault();
                                    if (c != null)
                                    {
                                        if (NewTextMessage != null)
                                        {
                                            NewTextMessage(this, "-1", string.Format("{0} {1}", c.Username, Localization.TranslationManager.Instance.Translate("RequestedSelection") as string), Color.Black);
                                        }
                                        if (Core.ApplicationData.Instance.ActiveDatabase != null)
                                        {
                                            var gsel = from Core.Data.Geocache g in Core.ApplicationData.Instance.ActiveDatabase.GeocacheCollection where g.Selected select g;
                                            foreach (var g in gsel)
                                            {
                                                sb.AppendFormat("{0},", g.Code);
                                            }
                                        }
                                    }

                                    ChatMessage bmsg = new ChatMessage();
                                    bmsg.Name        = "reqselresp";
                                    bmsg.Parameters.Add("reqid", msg.Parameters["reqid"]);
                                    bmsg.Parameters.Add("clientid", msg.ID);
                                    bmsg.Parameters.Add("selection", sb.ToString());

                                    SendMessage(bmsg);
                                }
                                else if (msg.Name == "reqselresp")
                                {
                                    if (msg.Parameters["reqid"] == _currentCopySelectionRequestID && _getGeocacheThread == null)
                                    {
                                        //handle response
                                        Core.Storage.Database db = Core.ApplicationData.Instance.ActiveDatabase;
                                        if (db != null)
                                        {
                                            string[] gcCodes = msg.Parameters["selection"].Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
                                            using (Utils.DataUpdater upd = new Utils.DataUpdater(db))
                                            {
                                                foreach (var g in db.GeocacheCollection)
                                                {
                                                    g.Selected = gcCodes.Contains(g.Code);
                                                }
                                            }
                                            //are we missing geocaches?
                                            _importGeocaches.Clear();
                                            if (Core.Settings.Default.LiveAPIMemberTypeId > 0)
                                            {
                                                foreach (string s in gcCodes)
                                                {
                                                    if (db.GeocacheCollection.GetGeocache(s) == null && s.StartsWith("GC"))
                                                    {
                                                        _importGeocaches.Add(s);
                                                    }
                                                }
                                                if (_importGeocaches.Count > 0)
                                                {
                                                    _copySelectionDb   = db;
                                                    _dataUpdater       = new Utils.DataUpdater(db);
                                                    _getGeocacheThread = new Thread(new ThreadStart(getCopiedSelectionGeocacheInbackgroundMethod));
                                                    _getGeocacheThread.IsBackground = true;
                                                    _getGeocacheThread.Start();
                                                }
                                            }
                                        }
                                    }
                                    _currentCopySelectionRequestID = null;
                                }
                            }
                            data = _serverConnection.ReadData();
                        }
                    }
                }
                catch
                {
                    closeConnection();
                }
            }), null);
        }
Example #19
0
        protected override void CreateMap()
        {
            // Maintain a list of points bordering the current list of rooms so we can attach
            // more rooms. Also track of the facing of the wall the point comes from.
            IList <int> openPoints = new List <int>();

            // Also keep track of the rooms and where they are.
            IList <Room> initialRooms = new List <Room>();

            int[,] occupied = new int[Width, Height];

            // Set up the initial placement of the map. Include special features, if any.
            int          counter  = InitialPlacement(initialRooms, openPoints, ref occupied);
            IList <Room> allRooms = new List <Room>(initialRooms);

            while (openPoints.Count > 0)
            {
                // Choose a random point to create a room around;
                int index  = openPoints[Rand.Next(openPoints.Count)];
                int availX = index % Width;
                int availY = index / Width;

                // Fit a room around the point as best as possible. AdjustRoom should avoid most
                // collisions between rooms.
                int  width  = (int)Rand.NextGamma(_ALPHA, _BETA);
                int  height = (int)Rand.NextGamma(_ALPHA, _BETA);
                Room room   = AdjustRoom(availX, availY, width, height, occupied);

                // Update the room list, the open point list, and the location grid.
                RemoveOpenPoints(room, openPoints);
                if (TrackRoom(room, allRooms, counter + 1, ref occupied))
                {
                    counter++;
                }

                AddOpenPoints(room, openPoints, occupied);
            }

            // Use the largest areas as rooms and triangulate them to calculate hallways.
            RoomList = allRooms
                       .OrderByDescending(r => r.Area)
                       .Take((int)(allRooms.Count * _FILL_PERCENT))
                       .ToList();

            // Ensure that prefab elements are included
            foreach (Room initial in initialRooms)
            {
                if (!RoomList.Contains(initial))
                {
                    RoomList.Add(initial);
                }
            }

            // If we don't get enough rooms, we can't (and don't need to) triangulate, so just
            // draw in what we have.
            if (RoomList.Count == 1)
            {
                CreateRoomWithoutBorder(RoomList[0]);
            }
            else if (RoomList.Count == 2)
            {
                // Add the only hallway to the hall list
                Adjacency = new ICollection <int>[] { new[] { 1 }, new[] { 0 } };
                ClearRoomsBetween(RoomList[0], RoomList[1], allRooms, occupied);
            }
            else
            {
                var polygon = new Polygon();
                foreach (Room room in RoomList)
                {
                    polygon.Add(new Vertex(room.Center.X, room.Center.Y));
                }
                IMesh delaunay = polygon.Triangulate();

                // Reduce the number of edges and clear out rooms along the remaining edges.
                ICollection <int>[] adj = BuildAdjacencyList(delaunay.Edges, RoomList.Count);
                var edges = TrimEdges(adj, RoomList).ToList();

                // Restore some edges, so exploring is a bit more interesting
                RestoreEdges(edges, delaunay.Edges.ToList(), adj, _END_TYPE);
                Adjacency = BuildAdjacencyList(edges, RoomList.Count);

                foreach (Edge edge in edges)
                {
                    ClearRoomsBetween(RoomList[edge.P0], RoomList[edge.P1], allRooms, occupied);
                }
            }

            PostProcess();
        }
Example #20
0
 /* Methods */
 public void AddRoom(HotelRoom r)
 {
     RoomList.Add(r);
 }