コード例 #1
0
        // This version of GetSprite uses a callstack to check if it isn't going into an endless loop
        private FrameInfo GetSprite(int index, HashSet <StateStructure> prevstates)
        {
            // If we have sprite of our own, see if we can return this index
            if (index < sprites.Count)
            {
                return(sprites[index]);
            }

            // Otherwise, continue searching where goto tells us to go
            if (gotostate != null)
            {
                // Find the class
                ActorStructure a = parser.GetArchivedActorByName(gotostate.ClassName);
                if (a != null)
                {
                    StateStructure s = a.GetState(gotostate.StateName);
                    if ((s != null) && !prevstates.Contains(s))
                    {
                        prevstates.Add(this);
                        return(s.GetSprite(gotostate.SpriteOffset, prevstates));
                    }
                }
            }

            // If there is no goto keyword used, just give us one of our sprites if we can
            if (sprites.Count > 0)
            {
                // The following behavior should really depend on the flow control keyword (loop or stop) but who cares.
                return(sprites[0]);
            }

            return(new FrameInfo());
        }
コード例 #2
0
        /// <summary>
        /// This finds the best suitable sprite to use when presenting this actor to the user.
        /// </summary>
        public StateStructure.FrameInfo FindSuitableSprite()
        {
            // Info: actual sprites are resolved in ThingTypeInfo.SetupSpriteFrame() - mxd
            // Sprite forced?
            if (HasPropertyWithValue("$sprite"))
            {
                string sprite = GetPropertyValueString("$sprite", 0, true);                 //mxd

                //mxd. Valid when internal or exists
                if (sprite.StartsWith(DataManager.INTERNAL_PREFIX, StringComparison.OrdinalIgnoreCase) || General.Map.Data.GetSpriteExists(sprite))
                {
                    return new StateStructure.FrameInfo {
                               Sprite = sprite
                    }
                }
                ;

                //mxd. Bitch and moan
                General.ErrorLogger.Add(ErrorType.Warning, "DECORATE warning in " + classname + ":" + doomednum + ". The sprite \"" + sprite + "\" assigned by the \"$sprite\" property does not exist.");
            }

            //mxd. Try to get a suitable sprite from our hardcoded states list
            foreach (string state in SPRITE_CHECK_STATES)
            {
                if (!HasState(state))
                {
                    continue;
                }

                StateStructure           s    = GetState(state);
                StateStructure.FrameInfo info = s.GetSprite(0);
                if (!string.IsNullOrEmpty(info.Sprite))
                {
                    return(info);
                }
            }

            // Still no sprite found? then just pick the first we can find
            Dictionary <string, StateStructure> list = GetAllStates();

            foreach (StateStructure s in list.Values)
            {
                StateStructure.FrameInfo info = s.GetSprite(0);
                if (!string.IsNullOrEmpty(info.Sprite))
                {
                    return(info);
                }
            }

            //mxd. No dice...
            return(null);
        }

        #endregion
    }
コード例 #3
0
        }                                                                              //mxd

        #endregion

        #region ================== Constructor / Disposer

        // Constructor
        internal ActorStructure(DecorateParser parser, DecorateCategoryInfo catinfo)
        {
            // Initialize
            this.catinfo = catinfo;             //mxd
            flags        = new Dictionary <string, bool>(StringComparer.OrdinalIgnoreCase);
            props        = new Dictionary <string, List <string> >(StringComparer.OrdinalIgnoreCase);
            states       = new Dictionary <string, StateStructure>(StringComparer.OrdinalIgnoreCase);
            uservars     = new Dictionary <string, UniversalType>(StringComparer.OrdinalIgnoreCase); //mxd
            bool done = false;                                                                       //mxd

            // Always define a game property, but default to 0 values
            props["game"] = new List <string>();

            inheritclass = "actor";
            replaceclass = null;
            baseclass    = null;
            skipsuper    = false;

            // First next token is the class name
            parser.SkipWhitespace(true);
            classname = parser.StripTokenQuotes(parser.ReadToken(ACTOR_CLASS_SPECIAL_TOKENS));

            if (string.IsNullOrEmpty(classname))
            {
                parser.ReportError("Expected actor class name");
                return;
            }

            //mxd. Fail on duplicates
            if (parser.ActorsByClass.ContainsKey(classname.ToLowerInvariant()))
            {
                parser.ReportError("Actor \"" + classname + "\" is double-defined");
                return;
            }

            // Parse tokens before entering the actor scope
            while (parser.SkipWhitespace(true))
            {
                string token = parser.ReadToken();
                if (!string.IsNullOrEmpty(token))
                {
                    token = token.ToLowerInvariant();

                    switch (token)
                    {
                    case ":":
                        // The next token must be the class to inherit from
                        parser.SkipWhitespace(true);
                        inheritclass = parser.StripTokenQuotes(parser.ReadToken());
                        if (string.IsNullOrEmpty(inheritclass))
                        {
                            parser.ReportError("Expected class name to inherit from");
                            return;
                        }

                        // Find the actor to inherit from
                        baseclass = parser.GetArchivedActorByName(inheritclass);
                        break;

                    case "replaces":
                        // The next token must be the class to replace
                        parser.SkipWhitespace(true);
                        replaceclass = parser.StripTokenQuotes(parser.ReadToken());
                        if (string.IsNullOrEmpty(replaceclass))
                        {
                            parser.ReportError("Expected class name to replace");
                            return;
                        }
                        break;

                    case "native":
                        // Igore this token
                        break;

                    case "{":
                        // Actor scope begins here,
                        // break out of this parse loop
                        done = true;
                        break;

                    case "-":
                        // This could be a negative doomednum (but our parser sees the - as separate token)
                        // So read whatever is after this token and ignore it (negative doomednum indicates no doomednum)
                        parser.ReadToken();
                        break;

                    default:
                        //mxd. Property begins with $? Then the whole line is a single value
                        if (token.StartsWith("$"))
                        {
                            // This is for editor-only properties such as $sprite and $category
                            props[token] = new List <string> {
                                (parser.SkipWhitespace(false) ? parser.ReadLine() : "")
                            };
                            continue;
                        }

                        if (!int.TryParse(token, NumberStyles.Integer, CultureInfo.InvariantCulture, out doomednum))                                // Check if numeric
                        {
                            // Not numeric!
                            parser.ReportError("Expected editor number or start of actor scope while parsing \"" + classname + "\"");
                            return;
                        }

                        //mxd. Range check
                        if ((doomednum < General.Map.FormatInterface.MinThingType) || (doomednum > General.Map.FormatInterface.MaxThingType))
                        {
                            // Out of bounds!
                            parser.ReportError("Actor \"" + classname + "\" has invalid editor number. Editor number must be between "
                                               + General.Map.FormatInterface.MinThingType + " and " + General.Map.FormatInterface.MaxThingType);
                            return;
                        }
                        break;
                    }

                    if (done)
                    {
                        break;                          //mxd
                    }
                }
                else
                {
                    parser.ReportError("Unexpected end of structure");
                    return;
                }
            }

            // Now parse the contents of actor structure
            string previoustoken = "";

            done = false;             //mxd
            while (parser.SkipWhitespace(true))
            {
                string token = parser.ReadToken();
                token = token.ToLowerInvariant();

                switch (token)
                {
                case "+":
                case "-":
                    // Next token is a flag (option) to set or remove
                    bool flagvalue = (token == "+");
                    parser.SkipWhitespace(true);
                    string flagname = parser.ReadToken();
                    if (!string.IsNullOrEmpty(flagname))
                    {
                        // Add the flag with its value
                        flagname        = flagname.ToLowerInvariant();
                        flags[flagname] = flagvalue;
                    }
                    else
                    {
                        parser.ReportError("Expected flag name");
                        return;
                    }
                    break;

                case "action":
                case "native":
                    // We don't need this, ignore up to the first next ;
                    while (parser.SkipWhitespace(true))
                    {
                        string t = parser.ReadToken();
                        if (string.IsNullOrEmpty(t) || t == ";")
                        {
                            break;
                        }
                    }
                    break;

                case "skip_super":
                    skipsuper = true;
                    break;

                case "states":
                    // Now parse actor states until we reach the end of the states structure
                    while (parser.SkipWhitespace(true))
                    {
                        string statetoken = parser.ReadToken();
                        if (!string.IsNullOrEmpty(statetoken))
                        {
                            // Start of scope?
                            if (statetoken == "{")
                            {
                                // This is fine
                            }
                            // End of scope?
                            else if (statetoken == "}")
                            {
                                // Done with the states,
                                // break out of this parse loop
                                break;
                            }
                            // State label?
                            else if (statetoken == ":")
                            {
                                if (!string.IsNullOrEmpty(previoustoken))
                                {
                                    // Parse actor state
                                    StateStructure st = new StateStructure(this, parser);
                                    if (parser.HasError)
                                    {
                                        return;
                                    }
                                    states[previoustoken.ToLowerInvariant()] = st;
                                }
                                else
                                {
                                    parser.ReportError("Expected actor state name");
                                    return;
                                }
                            }
                            else
                            {
                                // Keep token
                                previoustoken = statetoken;
                            }
                        }
                        else
                        {
                            parser.ReportError("Unexpected end of structure");
                            return;
                        }
                    }
                    break;

                case "var":                         //mxd
                    // Type
                    parser.SkipWhitespace(true);
                    string        typestr = parser.ReadToken().ToUpperInvariant();
                    UniversalType type    = UniversalType.EnumOption;                          // There is no Unknown type, so let's use something impossiburu...
                    switch (typestr)
                    {
                    case "INT": type = UniversalType.Integer; break;

                    case "FLOAT": type = UniversalType.Float; break;

                    default: parser.LogWarning("Unknown user variable type"); break;
                    }

                    // Name
                    parser.SkipWhitespace(true);
                    string name = parser.ReadToken();
                    if (string.IsNullOrEmpty(name))
                    {
                        parser.ReportError("Expected User Variable name");
                        return;
                    }
                    if (!name.StartsWith("user_", StringComparison.OrdinalIgnoreCase))
                    {
                        parser.ReportError("User Variable name must start with \"user_\" prefix");
                        return;
                    }
                    if (uservars.ContainsKey(name))
                    {
                        parser.ReportError("User Variable \"" + name + "\" is double defined");
                        return;
                    }
                    if (!skipsuper && baseclass != null && baseclass.uservars.ContainsKey(name))
                    {
                        parser.ReportError("User variable \"" + name + "\" is already defined in one of the parent classes");
                        return;
                    }

                    // Rest
                    parser.SkipWhitespace(true);
                    string next = parser.ReadToken();
                    if (next == "[")                            // that's User Array. Let's skip it...
                    {
                        int arrlen = -1;
                        if (!parser.ReadSignedInt(ref arrlen))
                        {
                            parser.ReportError("Expected User Array length");
                            return;
                        }
                        if (arrlen < 1)
                        {
                            parser.ReportError("User Array length must be a positive value");
                            return;
                        }
                        if (!parser.NextTokenIs("]") || !parser.NextTokenIs(";"))
                        {
                            return;
                        }
                    }
                    else if (next != ";")
                    {
                        parser.ReportError("Expected \";\", but got \"" + next + "\"");
                        return;
                    }
                    else
                    {
                        // Add to collection
                        uservars.Add(name, type);
                    }
                    break;

                case "}":
                    //mxd. Get user vars from the BaseClass, if we have one
                    if (!skipsuper && baseclass != null && baseclass.uservars.Count > 0)
                    {
                        foreach (var group in baseclass.uservars)
                        {
                            uservars.Add(group.Key, group.Value);
                        }
                    }

                    // Actor scope ends here, break out of this parse loop
                    done = true;
                    break;

                // Monster property?
                case "monster":
                    // This sets certain flags we are interested in
                    flags["shootable"]      = true;
                    flags["countkill"]      = true;
                    flags["solid"]          = true;
                    flags["canpushwalls"]   = true;
                    flags["canusewalls"]    = true;
                    flags["activatemcross"] = true;
                    flags["canpass"]        = true;
                    flags["ismonster"]      = true;
                    break;

                // Projectile property?
                case "projectile":
                    // This sets certain flags we are interested in
                    flags["noblockmap"]     = true;
                    flags["nogravity"]      = true;
                    flags["dropoff"]        = true;
                    flags["missile"]        = true;
                    flags["activateimpact"] = true;
                    flags["activatepcross"] = true;
                    flags["noteleport"]     = true;
                    break;

                // Clearflags property?
                case "clearflags":
                    // Clear all flags
                    flags.Clear();
                    break;

                // Game property?
                case "game":
                    // Include all tokens on the same line
                    List <string> games = new List <string>();
                    while (parser.SkipWhitespace(false))
                    {
                        string v = parser.ReadToken();
                        if (string.IsNullOrEmpty(v))
                        {
                            parser.ReportError("Expected \"Game\" property value");
                            return;
                        }
                        if (v == "\n")
                        {
                            break;
                        }
                        if (v == "}")
                        {
                            return;                                          //mxd
                        }
                        if (v != ",")
                        {
                            games.Add(v.ToLowerInvariant());
                        }
                    }
                    props[token] = games;
                    break;

                // Property
                default:
                    // Property begins with $? Then the whole line is a single value
                    if (token.StartsWith("$"))
                    {
                        // This is for editor-only properties such as $sprite and $category
                        props[token] = new List <string> {
                            (parser.SkipWhitespace(false) ? parser.ReadLine() : "")
                        };
                    }
                    else
                    {
                        // Next tokens up until the next newline are values
                        List <string> values = new List <string>();
                        while (parser.SkipWhitespace(false))
                        {
                            string v = parser.ReadToken();
                            if (string.IsNullOrEmpty(v))
                            {
                                parser.ReportError("Unexpected end of structure");
                                return;
                            }
                            if (v == "\n")
                            {
                                break;
                            }
                            if (v == "}")
                            {
                                return;                                              //mxd
                            }
                            if (v != ",")
                            {
                                values.Add(v);
                            }
                        }

                        //mxd. Translate scale to xscale and yscale
                        if (token == "scale")
                        {
                            props["xscale"] = values;
                            props["yscale"] = values;
                        }
                        else
                        {
                            props[token] = values;
                        }
                    }
                    break;
                }

                if (done)
                {
                    break;                      //mxd
                }
                // Keep token
                previoustoken = token;
            }

            //mxd. Check if baseclass is valid
            if (inheritclass.ToLowerInvariant() != "actor" && doomednum > -1 && baseclass == null)
            {
                //check if this class inherits from a class defined in game configuration
                Dictionary <int, ThingTypeInfo> things = General.Map.Config.GetThingTypes();
                string inheritclasscheck = inheritclass.ToLowerInvariant();

                foreach (KeyValuePair <int, ThingTypeInfo> ti in things)
                {
                    if (!string.IsNullOrEmpty(ti.Value.ClassName) && ti.Value.ClassName.ToLowerInvariant() == inheritclasscheck)
                    {
                        //states
                        if (states.Count == 0 && !string.IsNullOrEmpty(ti.Value.Sprite))
                        {
                            states.Add("spawn", new StateStructure(ti.Value.Sprite.Substring(0, 5)));
                        }

                        //flags
                        if (ti.Value.Hangs && !flags.ContainsKey("spawnceiling"))
                        {
                            flags["spawnceiling"] = true;
                        }

                        if (ti.Value.Blocking > 0 && !flags.ContainsKey("solid"))
                        {
                            flags["solid"] = true;
                        }

                        //properties
                        if (!props.ContainsKey("height"))
                        {
                            props["height"] = new List <string> {
                                ti.Value.Height.ToString()
                            }
                        }
                        ;

                        if (!props.ContainsKey("radius"))
                        {
                            props["radius"] = new List <string> {
                                ti.Value.Radius.ToString()
                            }
                        }
                        ;

                        return;
                    }
                }

                parser.LogWarning("Unable to find \"" + inheritclass + "\" class to inherit from, while parsing \"" + classname + ":" + doomednum + "\"");
            }
        }
コード例 #4
0
ファイル: ActorStructure.cs プロジェクト: volte/doombuilderx
        // Constructor
        internal ActorStructure(DecorateParser parser)
        {
            // Initialize
            flags  = new Dictionary <string, bool>();
            props  = new Dictionary <string, List <string> >();
            states = new Dictionary <string, StateStructure>();

            // Always define a game property, but default to 0 values
            props["game"] = new List <string>();

            inheritclass = "actor";
            replaceclass = null;
            baseclass    = null;
            skipsuper    = false;

            // First next token is the class name
            parser.SkipWhitespace(true);
            classname = parser.StripTokenQuotes(parser.ReadToken());
            if (string.IsNullOrEmpty(classname))
            {
                parser.ReportError("Expected actor class name");
                return;
            }

            // Parse tokens before entering the actor scope
            while (parser.SkipWhitespace(true))
            {
                string token = parser.ReadToken();
                if (!string.IsNullOrEmpty(token))
                {
                    token = token.ToLowerInvariant();
                    if (token == ":")
                    {
                        // The next token must be the class to inherit from
                        parser.SkipWhitespace(true);
                        inheritclass = parser.StripTokenQuotes(parser.ReadToken());
                        if (string.IsNullOrEmpty(inheritclass) || parser.IsSpecialToken(inheritclass))
                        {
                            parser.ReportError("Expected class name to inherit from");
                            return;
                        }
                        else
                        {
                            // Find the actor to inherit from
                            baseclass = parser.GetArchivedActorByName(inheritclass);
                            if (baseclass == null)
                            {
                                General.ErrorLogger.Add(ErrorType.Warning, "Unable to find the DECORATE class '" + inheritclass + "' to inherit from, while parsing '" + classname + "'");
                            }
                        }
                    }
                    else if (token == "replaces")
                    {
                        // The next token must be the class to replace
                        parser.SkipWhitespace(true);
                        replaceclass = parser.StripTokenQuotes(parser.ReadToken());
                        if (string.IsNullOrEmpty(replaceclass) || parser.IsSpecialToken(replaceclass))
                        {
                            parser.ReportError("Expected class name to replace");
                            return;
                        }
                    }
                    else if (token == "native")
                    {
                        // Igore this token
                    }
                    else if (token == "{")
                    {
                        // Actor scope begins here,
                        // break out of this parse loop
                        break;
                    }
                    else if (token == "-")
                    {
                        // This could be a negative doomednum (but our parser sees the - as separate token)
                        // So read whatever is after this token and ignore it (negative doomednum indicates no doomednum)
                        parser.ReadToken();
                    }
                    else
                    {
                        // Check if numeric
                        if (!int.TryParse(token, NumberStyles.Integer, CultureInfo.InvariantCulture, out doomednum))
                        {
                            // Not numeric!
                            parser.ReportError("Expected numeric editor thing number or start of actor scope");
                            return;
                        }
                    }
                }
                else
                {
                    parser.ReportError("Unexpected end of structure");
                    return;
                }
            }

            // Now parse the contents of actor structure
            string previoustoken = "";

            while (parser.SkipWhitespace(true))
            {
                string token = parser.ReadToken();
                token = token.ToLowerInvariant();

                if ((token == "+") || (token == "-"))
                {
                    // Next token is a flag (option) to set or remove
                    bool flagvalue = (token == "+");
                    parser.SkipWhitespace(true);
                    string flagname = parser.ReadToken();
                    if (!string.IsNullOrEmpty(flagname))
                    {
                        // Add the flag with its value
                        flagname        = flagname.ToLowerInvariant();
                        flags[flagname] = flagvalue;
                    }
                    else
                    {
                        parser.ReportError("Expected flag name");
                        return;
                    }
                }
                else if ((token == "action") || (token == "native"))
                {
                    // We don't need this, ignore up to the first next ;
                    while (parser.SkipWhitespace(true))
                    {
                        string t = parser.ReadToken();
                        if ((t == ";") || (t == null))
                        {
                            break;
                        }
                    }
                }
                else if (token == "skip_super")
                {
                    skipsuper = true;
                }
                else if (token == "states")
                {
                    // Now parse actor states until we reach the end of the states structure
                    while (parser.SkipWhitespace(true))
                    {
                        string statetoken = parser.ReadToken();
                        if (!string.IsNullOrEmpty(statetoken))
                        {
                            // Start of scope?
                            if (statetoken == "{")
                            {
                                // This is fine
                            }
                            // End of scope?
                            else if (statetoken == "}")
                            {
                                // Done with the states,
                                // break out of this parse loop
                                break;
                            }
                            // State label?
                            else if (statetoken == ":")
                            {
                                if (!string.IsNullOrEmpty(previoustoken))
                                {
                                    // Parse actor state
                                    StateStructure st = new StateStructure(this, parser, previoustoken);
                                    if (parser.HasError)
                                    {
                                        return;
                                    }
                                    states[previoustoken.ToLowerInvariant()] = st;
                                }
                                else
                                {
                                    parser.ReportError("Unexpected end of structure");
                                    return;
                                }
                            }
                            else
                            {
                                // Keep token
                                previoustoken = statetoken;
                            }
                        }
                        else
                        {
                            parser.ReportError("Unexpected end of structure");
                            return;
                        }
                    }
                }
                else if (token == "}")
                {
                    // Actor scope ends here,
                    // break out of this parse loop
                    break;
                }
                // Monster property?
                else if (token == "monster")
                {
                    // This sets certain flags we are interested in
                    flags["shootable"]      = true;
                    flags["countkill"]      = true;
                    flags["solid"]          = true;
                    flags["canpushwalls"]   = true;
                    flags["canusewalls"]    = true;
                    flags["activatemcross"] = true;
                    flags["canpass"]        = true;
                    flags["ismonster"]      = true;
                }
                // Projectile property?
                else if (token == "projectile")
                {
                    // This sets certain flags we are interested in
                    flags["noblockmap"]     = true;
                    flags["nogravity"]      = true;
                    flags["dropoff"]        = true;
                    flags["missile"]        = true;
                    flags["activateimpact"] = true;
                    flags["activatepcross"] = true;
                    flags["noteleport"]     = true;
                }
                // Clearflags property?
                else if (token == "clearflags")
                {
                    // Clear all flags
                    flags.Clear();
                }
                // Game property?
                else if (token == "game")
                {
                    // Include all tokens on the same line
                    List <string> games = new List <string>();
                    while (parser.SkipWhitespace(false))
                    {
                        string v = parser.ReadToken();
                        if (v == null)
                        {
                            parser.ReportError("Unexpected end of structure");
                            return;
                        }
                        if (v == "\n")
                        {
                            break;
                        }
                        if (v != ",")
                        {
                            games.Add(v.ToLowerInvariant());
                        }
                    }
                    props[token] = games;
                }
                // Property
                else
                {
                    // Property begins with $? Then the whole line is a single value
                    if (token.StartsWith("$"))
                    {
                        // This is for editor-only properties such as $sprite and $category
                        List <string> values = new List <string>();
                        if (parser.SkipWhitespace(false))
                        {
                            values.Add(parser.ReadLine());
                        }
                        else
                        {
                            values.Add("");
                        }
                        props[token] = values;
                    }
                    else
                    {
                        // Next tokens up until the next newline are values
                        List <string> values = new List <string>();
                        while (parser.SkipWhitespace(false))
                        {
                            string v = parser.ReadToken();
                            if (v == null)
                            {
                                parser.ReportError("Unexpected end of structure");
                                return;
                            }
                            if (v == "\n")
                            {
                                break;
                            }
                            if (v != ",")
                            {
                                values.Add(v);
                            }
                        }
                        props[token] = values;
                    }
                }

                // Keep token
                previoustoken = token;
            }
        }
コード例 #5
0
ファイル: ActorStructure.cs プロジェクト: volte/doombuilderx
        /// <summary>
        /// This finds the best suitable sprite to use when presenting this actor to the user.
        /// </summary>
        public string FindSuitableSprite()
        {
            string result = "";

            // Sprite forced?
            if (HasPropertyWithValue("$sprite"))
            {
                return(GetPropertyValueString("$sprite", 0));
            }
            else
            {
                // Try the idle state
                if (HasState("idle"))
                {
                    StateStructure s          = GetState("idle");
                    string         spritename = s.GetSprite(0);
                    if (!string.IsNullOrEmpty(spritename))
                    {
                        result = spritename;
                    }
                }

                // Try the see state
                if (string.IsNullOrEmpty(result) && HasState("see"))
                {
                    StateStructure s          = GetState("see");
                    string         spritename = s.GetSprite(0);
                    if (!string.IsNullOrEmpty(spritename))
                    {
                        result = spritename;
                    }
                }

                // Try the inactive state
                if (string.IsNullOrEmpty(result) && HasState("inactive"))
                {
                    StateStructure s          = GetState("inactive");
                    string         spritename = s.GetSprite(0);
                    if (!string.IsNullOrEmpty(spritename))
                    {
                        result = spritename;
                    }
                }

                // Try the spawn state
                if (string.IsNullOrEmpty(result) && HasState("spawn"))
                {
                    StateStructure s          = GetState("spawn");
                    string         spritename = s.GetSprite(0);
                    if (!string.IsNullOrEmpty(spritename))
                    {
                        result = spritename;
                    }
                }

                // Still no sprite found? then just pick the first we can find
                if (string.IsNullOrEmpty(result))
                {
                    Dictionary <string, StateStructure> list = GetAllStates();
                    foreach (StateStructure s in list.Values)
                    {
                        string spritename = s.GetSprite(0);
                        if (!string.IsNullOrEmpty(spritename))
                        {
                            result = spritename;
                            break;
                        }
                    }
                }

                if (!string.IsNullOrEmpty(result))
                {
                    // The sprite name is not actually complete, we still have to append
                    // the direction characters to it. Find an existing sprite with direction.
                    foreach (string postfix in SPRITE_POSTFIXES)
                    {
                        if (General.Map.Data.GetSpriteExists(result + postfix))
                        {
                            return(result + postfix);
                        }
                    }
                }
            }

            // No sprite found
            return("");
        }
コード例 #6
0
        /// <summary>
        /// This finds the best suitable sprite to use when presenting this actor to the user.
        /// </summary>
        public StateStructure.FrameInfo FindSuitableSprite()
        {
            // Info: actual sprites are resolved in ThingTypeInfo.SetupSpriteFrame() - mxd
            // Sprite forced?
            if (HasPropertyWithValue("$sprite"))
            {
                string sprite = GetPropertyValueString("$sprite", 0, true);                 //mxd

                //mxd. Valid when internal or exists
                if (sprite.StartsWith(DataManager.INTERNAL_PREFIX, StringComparison.OrdinalIgnoreCase) || General.Map.Data.GetSpriteExists(sprite))
                {
                    return new StateStructure.FrameInfo {
                               Sprite = sprite
                    }
                }
                ;

                //mxd. Bitch and moan
                General.ErrorLogger.Add(ErrorType.Warning, "DECORATE warning in " + classname + ":" + doomednum + ". The sprite \"" + sprite + "\" assigned by the \"$sprite\" property does not exist.");
            }

            StateStructure.FrameInfo firstNonTntInfo = null;
            StateStructure.FrameInfo firstInfo       = null;
            // Pick the first we can find (including and not including TNT1)
            Dictionary <string, StateStructure> list = GetAllStates();

            foreach (StateStructure s in list.Values)
            {
                StateStructure.FrameInfo info = s.GetSprite(0);
                if (string.IsNullOrEmpty(info.Sprite))
                {
                    continue;
                }

                if (!info.IsEmpty())
                {
                    firstNonTntInfo = info;
                }
                if (firstInfo == null)
                {
                    firstInfo = info;
                }

                if (firstNonTntInfo != null)
                {
                    break;
                }
            }

            //mxd. Try to get a suitable sprite from our hardcoded states list
            StateStructure.FrameInfo lastNonTntInfo = null;
            StateStructure.FrameInfo lastInfo       = null;
            foreach (string state in SPRITE_CHECK_STATES)
            {
                if (!HasState(state))
                {
                    continue;
                }

                StateStructure           s    = GetState(state);
                StateStructure.FrameInfo info = s.GetSprite(0);
                //if(!string.IsNullOrEmpty(info.Sprite)) return info;
                if (string.IsNullOrEmpty(info.Sprite))
                {
                    continue;
                }

                if (!info.IsEmpty())
                {
                    lastNonTntInfo = info;
                }
                if (lastInfo == null)
                {
                    lastInfo = info;
                }

                if (lastNonTntInfo != null)
                {
                    break;
                }
            }

            // [ZZ] return whatever is there by priority. try to pick non-TNT1 frames.
            StateStructure.FrameInfo[] infos = new StateStructure.FrameInfo[] { lastNonTntInfo, lastInfo, firstNonTntInfo, firstInfo };
            foreach (StateStructure.FrameInfo info in infos)
            {
                if (info != null)
                {
                    return(info);
                }
            }

            //mxd. No dice...
            return(null);
        }
コード例 #7
0
        /// <summary>
        /// This finds the best suitable sprite to use when presenting this actor to the user.
        /// </summary>
        public string FindSuitableSprite()
        {
            string result = "";

            // Sprite forced?
            if (props.ContainsKey("$sprite"))
            {
                return(props["$sprite"][0]);
            }
            else
            {
                // Try the idle state
                if (states.ContainsKey("idle"))
                {
                    StateStructure s = states["idle"];
                    if (!string.IsNullOrEmpty(s.FirstSprite))
                    {
                        result = s.FirstSprite;
                    }
                }

                // Try the see state
                if (string.IsNullOrEmpty(result) && states.ContainsKey("see"))
                {
                    StateStructure s = states["see"];
                    if (!string.IsNullOrEmpty(s.FirstSprite))
                    {
                        result = s.FirstSprite;
                    }
                }

                // Try the inactive state
                if (string.IsNullOrEmpty(result) && states.ContainsKey("inactive"))
                {
                    StateStructure s = states["inactive"];
                    if (!string.IsNullOrEmpty(s.FirstSprite))
                    {
                        result = s.FirstSprite;
                    }
                }

                // Try the spawn state
                if (string.IsNullOrEmpty(result) && states.ContainsKey("spawn"))
                {
                    StateStructure s = states["spawn"];
                    if (!string.IsNullOrEmpty(s.FirstSprite))
                    {
                        result = s.FirstSprite;
                    }
                }

                // Still no sprite found? then just pick the first we can find
                if (string.IsNullOrEmpty(result))
                {
                    foreach (StateStructure s in states.Values)
                    {
                        if (!string.IsNullOrEmpty(s.FirstSprite))
                        {
                            result = s.FirstSprite;
                            break;
                        }
                    }
                }

                if (!string.IsNullOrEmpty(result))
                {
                    // The sprite name is not actually complete, we still have to append
                    // the direction characters to it. Find an existing sprite with direction.
                    foreach (string postfix in SPRITE_POSTFIXES)
                    {
                        if (General.Map.Data.GetSpriteExists(result + postfix))
                        {
                            return(result + postfix);
                        }
                    }
                }
            }

            // No sprite found
            return("");
        }