示例#1
0
        public override void OnBuild(WorldEdit worldEdit, int oldBlockId, BlockSelection blockSel, ItemStack withItemStack)
        {
            if (startPos == null)
            {
                return;
            }

            BlockPos destPos = blockSel.Position.AddCopy(blockSel.Face.Opposite);

            Block block = blockAccessRev.GetBlock(blockSel.Position);

            if (PlaceMode)
            {
                block = blockAccessRev.GetBlock(0);
            }
            worldEdit.sapi.World.BlockAccessor.SetBlock(oldBlockId, blockSel.Position);

            if (!worldEdit.MayPlace(block, startPos.ManhattenDistance(destPos)))
            {
                return;
            }

            GameMath.BresenHamPlotLine3d(startPos.X, startPos.Y, startPos.Z, destPos.X, destPos.Y, destPos.Z, (pos) => blockAccessRev.SetBlock(block.BlockId, pos, withItemStack));

            if (LineMode == EnumLineStartPoint.LineStrip)
            {
                startPos = destPos.Copy();
            }

            blockAccessRev.SetHistoryStateBlock(blockSel.Position.X, blockSel.Position.Y, blockSel.Position.Z, oldBlockId, blockAccessRev.GetBlockId(blockSel.Position));
            blockAccessRev.Commit();
        }
示例#2
0
        public override void OnBuild(WorldEdit worldEdit, int oldBlockId, BlockSelection blockSel, ItemStack withItemStack)
        {
            if (BrushRadius <= 0)
            {
                return;
            }

            Block blockToPlace = blockAccessRev.GetBlock(blockSel.Position);

            worldEdit.sapi.World.BlockAccessor.SetBlock(oldBlockId, blockSel.Position);

            int quantityBlocks = (int)((GameMath.PI * BrushRadius * BrushRadius) * (4 * KernelRadius * KernelRadius) * Iterations);

            quantityBlocks *= 4; // because erode is computationally extra expensive

            if (!worldEdit.MayPlace(blockToPlace, quantityBlocks))
            {
                return;
            }

            int q = Iterations;

            while (q-- > 0)
            {
                ApplyErode(worldEdit, blockAccessRev, blockSel.Position, blockToPlace, withItemStack);
            }

            blockAccessRev.SetHistoryStateBlock(blockSel.Position.X, blockSel.Position.Y, blockSel.Position.Z, oldBlockId, blockAccessRev.GetBlockId(blockSel.Position));
            blockAccessRev.Commit();
        }
示例#3
0
        public void OnApply(WorldEdit worldEdit, int oldBlockId, BlockSelection blockSel, ItemStack withItemStack, bool isbreak = false)
        {
            if (Quantity == 0 || Radius == 0)
            {
                return;
            }

            float radSq = Radius * Radius;
            float q     = Quantity;

            Block block = blockAccessRev.GetBlock(blockSel.Position);

            if (isbreak)
            {
                block = blockAccessRev.GetBlock(0);
            }

            int quantityBlocks = (int)(GameMath.PI * radSq);

            if (!worldEdit.MayPlace(block, (int)q))
            {
                return;
            }

            if (oldBlockId >= 0)
            {
                worldEdit.sapi.World.BlockAccessor.SetBlock(oldBlockId, blockSel.Position);
            }
            lcgRand.SetWorldSeed(rand.Next());
            lcgRand.InitPositionSeed(blockSel.Position.X / blockAccessRev.ChunkSize, blockSel.Position.Z / blockAccessRev.ChunkSize);

            int xRadInt = (int)Math.Ceiling(Radius);
            int yRadInt = (int)Math.Ceiling(Radius);
            int zRadInt = (int)Math.Ceiling(Radius);

            HashSet <BlockPos> viablePositions = new HashSet <BlockPos>();
            BlockPos           dpos, ddpos;
            Block            testblock;
            EnumAirBrushMode mode = Mode;

            for (int dx = -xRadInt; dx <= xRadInt; dx++)
            {
                for (int dy = -yRadInt; dy <= yRadInt; dy++)
                {
                    for (int dz = -zRadInt; dz <= zRadInt; dz++)
                    {
                        if (dx * dx + dy * dy + dz * dz > radSq)
                        {
                            continue;
                        }

                        dpos      = blockSel.Position.AddCopy(dx, dy, dz);
                        testblock = blockAccessRev.GetBlock(dpos);
                        if (testblock.Replaceable >= 6000)
                        {
                            continue;
                        }

                        for (int i = 0; i < BlockFacing.NumberOfFaces; i++)
                        {
                            if (Apply == EnumAirBrushApply.SelectedFace && BlockFacing.ALLFACES[i] != blockSel.Face)
                            {
                                continue;
                            }

                            ddpos = dpos.AddCopy(BlockFacing.ALLFACES[i]);
                            Block dblock = blockAccessRev.GetBlock(ddpos);
                            if (dblock.Replaceable >= 6000 && (dblock.IsLiquid() == block.IsLiquid()))
                            {
                                // We found an air block beside a solid block -> let's remember that air block and keep looking
                                if (mode == EnumAirBrushMode.Add)
                                {
                                    viablePositions.Add(ddpos);
                                }
                                else
                                // We found an air block beside a solid block -> let's remember that solid block for removal and we can stop here
                                {
                                    viablePositions.Add(dpos);
                                }
                            }
                        }
                    }
                }
            }

            List <BlockPos> viablePositionsList = new List <BlockPos>(viablePositions);

            while (q-- > 0)
            {
                if (viablePositionsList.Count == 0)
                {
                    break;
                }

                if (q < 1 && rand.NextDouble() > q)
                {
                    break;
                }

                int index = rand.Next(viablePositionsList.Count);
                dpos = viablePositionsList[index];
                viablePositionsList.RemoveAt(index);

                if (mode == EnumAirBrushMode.Add)
                {
                    block.TryPlaceBlockForWorldGen(blockAccessRev, dpos, BlockFacing.UP, lcgRand);
                }
                else
                {
                    blockAccessRev.SetBlock(block.BlockId, dpos, withItemStack);
                }
            }

            if (oldBlockId >= 0)
            {
                blockAccessRev.SetHistoryStateBlock(blockSel.Position.X, blockSel.Position.Y, blockSel.Position.Z, oldBlockId, blockAccessRev.GetBlockId(blockSel.Position));
            }

            blockAccessRev.Commit();


            return;
        }
示例#4
0
        void OnUse(WorldEdit worldEdit, BlockPos pos, int oldBlockId, int sign, ItemStack withItemStack)
        {
            if (Radius <= 0)
            {
                return;
            }

            int   radInt = (int)Math.Ceiling(Radius);
            float radSq  = Radius * Radius;

            Block block = blockAccessRev.GetBlock(pos);

            if (sign > 0)
            {
                worldEdit.sapi.World.BlockAccessor.SetBlock(oldBlockId, pos);
            }

            float maxhgt            = Depth;
            EnumHeightToolMode dist = Mode;

            int quantityBlocks = (int)(GameMath.PI * radSq) * (int)maxhgt;

            if (!worldEdit.MayPlace(block, quantityBlocks))
            {
                return;
            }

            for (int dx = -radInt; dx <= radInt; dx++)
            {
                for (int dz = -radInt; dz <= radInt; dz++)
                {
                    float distanceSq = dx * dx + dz * dz;
                    if (distanceSq > radSq)
                    {
                        continue;
                    }

                    BlockPos dpos = pos.AddCopy(dx, 0, dz);

                    float height = sign * maxhgt;
                    switch (dist)
                    {
                    case EnumHeightToolMode.Pyramid:
                        height *= 1 - distanceSq / radSq;
                        break;

                    case EnumHeightToolMode.Gaussian:
                        float sigmaSq = 0.1f;
                        float sigma   = GameMath.Sqrt(sigmaSq);
                        float a       = 1f / (sigma * GameMath.Sqrt(GameMath.TWOPI));
                        float x       = distanceSq / radSq;

                        double gaussValue = a * Math.Exp(-(x * x) / (2 * sigmaSq));

                        height *= (float)gaussValue;
                        break;

                    case EnumHeightToolMode.Perlin:

                        height *= (float)noiseGen.Noise(dpos.X, dpos.Y, dpos.Z);

                        break;
                    }

                    while (dpos.Y > 0 && blockAccessRev.GetBlock(dpos).Replaceable >= 6000)
                    {
                        dpos.Down();
                    }


                    if (height < 0)
                    {
                        Erode(-height, dpos);
                    }
                    else
                    {
                        dpos.Up();
                        Grow(worldEdit.sapi.World, height, dpos, block, BlockFacing.UP, withItemStack);
                    }
                }
            }

            blockAccessRev.SetHistoryStateBlock(pos.X, pos.Y, pos.Z, oldBlockId, blockAccessRev.GetBlockId(pos));
            blockAccessRev.Commit();
        }
        public bool PerformBrushAction(WorldEdit worldEdit, Block placedBlock, int oldBlockId, BlockSelection blockSel, BlockPos targetPos, ItemStack withItemStack)
        {
            if (BrushDim1 <= 0)
            {
                return(false);
            }

            Block selectedBlock = blockSel.DidOffset ? blockAccessRev.GetBlock(blockSel.Position.AddCopy(blockSel.Face.Opposite)) : blockAccessRev.GetBlock(blockSel.Position);

            int selectedBlockId = selectedBlock.BlockId;

            if (oldBlockId >= 0)
            {
                worldEdit.sapi.World.BlockAccessor.SetBlock(oldBlockId, blockSel.Position);
            }



            EnumBrushMode brushMode = BrushMode;

            int blockId = placedBlock.BlockId;

            if (!worldEdit.MayPlace(blockAccessRev.GetBlock(blockId), brushPositions.Length))
            {
                return(false);
            }

            EnumDepthLimit depthLimit = DepthLimit;

            for (int i = 0; i < brushPositions.Length; i++)
            {
                BlockPos dpos = targetPos.AddCopy(brushPositions[i].X, brushPositions[i].Y, brushPositions[i].Z);

                bool skip = false;
                switch (depthLimit)
                {
                case EnumDepthLimit.Top1:
                    skip = blockAccessRev.GetBlockId(dpos) == 0 || blockAccessRev.GetBlockId(dpos.X, dpos.Y + 1, dpos.Z) != 0;
                    break;

                case EnumDepthLimit.Top2:
                    skip = blockAccessRev.GetBlockId(dpos) == 0 || (blockAccessRev.GetBlockId(dpos.X, dpos.Y + 1, dpos.Z) != 0 && blockAccessRev.GetBlockId(dpos.X, dpos.Y + 2, dpos.Z) != 0);
                    break;

                case EnumDepthLimit.Top3:
                    skip = blockAccessRev.GetBlockId(dpos) == 0 || (blockAccessRev.GetBlockId(dpos.X, dpos.Y + 1, dpos.Z) != 0 && blockAccessRev.GetBlockId(dpos.X, dpos.Y + 2, dpos.Z) != 0 && blockAccessRev.GetBlockId(dpos.X, dpos.Y + 3, dpos.Z) != 0);
                    break;

                case EnumDepthLimit.Top4:
                    skip = blockAccessRev.GetBlockId(dpos) == 0 || (blockAccessRev.GetBlockId(dpos.X, dpos.Y + 1, dpos.Z) != 0 && blockAccessRev.GetBlockId(dpos.X, dpos.Y + 2, dpos.Z) != 0 && blockAccessRev.GetBlockId(dpos.X, dpos.Y + 3, dpos.Z) != 0 && blockAccessRev.GetBlockId(dpos.X, dpos.Y + 4, dpos.Z) != 0);
                    break;
                }
                if (skip)
                {
                    continue;
                }


                switch (brushMode)
                {
                case EnumBrushMode.ReplaceAir:
                    if (blockAccessRev.GetBlockId(dpos) == 0)
                    {
                        blockAccessRev.SetBlock(blockId, dpos, withItemStack);
                    }
                    break;

                case EnumBrushMode.ReplaceNonAir:
                    if (blockAccessRev.GetBlockId(dpos) != 0)
                    {
                        blockAccessRev.SetBlock(blockId, dpos, withItemStack);
                    }
                    break;

                case EnumBrushMode.ReplaceSelected:
                    if (blockAccessRev.GetBlockId(dpos) == selectedBlockId)
                    {
                        blockAccessRev.SetBlock(blockId, dpos, withItemStack);
                    }

                    break;

                default:
                    blockAccessRev.SetBlock(blockId, dpos, withItemStack);
                    break;
                }
            }

            return(true);
        }