コード例 #1
0
        public double DiagonalDistanceTo(BuildingBlock point)
        {
            double xDistance = Math.Abs(X - point.X);
            double yDistance = Math.Abs(Y - point.Y);

            if (xDistance > yDistance)
            {
                return(Math.Sqrt(2) * yDistance + 1 * (xDistance - yDistance));
            }
            return(Math.Sqrt(2) * xDistance + 1 * (yDistance - xDistance));
        }
コード例 #2
0
        private void InitializeRoomPriority(BuildingBlock door)
        {
            _globalRoomCounter++;
            int  targetPriority           = door.Priority + 1;
            bool done                     = false;
            List <BuildingBlock> tileList = BuildingBlocks.Values.Where(t => t.Type == Tile.Types.Free ||
                                                                        t.Type == Tile.Types.Person ||
                                                                        t.Type == Tile.Types.Stair).ToList();
            List <BuildingBlock> doorNeighbours =
                door.BuildingBlockNeighbours.Where(
                    n =>
                    (n.Type == Tile.Types.Free || n.Type == Tile.Types.Person) &&
                    n.Priority > targetPriority).ToList();

            if (doorNeighbours.Count == 0)
            {
                done = true;
            }
            foreach (BuildingBlock block in doorNeighbours)
            {
                block.Priority = targetPriority;
                if (block.Room == 0)
                {
                    block.Room = _globalRoomCounter;
                }
            }
            do
            {
                if (tileList.Any(b => b.BuildingBlockNeighbours.Any(n => n.Priority == targetPriority) &&
                                 b.Priority > targetPriority &&
                                 (b.Type == Tile.Types.Free || b.Type == Tile.Types.Person)))
                {
                    foreach (
                        BuildingBlock block in
                        tileList.Where(b => b.BuildingBlockNeighbours.Any(n => n.Priority == targetPriority && n.Z == b.Z) &&
                                       b.Priority > targetPriority))
                    {
                        block.Priority = targetPriority;
                        if (block.Room == 0)
                        {
                            block.Room = _globalRoomCounter;
                        }
                    }
                }
                else
                {
                    done = true;
                }
            } while (!done);
        }
コード例 #3
0
        private void CreateVisualRepresentation()
        {
            int width       = LocalFloorPlan.Width;
            int height      = LocalFloorPlan.Height;
            int floorAmount = LocalFloorPlan.FloorAmount;

            _floorContainer = new Grid[floorAmount];

            for (int z = 0; z < floorAmount; z++)
            {
                Grid container = new Grid()
                {
                    HorizontalAlignment = HorizontalAlignment.Left,
                    VerticalAlignment   = VerticalAlignment.Top
                };
                for (int y = 0; y < height; y++)
                {
                    for (int x = 0; x < width; x++)
                    {
                        Rectangle figure = new Rectangle
                        {
                            Height = TileSize,
                            Width  = TileSize,
                            Fill   = new SolidColorBrush(Colors.White),
                            Tag    = Coordinate(x, y, z), /* Makes binding rectangles to buildingblocks easier */
                            Margin = new Thickness(0, 0, x * TileSize * 2 + x, y * TileSize * 2 + y)
                        };

                        if (LocalFloorPlan.Tiles[Coordinate(x, y, z)].Type != Tile.Types.Free)
                        {
                            ColorizeBuildingBlock(figure, LocalFloorPlan.Tiles[Coordinate(x, y, z)].Type);
                        }

                        BuildingBlock current = (LocalFloorPlan.Tiles[Coordinate(x, y, z)] as BuildingBlock);
                        current.Figure              = figure;
                        figure.ToolTip              = current.ToString();
                        figure.MouseLeftButtonDown += OnBuildingBlockClick;


                        AllRectangles.Add(Coordinate(x, y, z), figure);
                        container.Children.Add(figure);
                    }
                }
                _floorContainer[z] = container;
            }

            VisualContainer.Children.Add(_floorContainer[0]);
        }
コード例 #4
0
        private void OnBuildingBlockClick(object sender, MouseButtonEventArgs e)
        {
            Tile.Types type            = (Tile.Types)OnBuildingBlockTypeFetch?.Invoke(); //Get the type of the currently radio'ed FloorPlanControl-type
            Rectangle  senderRectangle = sender as Rectangle;                            //Get a reference to the sender rectangle

            if (senderRectangle == null)
            {
                throw new GeneralInternalException();
            }
            BuildingBlock senderBlock = (BuildingBlock)LocalFloorPlan.Tiles[senderRectangle.Tag.ToString()];

            SetBlockType(senderBlock, type);
            if (Keyboard.IsKeyDown(Settings.LineToolKey))
            {
                if (previousBlock != null)
                {
                    DrawLine(senderBlock, type);
                }
                previousBlock = senderBlock;
            }
        }
コード例 #5
0
 private void SetExitAndStairPriority(BuildingBlock exitOrStair, IEnumerable <BuildingBlock> doorlist)
 {
     InitializeRoomPriority(exitOrStair);
     do
     {
         foreach (BuildingBlock door in doorlist.Where(d => d.Z == exitOrStair.Z))
         {
             //Checks for each door, if the doors priority is larger than the surrounding buildingblocks
             if (door.Priority >
                 (BuildingBlocks.Values.Where(
                      b => b.BuildingBlockNeighbours.Contains(door) && b.Type == Tile.Types.Free || b.Type == Tile.Types.Person)
                  .Min(n => n.Priority)))
             {
                 door.Priority =
                     (BuildingBlocks.Values.Where(b => (b.Type == Tile.Types.Free || b.Type == Tile.Types.Person) &&
                                                  b.BuildingBlockNeighbours.Contains(door)).Min(n => n.Priority));
                 door.Priority++;
                 InitializeRoomPriority(door);
             }
         }
     } while (doorlist.Any(d => d.Priority - d.BuildingBlockNeighbours.Min(n => n.Priority) > 2));
 }
コード例 #6
0
ファイル: Data.cs プロジェクト: Bargsteen/p2
        //Method using to person, when person is blocked more than 5 rounds.
        private IEnumerable <BuildingBlock> FindNewPath(Person person)
        {
            //Gets the personblocking's pathlist
            BuildingBlock target = person.PathList[person.StepsTaken + 1];
            BuildingBlock pos    = person.PathList[person.StepsTaken];

            if (AllPeople.Values.Count(p => p.PathList.Count > p.StepsTaken + 1 && p.PathList[p.StepsTaken] == target && p.PathList[p.StepsTaken + 1] == pos) == 1)
            {
                Person personBlocking = AllPeople.Values.First(p => p.PathList[p.StepsTaken] == target);
                if (personBlocking.PathList.Count > 0 &&
                    (person.Position as BuildingBlock).BuildingBlockNeighbours.Any(n => n.Type != Tile.Types.Person))
                {
                    if (personBlocking.PathList.Count(b => b.Type != Tile.Types.Person) <
                        person.PathList.Count(b => b.Type != Tile.Types.Person))
                    {
                        person.PathList.Clear();
                        person.PathList.AddRange(personBlocking.PathList);
                        person.StepsTaken = personBlocking.StepsTaken + 1;
                    }
                }
            }
            return(null);
        }
コード例 #7
0
 private void CheckForStairConnection(BuildingBlock buildingBlock)
 {
     if (buildingBlock.Type == Tile.Types.Stair && FloorAmount > 1)
     {
         string coordinatesOfFloorAbove = Coordinate(buildingBlock.X, buildingBlock.Y, buildingBlock.Z + 1);
         string coordinatesOfFloorBelow = Coordinate(buildingBlock.X, buildingBlock.Y, buildingBlock.Z - 1);
         if (Tiles.ContainsKey(coordinatesOfFloorAbove))
         {
             BuildingBlock neighbourAbove = Tiles[coordinatesOfFloorAbove] as BuildingBlock;
             if (neighbourAbove?.Type == Tile.Types.Stair)
             {
                 buildingBlock.BuildingBlockNeighbours.Add(neighbourAbove);
             }
         }
         if (Tiles.ContainsKey(coordinatesOfFloorBelow))
         {
             BuildingBlock neighbourBelow = Tiles[coordinatesOfFloorBelow] as BuildingBlock;
             if (neighbourBelow?.Type == Tile.Types.Stair)
             {
                 buildingBlock.BuildingBlockNeighbours.Add(neighbourBelow);
             }
         }
     }
 }
コード例 #8
0
ファイル: AStar.cs プロジェクト: Bargsteen/p2
        private IEnumerable <Tile> GetPathUsingAStar(IEvacuateable person, BuildingBlock destination)
        {
            bool firstRun = true;
            SortedSet <BuildingBlock>          priorityQueue = new SortedSet <BuildingBlock>(Comparer <BuildingBlock> .Default);
            Dictionary <string, BuildingBlock> closedSet     = new Dictionary <string, BuildingBlock>();
            List <BuildingBlock> unvisitedVertices           = TheFloorPlan.Tiles.Values.Cast <BuildingBlock>().ToList();

            foreach (BuildingBlock point in unvisitedVertices)
            {
                point.LengthToDestination = point.DiagonalDistanceTo(destination);
                point.Parent = null;
                if (firstRun)
                {
                    firstRun = false;
                }
                else
                {
                    point.LengthFromSource = 100000;
                }
                point.IsChecked = false;
            }

            unvisitedVertices.Remove(person.Position as BuildingBlock);
            BuildingBlock currentPosition = person.Position as BuildingBlock;

            if (currentPosition == null)
            {
                return(null);
            }
            currentPosition.LengthFromSource = 0;
            unvisitedVertices.Insert(0, currentPosition);

            while (!Equals(currentPosition, destination))
            {
                foreach (BuildingBlock buildingBlock in currentPosition.BuildingBlockNeighbours)
                {
                    if (buildingBlock.IsChecked == false)
                    {
                        if (!closedSet.ContainsKey(Settings.Coordinate(buildingBlock.X, buildingBlock.Y, buildingBlock.Z)))
                        {
                            priorityQueue.Add(buildingBlock);
                        }
                    }
                }
                CheckNeighbors(currentPosition, priorityQueue);
                if (priorityQueue.Count == 0)
                {
                    if (closedSet.ContainsKey(Settings.Coordinate(currentPosition.X, currentPosition.Y, currentPosition.Z)) == false)
                    {
                        closedSet.Add(Settings.Coordinate(currentPosition.X, currentPosition.Y, currentPosition.Z), currentPosition);
                    }

                    foreach (BuildingBlock buildingBlock in unvisitedVertices)
                    {
                        buildingBlock.IsChecked = false;
                    }
                    continue;
                }
                currentPosition.IsChecked = true;
                currentPosition           = priorityQueue.First();
                priorityQueue.Clear();
            }

            List <BuildingBlock> path   = new List <BuildingBlock>();
            BuildingBlock        parent = destination;

            do
            {
                path.Add(parent);
                parent = parent.Parent;
            } while (parent != null);
            path.Reverse();
            return(path);
        }
コード例 #9
0
 public Person(BuildingBlock position) : this(0, 0, position)
 {
 }
コード例 #10
0
        private Color CalculateHeatMapColor(BuildingBlock block)
        {
            // Modified from: http://www.andrewnoske.com/wiki/Code_-_heatmaps_and_color_gradients

            double value =
                Math.Min(
                    (double)block.HeatmapCounter / ((double)_mainWindow.TheUserInterface.LocalPeopleDictionary.Count * 2),
                    1.0);
            int colorAmount = 4;

            double[,] color =
            {
                {
                    0,
                    0,
                    255
                }
                ,
                {
                    0,
                    255,
                    0
                }
                ,
                {
                    255,
                    255,
                    0
                }
                ,
                {
                    255,
                    0,
                    0
                }
            };
            // A static array of 4 colors:  (blue,   green,  yellow,  red) using {r,g,b} for each.

            int    idx1;             // |-- Our desired color will be between these two indexes in "color".
            int    idx2;             // |
            double fractBetween = 0; // Fraction between "idx1" and "idx2" where our value is.

            if (value <= 0)
            {
                idx1 = idx2 = 0;
            } // accounts for an input <=0
            else if (value >= 255)
            {
                idx1 = idx2 = colorAmount - 1;
            } // accounts for an input >=0
            else
            {
                value        = value * (colorAmount - 1);           // Will multiply value by 3.
                idx1         = (int)Math.Floor(value);              // Our desired color will be after this index.
                idx2         = Math.Min(idx1 + 1, colorAmount - 1); // ... and before this index (inclusive).
                fractBetween = value - idx1;                        // Distance between the two indexes (0-1).
            }


            int red   = (int)Math.Round((color[idx2, 0] - color[idx1, 0]) * fractBetween + color[idx1, 0]);
            int green = (int)Math.Round((color[idx2, 1] - color[idx1, 1]) * fractBetween + color[idx1, 1]);
            int blue  = (int)Math.Round((color[idx2, 2] - color[idx1, 2]) * fractBetween + color[idx1, 2]);

            return(new Color
            {
                A = 255,
                R = Convert.ToByte(red),
                G = Convert.ToByte(green),
                B = Convert.ToByte(blue)
            });
        }
コード例 #11
0
 public void LineToolReleased()
 {
     previousBlock = null;
 }