internal Person(int id, double movementSpeed, BuildingBlock position)
        {
            if (id <= 0)
            { /* Negative or zero-valued id means this is a totally new person */
                int newID;
                do
                {
                    newID = _idCounter++;
                } while (IdsInUse.Contains(newID));
                ID = newID;
            }
            else
            {
                /* non-zeroed, positive value means this is an existing person */
                if (IdsInUse.Contains(id))
                    throw new PersonException($"A user with ID {id} already exists!");
                ID = id;
            }

            PersonInteractionStats = new DataSimulationStatistics();
            // 3 - 8 kmt
            MovementSpeed = movementSpeed < 3 ? 3 + Rand.NextDouble() * 5 : movementSpeed; // Less than 5 means that it was not created.
            MovementSpeed = 3 + Rand.NextDouble() * 5;
            MovementSpeedInMetersPerSecond = (MovementSpeed * 1000) / 60 / 60;
            Position = position;
            //If their position is int16.maxvalue, if the priority is not assigned == That there is no path,
            //They will not be touched in the simulation, but will be added to the counter in CP_SimulationStats
            if (position.Priority == Int16.MaxValue)
            {
                NoPathAvailable = true;
            }
            OriginalPosition = position;
        }

 public void DiagonalDistanceToIfXDistanceIsSmalerThenYDistanceTest()
 {
     BuildingBlock pointOne = new BuildingBlock(0, 0);
     BuildingBlock pointTwo = new BuildingBlock(2, 1);
     var distance = pointOne.DiagonalDistanceTo(pointTwo);
     Assert.AreEqual(1 + Math.Sqrt(2), distance);
 }

 public Area(string name, List<IAreaConnector> inputs)
     : base(new List<BuildingBlock>())
 {
     _name = name;
     _boundBuildingBlock = null;
     _inputs = inputs;
 }

 public void DiagonalDistanceHalfOfIntMax()
 {
     BuildingBlock pointOne = new BuildingBlock(Int32.MaxValue / 2, Int32.MaxValue / 2);
     BuildingBlock pointTwo = new BuildingBlock(0, 0);
     var distance = pointOne.DiagonalDistanceTo(pointTwo);
     Assert.AreEqual((Int32.MaxValue / 2) * Math.Sqrt(2), distance);
 }

 public BuildingPartDestroyedEvent(BuildingBlock buildingBlock, HitInfo info)
 {
     BuildingPart = new BuildingPart(buildingBlock);
     Info = info;
     string bonename = StringPool.Get(info.HitBone);
     HitBone = bonename == "" ? "unknown" : bonename;
 }

 public void DiagonalDistanceToIfYDistanceIsSmalerThenXDistanceTest()
 {
     BuildingBlock pointOne = new BuildingBlock(1, 2);
     BuildingBlock pointTwo = new BuildingBlock(1, 1);
     var distance = pointOne.DiagonalDistanceTo(pointTwo);
     Assert.AreEqual(1, distance);
 }

 public void DiagonalDistanceToIfYDistanceIsEqualToXDistanceTest()
 {
     BuildingBlock pointOne = new BuildingBlock(10, 10);
     BuildingBlock pointTwo = new BuildingBlock(0, 0);
     var distance = pointOne.DiagonalDistanceTo(pointTwo);
     Assert.AreEqual(10 * Math.Sqrt(2), distance);
 }

        public PuzzleOutput areaGeneratePuzzle(BuildingBlock buildingBlockToBind)
        {
            if (_verbose) Debug.Log("spawning Area: " + _name);
            if (_boundBuildingBlock != null) {
                if (_verbose) Debug.Log("Area already bound to another building block!");
                return new PuzzleOutput();
            }
            else {
                BuildingBlock.shuffle(_inputs);
                foreach (IAreaConnector input in _inputs) {

                    PuzzleOutput possibleInput = input.areaGeneratePuzzle(this);
                    if (possibleInput == null)
                        continue;
                    _input = input;
                    _boundBuildingBlock = buildingBlockToBind;
                    PuzzleOutput 	result = new PuzzleOutput();
                    result.Items.AddRange(possibleInput.Items);
                    result.Relationships.AddRange(possibleInput.Relationships);

                    // Add an area connection relationship here
                    AreaConnectionRelationship connectionRelationship = input.makeConnection(this);
                    result.Relationships.Add(connectionRelationship);

                    return result;
                }
                return null;

            }
        }

 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);
 }

 public void DiagonalDistanceHalfOfIntMin()
 {
     int min = (Int32.MinValue + 1) / 2;
     BuildingBlock pointOne = new BuildingBlock(min, min);
     BuildingBlock pointTwo = new BuildingBlock(0, 0);
     var distance = pointOne.DiagonalDistanceTo(pointTwo);
     Assert.AreEqual((Math.Abs(min) * Math.Sqrt(2)), distance);
 }

        public BuildingPartGradeChangeEvent(BuildingBlock bb, BuildingGrade.Enum bgrade, BasePlayer player)
        {
            BuildingPart = new BuildingPart(bb);
            Builder = Server.GetPlayer(player);
            grade = bgrade;

            HasPrivilege = (bool)bb.CallMethod("CanChangeToGrade", bgrade, player);
        }

 public BuildingEvent(Construction construction, Construction.Target target, BuildingBlock bb, bool bNeedsValidPlacement)
 {
     Builder = Server.GetPlayer(target.player);
     BuildingPart = new BuildingPart(bb);
     Construction = construction;
     Target = target;
     NeedsValidPlacement = bNeedsValidPlacement;
 }

        public PropertyChangePuzzle(BuildingBlock changerInput, BuildingBlock changeeInput, 
									string desiredPropertyName, object desiredPropertyVal)
            : base(new List<BuildingBlock>() { changerInput, changeeInput })
        {
            _changerInput = changerInput;
            _changeeInput = changeeInput;
            _desiredPropertyName = desiredPropertyName;
            _desiredPropertyVal = desiredPropertyVal;
        }

 public void areaDespawnItems(BuildingBlock possibleBind)
 {
     if (_verbose) Debug.Log(string.Format("Attempting to despawn items for area {0}", _name));
     if (possibleBind == _boundBuildingBlock) {
         if (_verbose) Debug.Log(string.Format("Successfully despawning items for area {0}", _name));
         _input.areaDespawnItems(this);
         _boundBuildingBlock = null;
     }
 }

 private void addBlockToList(BuildingBlock buildingBlock, DateTime dateTime)
 {
     KeyValuePair<BuildingBlock, DateTime> newKVP = new KeyValuePair<BuildingBlock, DateTime>(buildingBlock, dateTime);
     if (!this.upgradedBuildingBlocks.Exists(x => x.Key.Equals(newKVP.Key)))
     {
         this.upgradedBuildingBlocks.Add(newKVP);
         updateConfig();
     }
 }

 void OnEntityEnter(TriggerBase triggerbase, BaseEntity entity)
 {
     if (!hasStarted) return;
     cachedBlock = triggerbase.GetComponentInParent<BuildingBlock>();
     if (cachedBlock == null) return;
     if (cachedBlock.blockDefinition.fullName != "build/block.halfheight") return;
     cachedPlayer = entity.GetComponent<BasePlayer>();
     if (cachedPlayer == null) return;
     cachedBlock.Kill(BaseNetworkable.DestroyMode.Gib);
     cachedPlayer.SendConsoleCommand("chat.add", new object[] { "0", string.Format("<color=orange>{0}:</color> {1}", "Warning", "You are not allowed to build blocks over you"), 1.0 });
 }

 void OnEntityBuilt(Planner planner, GameObject gameObject)
 {
     cachedBlock = gameObject.GetComponent<BuildingBlock>();
     if (cachedBlock == null) return;
     if (cachedBlock.blockDefinition == null) return;
     if (cachedBlock.blockDefinition.fullName != "build/block.halfheight") return;
     cachedBlock.GetComponentInChildren<MeshCollider>().gameObject.AddComponent<TriggerBase>();
     cachedBlock.GetComponentInChildren<TriggerBase>().gameObject.layer = triggerLayer;
     cachedBlock.GetComponentInChildren<TriggerBase>().interestLayers = playerMask;
     timer.Once(0.1f, () => ResetBlock(cachedBlock) );
 }

 public void PersonStart()
 {
     BuildingBlock block = new BuildingBlock(0,0);
     Person person = new Person(block);
     Assert.AreEqual(1,person.ID);
     Assert.AreEqual(false,person.Evacuated);
     Assert.AreEqual(new List<BuildingBlock>(), person.PathList);
     Tile tile = person.Position;
     Assert.AreEqual(0, tile.X);
     Assert.AreEqual(0, tile.Y);
 }

 public void BuildingBlockStart()
 {
     BuildingBlock buildingBlock = new BuildingBlock(0, 0);
     Assert.AreEqual(0, buildingBlock.X);
     Assert.AreEqual(0, buildingBlock.Y);
     Assert.AreEqual(0, buildingBlock.HeatmapCounter);
     Assert.AreEqual(false, buildingBlock.IsChecked);
     Assert.AreEqual(double.MaxValue, buildingBlock.LengthFromSource);
     Assert.AreEqual(0, buildingBlock.LengthToDestination);
     Assert.AreEqual(null, buildingBlock.Parent);
     Assert.AreEqual(new HashSet<Tile>(), buildingBlock.Neighbours);
     Assert.AreEqual(Tile.Types.Free, buildingBlock.Type);
 }

        int NextBlockGrade(BuildingBlock building_block, int offset = 1)
        {
            var current_grade = (int)building_block.grade;

            var grades = building_block.blockDefinition.grades;
            if (grades == null) return current_grade;

            var target_grade = current_grade + offset;
            while (target_grade >= 0 && target_grade < grades.Length)
            {
                if (grades[target_grade] != null) return target_grade;
                target_grade += offset;
            }

            return current_grade;
        }