C# CommandReader.Next方法代码示例

        public IBrush MakeBrush( Player player, CommandReader cmd ) {
            if( player == null ) throw new ArgumentNullException( "player" );
            if( cmd == null ) throw new ArgumentNullException( "cmd" );

            if( !cmd.HasNext ) {
                player.Message( "ReplaceBrush usage: &H/Brush rb <Block> <BrushName>" );
                return null;
            }

            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 newBrush = brushFactory.MakeBrush( player, cmd );
            if( newBrush == null ) {
                return null;
            }

            return new ReplaceBrushBrush( block, newBrush );
        }

        public override bool ReadParams(CommandReader cmd) {
            // get image URL
            string urlString = cmd.Next();
            if (string.IsNullOrWhiteSpace(urlString)) {
                return false;
            }

            if (urlString.StartsWith("http://imgur.com/")) {
                urlString = "http://i.imgur.com/" + urlString.Substring("http://imgur.com/".Length) + ".png";
            }
            // if string starts with "++", load image from imgur
            if (urlString.StartsWith("++")) {
                urlString = "http://i.imgur.com/" + urlString.Substring(2) + ".png";
            }
            // prepend the protocol, if needed (assume http)
            if (!urlString.ToLower().StartsWith("http://") && !urlString.ToLower().StartsWith("https://")) {
                urlString = "http://" + urlString;
            }
            if (!urlString.ToLower().StartsWith("http://i.imgur.com")) {
                Player.Message("For safety reasons we only accept images uploaded to &9http://imgur.com/ &sSorry for this inconvenience.");
                return false;
            }
            if (!urlString.ToLower().EndsWith(".png") && !urlString.ToLower().EndsWith(".jpg") && !urlString.ToLower().EndsWith(".gif")) {
                Player.Message("URL must be a link to an image");
                return false;
            }

            // validate the image URL
            Uri url;
            if (!Uri.TryCreate(urlString, UriKind.Absolute, out url)) {
                Player.Message("DrawImage: Invalid URL given.");
                return false;
            } else if (!url.Scheme.Equals(Uri.UriSchemeHttp) && !url.Scheme.Equals(Uri.UriSchemeHttps)) {
                Player.Message("DrawImage: Invalid URL given. Only HTTP and HTTPS links are allowed.");
                return false;
            }
            ImageUrl = url;

            // Check if player gave optional second argument (palette name)
            string paletteName = cmd.Next();
            if (paletteName != null) {
                StandardBlockPalette paletteType;
                if (EnumUtil.TryParse(paletteName, out paletteType, true)) {
                    Palette = BlockPalette.GetPalette(paletteType);
                } else {
                    Player.Message("DrawImage: Unrecognized palette \"{0}\". Available palettes are: \"{1}\"",
                                   paletteName,
                                   Enum.GetNames(typeof(StandardBlockPalette)).JoinToString());
                    return false;
                }
            } else {
                // default to "Light" (lit single-layer) palette
                Palette = BlockPalette.Light;
            }

            // All set
            return true;
        }

        public override MapGeneratorParameters CreateParameters( Player player, CommandReader cmd ) {
            string themeName = cmd.Next();
            if( themeName == null ) {
                return CreateDefaultParameters();
            }

            MapGenTheme theme;
            RealisticMapGenTerrainType terrainType;

            string templateName = cmd.Next();
            if( templateName == null ) {
                player.Message( "SetGen: Realistic MapGen requires both a theme and a terrainType. " +
                                "See &H/Help SetGen Realistic&S or check wiki.fCraft.net for details" );
                return null;
            }

            // parse theme
            bool swapThemeAndTemplate;
            if( EnumUtil.TryParse( themeName, out theme, true ) ) {
                swapThemeAndTemplate = false;

            } else if( EnumUtil.TryParse( templateName, out theme, true ) ) {
                swapThemeAndTemplate = true;

            } else {
                player.Message( "SetGen: Unrecognized theme \"{0}\". Available themes are: {1}",
                                themeName,
                                Enum.GetNames( typeof( MapGenTheme ) ).JoinToString() );
                return null;
            }

            // parse terrainType
            if( swapThemeAndTemplate && !EnumUtil.TryParse( themeName, out terrainType, true ) ) {
                MessageTemplateList( themeName, player );
                return null;
            } else if( !EnumUtil.TryParse( templateName, out terrainType, true ) ) {
                MessageTemplateList( templateName, player );
                return null;
            }

            // TODO: optional parameters for preset customization
            return CreateParameters( terrainType, theme );
        }

 public void Execute( string text )
 {
     CommandReader reader = new CommandReader( text );
     if( reader.TotalArgs == 0 ) {
         game.Chat.Add( "&e/client: No command name specified. See /client commands for a list of commands." );
         return;
     }
     string commandName = reader.Next();
     Command cmd = GetMatchingCommand( commandName );
     if( cmd != null ) {
         cmd.Execute( reader );
     }
 }

 public override MapGeneratorParameters CreateParameters( Player player, CommandReader cmd ) {
     string themeName = cmd.Next();
     MapGeneratorParameters newParams;
     if( themeName != null ) {
         newParams = CreateParameters( themeName );
         if( newParams == null ) {
             player.Message( "SetGen: \"{0}\" is not a recognized flat theme name. Available themes are: {1}",
                             themeName, Presets.JoinToString() );
             return null;
         }
     } else {
         newParams = CreateDefaultParameters();
     }
     return newParams;
 }

 public void Execute( string text )
 {
     CommandReader reader = new CommandReader( text );
     if( reader.TotalArgs == 0 ) {
         game.Chat.Add( "&eList of client commands:" );
         PrintDefinedCommands( game );
         game.Chat.Add( "&eTo see a particular command's help, type /client help [cmd name]" );
         return;
     }
     string commandName = reader.Next();
     Command cmd = GetMatchingCommand( commandName );
     if( cmd != null ) {
         cmd.Execute( reader );
     }
 }

 public override void Execute( CommandReader reader )
 {
     string cmdName = reader.Next();
     if( cmdName == null ) {
         game.Chat.Add( "&e/client help: No command name specified. See /client commands for a list of commands." );
     } else {
         Command cmd = game.CommandManager.GetMatchingCommand( cmdName );
         if( cmd != null ) {
             string[] help = cmd.Help;
             for( int i = 0; i < help.Length; i++ ) {
                 game.Chat.Add( help[i] );
             }
         }
     }
 }

        public override void Execute( CommandReader reader )
        {
            game.UserEvents.BlockChanged -= BlockChanged;
            block = 0xFF;
            mark1 = new Vector3I( int.MaxValue );
            mark2 = new Vector3I( int.MaxValue );
            persist = false;

            if( !ParseBlock( reader ) ) return;
            string arg = reader.Next();
            if( arg != null && Utils.CaselessEquals( arg, "yes" ) )
                persist = true;

            game.Chat.Add( "&eCuboid: &fPlace or delete a block.", MessageType.ClientStatus3 );
            game.UserEvents.BlockChanged += BlockChanged;
        }

 static void BrushHandler( Player player, CommandReader cmd ) {
     string brushName = cmd.Next();
     if( brushName == null ) {
         player.Message( player.Brush.Description );
     } else {
         IBrushFactory brushFactory = GetBrushFactory( brushName );
         if( brushFactory == null ) {
             player.Message( "Unrecognized brush \"{0}\"", brushName );
         } else {
             IBrush newBrush = brushFactory.MakeBrush( player, cmd );
             if( newBrush != null ) {
                 player.Brush = newBrush;
                 player.Message( "Brush set to {0}", player.Brush.Description );
             }
         }
     }
 }

        public IBrush MakeBrush( Player player, CommandReader cmd ) {
            if( player == null ) throw new ArgumentNullException( "player" );
            if( cmd == null ) throw new ArgumentNullException( "cmd" );

            List<Block> blocks = new List<Block>();
            List<int> blockRatios = new List<int>();
            bool scaleSpecified = false,
                 turbulenceSpecified = false,
                 seedSpecified = false;
            int scale = 100,
                turbulence = 100;
            UInt16 seed = CloudyBrush.NextSeed();

            while( true ) {
                int offset = cmd.Offset;
                string rawNextParam = cmd.Next();
                if( rawNextParam == null ) break;

                if( rawNextParam.EndsWith( "%" ) ) {
                    string numPart = rawNextParam.Substring( 0, rawNextParam.Length - 1 );
                    int tempScale;
                    if( !Int32.TryParse( numPart, out tempScale ) ) {
                        player.Message( "Cloudy brush: To specify scale, write a number followed by a percentage (e.g. 100%)." );
                        return null;
                    }
                    if( scaleSpecified ) {
                        player.Message( "Cloudy brush: Scale has been specified twice." );
                        return null;
                    }
                    if( scale < 1 || tempScale > CloudyBrush.MaxScale ) {
                        player.Message( "Cloudy brush: Invalid scale ({0}). Must be between 1 and {1}",
                                        scale, CloudyBrush.MaxScale );
                        return null;
                    }
                    scale = tempScale;
                    scaleSpecified = true;
                    continue;

                } else if( rawNextParam.EndsWith( "T", StringComparison.OrdinalIgnoreCase ) ) {
                    string numPart = rawNextParam.Substring( 0, rawNextParam.Length - 1 );
                    int tempTurbulence;
                    if( Int32.TryParse( numPart, out tempTurbulence ) ) {
                        if( turbulenceSpecified ) {
                            player.Message( "Cloudy brush: Turbulence has been specified twice." );
                            return null;
                        }
                        if( turbulence < 1 || tempTurbulence > CloudyBrush.MaxScale ) {
                            player.Message( "Cloudy brush: Invalid turbulence ({0}). Must be between 1 and {1}",
                                            turbulence, CloudyBrush.MaxScale );
                            return null;
                        }
                        turbulence = tempTurbulence;
                        turbulenceSpecified = true;
                        continue;
                    }

                } else if( rawNextParam.EndsWith( "S", StringComparison.OrdinalIgnoreCase ) ) {
                    string numPart = rawNextParam.Substring( 0, rawNextParam.Length - 1 );
                    try {
                        seed = UInt16.Parse( numPart, System.Globalization.NumberStyles.HexNumber );
                        if( seedSpecified ) {
                            player.Message( "Cloudy brush: Seed has been specified twice." );
                            return null;
                        }
                        seedSpecified = true;
                        continue;
                    } catch {
                        seed = CloudyBrush.NextSeed();
                    }
                }

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

            CloudyBrush madeBrush;
            if( blocks.Count == 0 ) {
                madeBrush = new CloudyBrush();
            } else if( blocks.Count == 1 ) {
                madeBrush = new CloudyBrush( blocks[0], blockRatios[0] );
            } else {
                madeBrush = new CloudyBrush( blocks.ToArray(), blockRatios.ToArray() );
            }

            madeBrush.Frequency /= ( scale / 100f );
            madeBrush.Persistence *= ( turbulence / 100f );
            madeBrush.Seed = seed;

            return madeBrush;
        }

 public override void Execute( CommandReader reader )
 {
     string cmdName = reader.Next();
     if( cmdName == null ) {
         game.Chat.Add( "&eList of client commands:" );
         game.CommandManager.PrintDefinedCommands( game );
         game.Chat.Add( "&eTo see a particular command's help, type /client help [cmd name]" );
     } else {
         Command cmd = game.CommandManager.GetMatchingCommand( cmdName );
         if( cmd != null ) {
             string[] help = cmd.Help;
             for( int i = 0; i < help.Length; i++ ) {
                 game.Chat.Add( help[i] );
             }
         }
     }
 }

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

        bool ParseBlock( CommandReader reader )
        {
            string id = reader.Next();
            if( id == null ) return true;
            if( Utils.CaselessEquals( id, "yes" ) ) { persist = true; return true; }

            byte blockID = 0;
            if( !byte.TryParse( id, out blockID ) ) {
                game.Chat.Add( "&eCuboid: &c\"" + id + "\" is not a valid block id." ); return false;
            }
            if( blockID >= BlockInfo.CpeCount && game.BlockInfo.Name[blockID] == "Invalid" ) {
                game.Chat.Add( "&eCuboid: &cThere is no block with id \"" + id + "\"." ); return false;
            }
            block = blockID;
            return true;
        }