Example #1
0
        private void CreateDoor(MapBlock _mapBlock, ETerrains _floor, IEnumerable <Point> _borderPoints)
        {
            var doorCoords = Room.RoomRectangle.Center;
            var prevPoint  = doorCoords;
            var direction  = World.Rnd.GetRandomDirection();
            var delta      = direction.GetDelta();

            while (!_borderPoints.Contains(doorCoords))
            {
                prevPoint   = doorCoords;
                doorCoords += delta;
            }
            var nextPoint = doorCoords + delta;

            var borders = direction.GetBorders().ToArray();

            DoorWorldCoords = _mapBlock.ToWorldCoords(doorCoords);

            OutDoorWorldCoords = new[] { nextPoint + borders[0].Key, nextPoint, nextPoint + borders[1].Key }.Select(_mapBlock.ToWorldCoords).ToArray();
            InDoorWorldCoords  = new[] { prevPoint + borders[0].Key, prevPoint, prevPoint + borders[1].Key }.Select(_mapBlock.ToWorldCoords).ToArray();

            _mapBlock.Map[doorCoords.X, doorCoords.Y] = _floor;
            var doors = EssenceHelper.GetAllThings <ClosedDoor>().ToArray();

            _mapBlock.AddEssence(doors[0], doorCoords);
        }
        public override void Fill(MapBlock _block, WorldLayer _layer)
        {
            var rnd = new Random(_block.RandomSeed);

            InDoorWorldCoords  = Room.RoomRectangle.Inflate(-1, -1).BorderPoints.ToArray();
            OutDoorWorldCoords = Room.RoomRectangle.BorderPoints.ToArray();

            MapBlockHelper.Fill(_block, rnd, _layer, _layer.DefaultEmptySpaces, Room.AreaRectangle);

            var graves = EssenceHelper.GetAllThings <Grave>().ToArray();

            foreach (var point in Room.RoomRectangle.AllPoints)
            {
                if (rnd.Next(4) == 0 && !InDoorWorldCoords.Contains(point))
                {
                    _block.AddEssence(graves.RandomItem(rnd), point);
                }
            }
        }
Example #3
0
        protected override MapBlock GenerateBlock(Point _blockId)
        {
            var block = SurfaceBlockGenerator.GenerateBlock(_blockId, this);

            var rnd = new Random(block.RandomSeed);

            var baseType = GetBlockType(_blockId);

            if (baseType == EMapBlockTypes.CITY)
            {
                City.GenerateCityBlock(block, rnd, this);
            }

            var trees  = EssenceHelper.GetAllThings <Tree>().ToArray();
            var shrubs = EssenceHelper.GetAllThings <Shrub>().ToArray();

            foreach (var point in new Rct(0, 0, Constants.MAP_BLOCK_SIZE, Constants.MAP_BLOCK_SIZE).AllPoints)
            {
                switch (block.Map[point.X, point.Y])
                {
                case ETerrains.FOREST:
                    switch (rnd.Next(10))
                    {
                    case 0:
                    case 1:
                        block.AddEssence(shrubs.RandomItem(rnd), point);
                        break;

                    case 2:
                    case 3:
                    case 4:
                        block.AddEssence(trees.RandomItem(rnd), point);
                        break;
                    }
                    break;

                case ETerrains.SHRUBS:
                    switch (rnd.Next(7))
                    {
                    case 0:
                    case 1:
                    case 2:
                    case 3:
                        block.AddEssence(shrubs.RandomItem(rnd), point);
                        break;

                    case 4:
                        block.AddEssence(trees.RandomItem(rnd), point);
                        break;
                    }
                    break;
                }
            }
            if (Constants.WORLD_MAP_SIZE == 1)
            {
                TestSurfaceGenerator1x1.Fill(block, Constants.WORLD_SEED, baseType);
            }
            else
            {
                GenerateRandomItems(rnd, block);
            }
            return(block);
        }