IBrushInstance IBrush.MakeInstance( Player player, CommandReader cmd, DrawOperation op ) {
     if( ReadParams( cmd ) ) {
         return this;
     } else {
         return null;
     }
 }

 public override Block NextBlock(DrawOperation op) {
     if (op == null) throw new ArgumentNullException("op");
     Block block = op.Map.GetBlock(op.Coords);
     for (int i = 0; i < Blocks.Length; i++) {
         if (block == Blocks[i]) {
             return Block.None;
         }
     }
     return Replacement;
 }

 public bool Begin(Player player, DrawOperation state) {
     if (player == null) throw new ArgumentNullException("player");
     if (state == null) throw new ArgumentNullException("state");
     if (Blocks == null || Blocks.Length == 0) {
         if (player.LastUsedBlockType == Block.None) {
             player.Message("Cannot deduce desired block. Click a block or type out the block name.");
             return false;
         } else {
             Blocks = new[] {
                 player.GetBind(player.LastUsedBlockType)
             };
         }
     }
     return true;
 }

        public IBrushInstance MakeInstance( Player player, CommandReader cmd, DrawOperation state ) {
            if( player == null ) throw new ArgumentNullException( "player" );
            if( cmd == null ) throw new ArgumentNullException( "cmd" );
            if( state == null ) throw new ArgumentNullException( "state" );
            List<Block> blocks = new List<Block>();

            while( cmd.HasNext ) {
                Block block;
                if( !cmd.NextBlock( player, true, out block ) ) {
                    return null;
                }
                blocks.Add( block );
            }

            return new NormalBrush( blocks.ToArray() );
        }

        public virtual bool Begin( Player player, DrawOperation op ) {
            if( player == null ) throw new ArgumentNullException( "player" );
            if( op == null ) throw new ArgumentNullException( "op" );

            if( op.Bounds.Volume > 32 * 32 * 32 ) {
                player.Message( "{0} brush: Preparing, please wait...", Brush.Factory.Name );
            }

            noise3D = new PerlinNoise3D( new Random( Seed ) ) {
                Amplitude = 1,
                Frequency = Frequency,
                Octaves = Octaves,
                Persistence = Persistence
            };

            // generate and normalize the raw (float) data
            float[, ,] rawData = new float[op.Bounds.Width, op.Bounds.Length, op.Bounds.Height];
            for( int x = 0; x < op.Bounds.Width; x++ ) {
                for( int y = 0; y < op.Bounds.Length; y++ ) {
                    for( int z = 0; z < op.Bounds.Height; z++ ) {
                        rawData[x, y, z] = noise3D.Compute( x, y, z );
                    }
                }
            }
            Noise.Normalize( rawData, out normMultiplier, out normConstant );
            if( MapAllValues( rawData ) ) {
                Noise.Normalize( rawData, out normMultiplier, out normConstant );
            }

            // create a mapping of raw data to blocks
            int totalBlocks = BlockRatios.Sum();
            int blocksSoFar = BlockRatios[0];
            computedThresholds = new float[Blocks.Length];
            computedThresholds[0] = 0;
            for( int i = 1; i < Blocks.Length; i++ ) {
                float desiredCoverage = blocksSoFar / (float)totalBlocks;
                computedThresholds[i] = Noise.FindThreshold( rawData, desiredCoverage );
                blocksSoFar += BlockRatios[i];
            }
            return true;
        }

        public IBrushInstance MakeInstance( Player player, CommandReader cmd, DrawOperation op ) {
            if( player == null ) throw new ArgumentNullException( "player" );
            if( cmd == null ) throw new ArgumentNullException( "cmd" );
            if( op == null ) throw new ArgumentNullException( "op" );

            if( cmd.HasNext ) {
                Block block, altBlock;
                if( !cmd.NextBlock( player, true, out block ) ) return null;
                if( cmd.HasNext ) {
                    if( !cmd.NextBlock( player, true, out altBlock ) ) return null;
                } else {
                    altBlock = Block.None;
                }
                Block1 = block;
                Block2 = altBlock;

            } else if( Block1 == Block.None ) {
                player.Message( "{0}: Please specify one or two blocks.", Factory.Name );
                return null;
            }

            return new CheckeredBrush( this );
        }

 protected static void RaiseEndedEvent( DrawOperation op ) {
     var h = Ended;
     if( h != null ) h( null, new DrawOperationEventArgs( op ) );
 }

 protected static void RaiseBeganEvent( DrawOperation op ) {
     var h = Began;
     if( h != null ) h( null, new DrawOperationEventArgs( op ) );
 }

 // Returns false if cancelled
 protected static bool RaiseBeginningEvent( DrawOperation op ) {
     var h = Beginning;
     if( h == null ) return true;
     var e = new DrawOperationBeginningEventArgs( op );
     h( null, e );
     return !e.Cancel;
 }

        public IBrushInstance MakeInstance( Player player, CommandReader cmd, DrawOperation state ) {
            if( player == null ) throw new ArgumentNullException( "player" );
            if( cmd == null ) throw new ArgumentNullException( "cmd" );
            if( state == null ) throw new ArgumentNullException( "state" );

            List<Block> blocks = new List<Block>();
            List<int> blockRatios = new List<int>();
            while( cmd.HasNext ) {
                int ratio;
                Block block;
                if( !cmd.NextBlockWithParam( player, true, out block, out ratio ) ) return null;
                if( ratio < 1 || ratio > MaxRatio ) {
                    player.Message( "Cloudy brush: Invalid block ratio ({0}). Must be between 1 and {1}.",
                                    ratio, MaxRatio );
                    return null;
                }
                blocks.Add( block );
                blockRatios.Add( ratio );
            }

            if( blocks.Count == 0 ) {
                if( Blocks.Length == 0 ) {
                    player.Message( "{0} brush: Please specify at least one block.", Factory.Name );
                    return null;
                } else {
                    return new CloudyBrush( this );
                }
            } else if( blocks.Count == 1 ) {
                return new CloudyBrush( blocks[0], blockRatios[0] );
            } else {
                return new CloudyBrush( blocks.ToArray(), blockRatios.ToArray() );
            }
        }

 public bool Begin( Player player, DrawOperation op ) {
     if( player == null ) throw new ArgumentNullException( "player" );
     if( op == null ) throw new ArgumentNullException( "op" );
     op.Context |= BlockChangeContext.Replaced;
     return ReplacementInstance.Begin( player, op );
 }

 bool IBrushInstance.Begin( Player player, DrawOperation op )
 {
     return true;
 }

 public bool Begin(Player player, DrawOperation op) {
     if (player == null)
         throw new ArgumentNullException("player");
     if (op == null)
         throw new ArgumentNullException("op");
     if (Blocks == null || Blocks.Length == 0) {
         throw new InvalidOperationException("No blocks given.");
     }
     if (Replacement == Block.None) {
         if (player.LastUsedBlockType == Block.None) {
             player.Message("Cannot deduce desired replacement block. Click a block or type out the block name.");
             return false;
         } else {
             Replacement = player.GetBind(player.LastUsedBlockType);
         }
     }
     op.Context |= BlockChangeContext.Replaced;
     return true;
 }

 public bool Begin( Player player, DrawOperation op ) {
     if( player == null ) throw new ArgumentNullException( "player" );
     if( op == null ) throw new ArgumentNullException( "op" );
     if( Blocks == null || Blocks.Length == 0 ) {
         throw new InvalidOperationException( "No blocks given." );
     }
     return true;
 }

 public Block NextBlock(DrawOperation state) {
     if (state == null) throw new ArgumentNullException("state");
     if (state.AlternateBlockIndex < Blocks.Length) {
         return Blocks[state.AlternateBlockIndex];
     } else {
         return Block.None;
     }
 }

 //copy-paste from BuildingCommands
 private static void DrawOperationBegin(Player player, Command cmd, DrawOperation op)
 {
     IBrushInstance instance = player.Brush.MakeInstance(player, cmd, op);
     if (instance != null)
     {
         op.Brush = instance;
         player.SelectionStart(op.ExpectedMarks, new SelectionCallback(DrawOperationCallback), op, new Permission[] { Permission.DrawAdvanced });
         player.Message("{0}: Click {1} blocks or use &H/Mark&S to make a selection.", new object[] { op.Description, op.ExpectedMarks });
     }
 }

        public IBrushInstance MakeInstance( Player player, CommandReader cmd, DrawOperation op ) {
            if( player == null ) throw new ArgumentNullException( "player" );
            if( cmd == null ) throw new ArgumentNullException( "cmd" );
            if( op == null ) throw new ArgumentNullException( "op" );

            if( cmd.HasNext ) {
                Block block;
                if( !cmd.NextBlock( player, false, out block ) ) return null;

                string brushName = cmd.Next();
                if( brushName == null || !CommandManager.IsValidCommandName( brushName ) ) {
                    player.Message( "ReplaceBrush usage: &H/Brush rb <Block> <BrushName>" );
                    return null;
                }
                IBrushFactory brushFactory = BrushManager.GetBrushFactory( brushName );

                if( brushFactory == null ) {
                    player.Message( "Unrecognized brush \"{0}\"", brushName );
                    return null;
                }

                IBrush replacement = brushFactory.MakeBrush( player, cmd );
                if( replacement == null ) {
                    return null;
                }
                Block = block;
                Replacement = replacement;
            }

            ReplacementInstance = Replacement.MakeInstance( player, cmd, op );
            if( ReplacementInstance == null ) return null;

            return new ReplaceBrushBrush( this );
        }

 public Block NextBlock( DrawOperation op ) {
     if( op == null ) throw new ArgumentNullException( "op" );
     Block block = op.Map.GetBlock( op.Coords );
     if( block == Block ) {
         return ReplacementInstance.NextBlock( op );
     }
     return Block.None;
 }

 public DrawOperationEventArgs( DrawOperation drawOp ) {
     DrawOp = drawOp;
 }

 public bool Begin( Player player, DrawOperation state ) {
     if( player == null ) throw new ArgumentNullException( "player" );
     if( state == null ) throw new ArgumentNullException( "state" );
     return true;
 }