User:Maven/entitybot

Here is code for a small app to convert FGD entries into markup for an entity entry in this wiki.

Notes

This code is in the public domain.

It uses C# 2.0, and comes without support. Please excuse its ugly kuldgeness. The correct way would have been to use Flex/Bison.

To use this, pass an entity entry from the FGD as a parameter to Conversion.ConvertFGD2Wiki and returned string into the appropriate VDC edit page. You will need to fill in some of the Availability section and make sure that there are no missing templates.

This code does not include a UI.

(Feel free to change anything in this article, including the code.)

using System;
using System.Collections.Generic;
using System.Text;

namespace FGD2Wiki
{
    public class Conversion
    {

        private enum EntityType
        {
            Error = 0,
            PointBased,
            BrushBased,
        };

        private class EntityInput
        {
            public string name;
            public string type;
            public string desc;

            public string ToWiki()
            {
                StringBuilder sb = new StringBuilder();
                sb.Append( "*'''" );
                sb.Append( this.name );
                if ( this.type != "void" )
                {
                    sb.Append( " <" );
                    sb.Append( this.type );
                    sb.Append( ">" );
                }
                sb.AppendLine( "'''" );
                sb.Append( ":" );
                sb.AppendLine( this.desc );
                return sb.ToString();
            }
        };

        private class EntityOutput
        {
            public string name;
            public string type;
            public string desc;

            public string ToWiki()
            {
                StringBuilder sb = new StringBuilder();
                sb.Append( "*'''" );
                sb.Append( this.name );
                if ( this.type != "void" )
                {
                    sb.Append( " <" );
                    sb.Append( this.type );
                    sb.Append( ">" );
                }
                sb.AppendLine( "'''" );
                sb.Append( ":" );
                sb.AppendLine( this.desc );
                return sb.ToString();
            }
        };

        private struct Pair<A, B>
        {
            public Pair( A a, B b ) { this.a = a; this.b = b; }
            public A a;
            public B b;
        }

        private class EntityKeyvalue
        {
            public string name;
            public string type;
            public string name2;    // the SmartEdit name
            public string desc;
            public string def;
            public List<Pair<int, string>> choices = new List<Pair<int, string>>();

            public string ToWiki()
            {
                StringBuilder sb = new StringBuilder();

                // Add the name
                sb.Append( "*'''" );
                sb.Append( this.name );
                sb.AppendLine( "'''" );

                // Add the type
                sb.Append( ":<" );
                switch ( this.type )
                {
                    case "angle":
                    case "angles":
                    case "vecline":
                    case "byte":
                    case "color255":
                        sb.Append( "[[" );
                        sb.Append( this.type );
                        sb.Append( "]]" );
                        break;
                    case "boolean":
                    case "bool":
                        sb.Append( "[[Wikipedia:boolean|boolean]]" );
                        break;
                    default:
                        sb.Append( this.type );
                        break;
                }
                sb.Append( "> " );

                // Add the SmartEdit name to the desc if the desc is shortish
                if ( this.desc.Length < 12 )
                {
                    sb.Append( this.name2 );
                    sb.Append( ". " );
                }

                // Add the description
                sb.Append( this.desc );
                // Add a period if there isn't one aleady
                if ( this.desc.Length > 0 && !this.desc.EndsWith( "." ) )
                    sb.Append( "." );

                /*
                // Give the default value
                if ( this.def != "" )
                {
                    sb.Append( " Default: " );
                    sb.Append( this.def );
                }
                */
                sb.AppendLine();

                // If this is a 'choices' variable, create the choice table
                if ( this.type == "choices" )
                {
                    sb.AppendLine( ":{|" );
                    sb.AppendLine( "! Literal value || Description" );
                    foreach ( Pair<int, string> pair in choices )
                    {
                        sb.AppendLine( "|-" );
                        sb.Append( "| " );
                        sb.Append( pair.a );
                        sb.Append( " || " );
                        sb.AppendLine( pair.b );
                    }
                    sb.AppendLine( "|}" );
                }

                return sb.ToString();
            }
        };

        private class EntitySpawnflag
        {
            public int value;
            public string desc;
            public int def;
        };

        private static string StripTextUntil( ref string s, char c )
        {
            int i = s.IndexOf( c );
            if ( i < 0 )
            {
                string m = s.Trim();
                s = "";
                return m;
            }
            string n = s.Substring( 0, i );
            s = s.Substring( i + 1 ).TrimStart();
            return n.Trim();
        }

        public static string ConvertFGD2Wiki( string input )
        {
            string token;

            // Trim input string
            input = input.Trim();

            //------------------
            // Parse the header
            //------------------

            // Read the entity type: point-based or brush-based
            EntityType eEntityType = EntityType.Error;
            token = StripTextUntil( ref input, ' ' );
            switch ( token )
            {
                case "@PointClass":
                case "@FilterClass":
                case "@NPCClass":
                    eEntityType = EntityType.PointBased;
                    break;
                case "@SolidClass":
                    eEntityType = EntityType.BrushBased;
                    break;
                case "@BaseClass":
                    return "@BaseClass not supported";
                default:
                    eEntityType = EntityType.Error;
                    break;
            }

            // Read everything until the equal sign
            string[] basetypes = new string[0];
            string sEntityParams = StripTextUntil( ref input, '=' );
            while ( sEntityParams.Length > 0 )
            {
                // Get the param name
                string sParamName = StripTextUntil( ref sEntityParams, '(' );
                string sParamData = StripTextUntil( ref sEntityParams, ')' );

                switch ( sParamName )
                {
                    case "base":
                        {
                            // Split into individual items
                            basetypes = sParamData.Split( ',' );
                            // Remove whitespace
                            for ( int j = 0; j < basetypes.Length; ++j )
                                basetypes[j] = basetypes[j].Trim().ToLower();

                            // Place targetname and parentname go first, if they exist, followed by the other templates
                            List<string> llBaseTypes = new List<string>( basetypes );   // temporary linked list
                            // TODO: this way is cheesy and inefficient; fix it
                            if ( llBaseTypes.Contains( "parentname" ) )
                            {
                                // Move parentname to the front
                                llBaseTypes.Remove( "parentname" );
                                llBaseTypes.Insert( 0, "parentname" );
                            }
                            if ( llBaseTypes.Contains( "targetname" ) )
                            {
                                // Move targetname to the front
                                llBaseTypes.Remove( "targetname" );
                                llBaseTypes.Insert( 0, "targetname" );
                            }
                            basetypes = llBaseTypes.ToArray();  // convert back to array

                            break;
                        }
                    default:
                        /* ignore it */
                        break;
                }
            }

            // TODO: not all entities have a description; handle that case

            // Read the entity name
            string sEntityName = StripTextUntil( ref input, ':' );

            // Read the entity description
            string sEntityDescriptionUnparsed = StripTextUntil( ref input, '[' );
            string sEntityDescription = "";
            while ( sEntityDescriptionUnparsed.Length > 0 )
            {
                // Ignore everything until a quote
                StripTextUntil( ref sEntityDescriptionUnparsed, '"' );
                // Take everything until the next quote
                sEntityDescription = sEntityDescription + StripTextUntil( ref sEntityDescriptionUnparsed, '"' ) + " ";

                // TODO: this will choke on escaped quotes
            }

            //---------------
            // Read the body
            //---------------

            string sBody = StripTextUntil( ref input, '@' );
            List<EntityInput> llInputs = new List<EntityInput>();
            List<EntityOutput> llOutputs = new List<EntityOutput>();
            List<EntityKeyvalue> llKeyvalues = new List<EntityKeyvalue>();
            List<EntitySpawnflag> llSpawnflags = new List<EntitySpawnflag>();
            while ( sBody.Length > 0 && !sBody.StartsWith( "]" ) )
            {
                // Check for line comment
                while ( sBody.StartsWith( "//" ) )
                {
                    // Eat everything until the next newline
                    StripTextUntil( ref sBody, '\n' );
                }

                // Get the item part of the next item:value pair
                string sItem = StripTextUntil( ref sBody, ')' );

                // Input
                if ( sItem.StartsWith( "input " ) )
                {
                    // Create a new input
                    EntityInput ei = new EntityInput();
                    // Discard the "input" part
                    StripTextUntil( ref sItem, ' ' );
                    // Read its information
                    ei.name = StripTextUntil( ref sItem, '(' );
                    ei.type = sItem;
                    // Read the desc
                    StripTextUntil( ref sBody, '"' );
                    ei.desc = StripTextUntil( ref sBody, '"' );
                    // Add it to the list of inputs
                    llInputs.Add( ei );
                }

                // Output
                else if ( sItem.StartsWith( "output " ) )
                {
                    // Create a new output
                    EntityOutput eo = new EntityOutput();
                    // Discard the "output" part
                    StripTextUntil( ref sItem, ' ' );
                    // Read its information
                    eo.name = StripTextUntil( ref sItem, '(' );
                    eo.type = StripTextUntil( ref sItem, ')' );
                    // Read the desc
                    StripTextUntil( ref sBody, '"' );
                    eo.desc = StripTextUntil( ref sBody, '"' );
                    // Add it to the list of outputs
                    llOutputs.Add( eo );
                }

                // Keyvalue
                else
                {
                    // Read the name
                    string sName = StripTextUntil( ref sItem, '(' );

                    // Is it the spawnflags field?
                    if ( sName == "spawnflags" )
                    {
                        StripTextUntil( ref sBody, '[' );
                        string sFlags = StripTextUntil( ref sBody, ']' );
                        while ( sFlags.Length > 0 )
                        {
                            // Check for line comment
                            while ( sFlags.StartsWith( "//" ) )
                            {
                                // Eat everything until the next newline
                                StripTextUntil( ref sFlags, '\n' );
                            }

                            // Create a new spawnflag
                            EntitySpawnflag fl = new EntitySpawnflag();

                            // Read its data
                            string sFlag = StripTextUntil( ref sFlags, '\n' );
                            fl.value = int.Parse( StripTextUntil( ref sFlag, ':' ) );
                            StripTextUntil( ref sFlag, '"' );
                            fl.desc = StripTextUntil( ref sFlag, '"' );
                            StripTextUntil( ref sFlag, ':' );
                            fl.def = int.Parse( StripTextUntil( ref sFlag, '/' ) );

                            // Check for a flag comment
                            if ( sFlag.StartsWith( "/" ) )
                                fl.desc += " (" + sFlag.Substring(1).Trim() + ")";

                            // Add it to the list of spawnflags
                            llSpawnflags.Add( fl );
                        }
                    }

                    // Not spawnflag
                    else
                    {
                        // TODO: handle multi-line strings in desc

                        // Create a new keyvalue
                        EntityKeyvalue kv = new EntityKeyvalue();
                        // Read its information
                        kv.name = sName;
                        kv.type = StripTextUntil( ref sItem, ')' );
                        // Read the SmartEdit name
                        StripTextUntil( ref sBody, '"' );
                        kv.name2 = StripTextUntil( ref sBody, '"' );
                        StripTextUntil( ref sBody, ':' );

                        // Is this a 'choices' keyvalue?
                        if ( kv.type == "choices" )
                        {
                            // Read the default value
                            kv.def = StripTextUntil( ref sBody, '=' );

                            // Parse the choices
                            StripTextUntil( ref sBody, '[' );
                            string sChoices = StripTextUntil( ref sBody, ']' );
                            while ( sChoices.Length > 0 )
                            {
                                // Create a new int,string pair
                                Pair<int, string> pair = new Pair<int, string>();
                                // Parse the choice info
                                pair.a = int.Parse( StripTextUntil( ref sChoices, ':' ) );
                                StripTextUntil( ref sChoices, '"' );
                                pair.b = StripTextUntil( ref sChoices, '"' );
                                // Add the pair
                                kv.choices.Add( pair );
                            }

                            // No desc (the SmartEdit name will be used)
                            kv.desc = "";
                        }
                        // Not a 'choices' keyvalue
                        else
                        {
                            // Read the rest of the line
                            String sLine = StripTextUntil( ref sBody, '\n' );

                            // Read the default value
                            if ( sLine.StartsWith( "\"" ) )
                            {
                                // This is the case where it's in quotes
                                StripTextUntil( ref sLine, '"' );
                                kv.def = StripTextUntil( ref sLine, '"' );
                            }
                            else
                            {
                                // This is the case where it isn't (it's an integer or blank)
                                kv.def = StripTextUntil( ref sLine, ':' );
                            }

                            // Read the desc
                            StripTextUntil( ref sLine, '"' );
                            kv.desc = StripTextUntil( ref sLine, '"' );
                        }

                        // Add it to the list of keyvalues
                        llKeyvalues.Add( kv );
                    }
                }
            }

            //------------------------
            // Create the output text
            //------------------------

            StringBuilder sb = new StringBuilder();

            // Create the wrongtitle line
            sb.Append( "{{wrongtitle|title=" );
            sb.Append( sEntityName );
            sb.AppendLine( "}}" );
            sb.AppendLine();

            // Create the Entity Description section
            sb.AppendLine( "==Entity Description==" );
            sb.AppendLine( sEntityDescription );
            sb.AppendLine();

            // Create the Availability section
            sb.AppendLine( "==Availability==" );
            sb.Append( "{{in game|" );
            switch ( eEntityType )
            {
                case EntityType.PointBased:
                    sb.Append( "point" );
                    break;
                case EntityType.BrushBased:
                    sb.Append( "brush" );
                    break;
                default:
                    return "Unexpected entity type: " + eEntityType;
            }
            sb.AppendLine( "}} ???" );
            sb.AppendLine( "{{in code|class=???|file=???}}" );
            sb.AppendLine();

            // Create the Keyvalues section
            sb.AppendLine( "==Keyvalues==" );
            foreach ( string template in basetypes )
            {
                sb.Append( "*{{kv " );
                sb.Append( template );
                sb.AppendLine( "}}" );
            }
            foreach ( EntityKeyvalue kv in llKeyvalues )
            {
                sb.Append( kv.ToWiki() );
            }
            sb.AppendLine();

            // Create the Flags section
            StringBuilder sbFlags = new StringBuilder();
            foreach ( string template in basetypes )
            {
                if ( IsEmptyFlag( template ) )
                    continue;
                sbFlags.Append( "*{{fl " );
                sbFlags.Append( template );
                sbFlags.AppendLine( "}}" );
            }
            foreach ( EntitySpawnflag fl in llSpawnflags )
            {
                sbFlags.Append( "*" );
                sbFlags.Append( fl.value );
                sbFlags.Append( " : " );
                sbFlags.AppendLine( fl.desc );
            }
            // If flag data is not empty, add the Flags section
            if ( sbFlags.ToString().Length > 0 )
            {
                sb.AppendLine( "==Flags==" );
                sb.Append( sbFlags.ToString() );
                sb.AppendLine();
            }

            // Create the Inputs section
            StringBuilder sbInputs = new StringBuilder();
            foreach ( string template in basetypes )
            {
                if ( IsEmptyInput( template ) )
                    continue;
                sbInputs.Append( "*{{i " );
                sbInputs.Append( template );
                sbInputs.AppendLine( "}}" );
            }
            foreach ( EntityInput ei in llInputs )
            {
                sbInputs.Append( ei.ToWiki() );
            }
            // If input data is not empty, add the Inputs section
            if ( sbInputs.ToString().Length > 0 )
            {
                sb.AppendLine( "==Inputs==" );
                sb.Append( sbInputs.ToString() );
                sb.AppendLine();
            }

            // Create the Outputs sections
            StringBuilder sbOutputs = new StringBuilder();
            foreach ( string template in basetypes )
            {
                if ( IsEmptyOutput( template ) )
                    continue;
                sbOutputs.Append( "*{{o " );
                sbOutputs.Append( template );
                sbOutputs.AppendLine( "}}" );
            }
            foreach ( EntityOutput eo in llOutputs )
            {
                sbOutputs.Append( eo.ToWiki() );
            }
            // If output data is not empty, add the Outputs section
            if ( sbOutputs.ToString().Length > 0 )
            {
                sb.AppendLine( "==Outputs==" );
                sb.Append( sbOutputs.ToString() );
                sb.AppendLine();
            }

            // Add the Category:Entities line
            sb.AppendLine( "[[Category:Entities]]" );
            sb.AppendLine();

            /*
            // TEMP: dump the tokens to the output box
            foreach ( string token in tokens )
                sb.AppendLine( token );
            */

            // Output the results
            return sb.ToString();
        }

        // TODO: check FGD instead of using the hard-coding below

        private static bool IsEmptyFlag( string s )
        {
            // TODO: efficiency
            switch ( s.ToLower() )
            {
                case "angles":
                case "parentname":
                case "targetname":
                case "renderfxchoices":
                case "basevehicle":
                case "renderfields":
                case "basefilter":
                case "origin":
                case "shadow":
                case "global":
                case "enabledisable":
                case "baseplat":
                case "button":
                    return true;
                default:
                    return false;
            }
        }

        private static bool IsEmptyInput( string s )
        {
            // TODO: efficiency
            switch ( s.ToLower() )
            {
                case "angles":
                case "renderfxchoices":
                case "renderfields":
                case "origin":
                case "global":
                    return true;
                default:
                    return false;
            }
        }

        private static bool IsEmptyOutput( string s )
        {
            // TODO: efficiency
            switch ( s.ToLower() )
            {
                case "angles":
                case "parentname":
                case "renderfxchoices":
                case "renderfields":
                case "origin":
                case "shadow":
                case "global":
                case "enabledisable":
                case "baseplat":
                    return true;
                default:
                    return false;
            }
        }

    } // class Conversion

} // namespace FGD2Wiki