Ejemplo n.º 1
0
        // parse a collection of variables from a file
        public static VariableSystem readFrom(string fileName)
        {
            if (fileName == null || fileName.Length == 0)
            {
                return(null);
            }

            string data;

            // open the file
            StreamReader input = null;

            try {
                input = File.OpenText(fileName);
            }
            catch (Exception) {
                return(null);
            }

            VariableSystem variables     = new VariableSystem();
            string         category      = null;
            int            categoryIndex = -1;

            // read to the end of the file
            while ((data = input.ReadLine()) != null)
            {
                data = data.Trim();
                if (data.Length == 0)
                {
                    category      = null;
                    categoryIndex = -1;
                    continue;
                }

                // parse a category
                if (data[0] == '[' && data[data.Length - 1] == ']')
                {
                    category      = data.Substring(1, data.Length - 2);
                    categoryIndex = variables.addCategory(category);
                }
                // parse a variable
                else
                {
                    Variable v = Variable.parseFrom(data);
                    if (v != null)
                    {
                        v.category = categoryIndex;
                        variables.add(v);
                    }
                }
            }

            if (input != null)
            {
                input.Close();
            }

            return(variables);
        }
Ejemplo n.º 2
0
        public override bool Equals(object o)
        {
            VariableSystem v = o as VariableSystem;

            if (v == null)
            {
                return(false);
            }
            return(m_variables.Equals(v.m_variables));
        }
Ejemplo n.º 3
0
        public static Terrain parseFrom(StreamReader input, SpriteSheetCollection spriteSheets)
        {
            if (input == null || spriteSheets == null)
            {
                return(null);
            }

            VariableSystem properties = new VariableSystem();

            // store all of the animation properties
            String   data;
            Variable property;

            do
            {
                data = input.ReadLine();
                if (data == null)
                {
                    return(null);
                }

                data = data.Trim();
                if (data.Length == 0)
                {
                    continue;
                }

                property = Variable.parseFrom(data);
                if (property == null)
                {
                    return(null);
                }

                properties.add(property);
            } while (properties.size() < 2);

            String heightmapName = properties.getValue("Heightmap Name");

            if (heightmapName == null)
            {
                return(null);
            }
            string visibleString = properties.getValue("Visible");

            if (visibleString == null)
            {
                return(null);
            }
            bool visible = visibleString.Equals("True", StringComparison.OrdinalIgnoreCase);

            // create the object
            Terrain newObject = new Terrain(visible, heightmapName);

            return(newObject);
        }
Ejemplo n.º 4
0
        // load game settings from a specified file name
        public bool loadFrom(string fileName)
        {
            // use a variable system to parse the settings file
            VariableSystem newVariables = VariableSystem.readFrom(fileName);

            if (newVariables == null)
            {
                return(false);
            }

            m_variables = newVariables;

            // create local variables instantiated with data parsed from the variable system
            try { screenWidth = int.Parse(m_variables.getValue("Screen Width", "Settings")); } catch (Exception) { }
            try { screenHeight = int.Parse(m_variables.getValue("Screen Height", "Settings")); } catch (Exception) { }
            try { fullScreen = bool.Parse(m_variables.getValue("Fullscreen", "Settings")); } catch (Exception) { }
            spriteSheetFileName = m_variables.getValue("SpriteSheet File", "Paths");
            animationsFileName  = m_variables.getValue("Animations File", "Paths");

            return(true);
        }
Ejemplo n.º 5
0
        // parse and create a sprite sheet from a text file input stream
        public static SpriteSheet parseFrom(StreamReader instream, ContentManager content)
        {
            if (instream == null || content == null)
            {
                return(null);
            }

            string input = null;
            string data  = null;

            Variable        v;
            VariableSystem  properties = new VariableSystem();
            string          spriteSheetName, spriteSheetFileName = null;
            SpriteSheetType spriteSheetType  = SpriteSheetType.Invalid;
            Sprite          spriteSheetImage = null;
            SpriteSheet     spriteSheet      = null;

            try {
                while ((input = instream.ReadLine()) != null)
                {
                    // trim the current line being read
                    data = input.Trim();

                    // if the line is blank, discard it
                    if (data.Length == 0)
                    {
                        continue;
                    }
                    // otherwise, if it contains information
                    else
                    {
                        // attempt to parse a variable from the data and store it
                        v = Variable.parseFrom(data);

                        // if successful, store it
                        if (v != null)
                        {
                            properties.add(v);
                        }

                        // if the variable is a specification of the number of sprites or
                        // the number of grids to be parsed, begin doing so
                        if (v != null && (v.id.Equals("Number of Sprites", StringComparison.OrdinalIgnoreCase) ||
                                          v.id.Equals("Number of Grids", StringComparison.OrdinalIgnoreCase) ||
                                          (properties.contains("SpriteSheet Name") &&
                                           properties.contains("SpriteSheet Type") &&
                                           properties.contains("File Name") &&
                                           properties.getValue("SpriteSheet Type").Equals("Single", StringComparison.OrdinalIgnoreCase))))
                        {
                            // get the sprite sheet name and verify it exists
                            spriteSheetName = properties.getValue("SpriteSheet Name");
                            if (spriteSheetName == null)
                            {
                                return(null);
                            }

                            // parse the sprite sheet type and ensure it is valid
                            spriteSheetType = parseType(properties.getValue("SpriteSheet Type"));
                            if (spriteSheetType == SpriteSheetType.Invalid)
                            {
                                return(null);
                            }

                            // get the sprite sheet file name
                            spriteSheetFileName = properties.getValue("File Name");
                            if (spriteSheetFileName == null)
                            {
                                return(null);
                            }

                            // load the sprite to be parsed by the sprite sheet system
                            spriteSheetImage      = new Sprite(spriteSheetFileName, content);
                            spriteSheetImage.type = SpriteType.SpriteSheet;

                            // ===============================================================================
                            // Single Sprite =================================================================
                            // ===============================================================================
                            if (spriteSheetType == SpriteSheetType.Single)
                            {
                                VariableSystem spriteAttributes = new VariableSystem();
                                for (int i = 0; i < 4; i++)
                                {
                                    spriteAttributes.add(Variable.parseFrom(instream.ReadLine()));
                                }

                                // get the sprite name
                                String spriteNameData = spriteAttributes.getValue("Sprite Name");
                                if (spriteNameData == null)
                                {
                                    return(null);
                                }

                                // get the sprite type
                                String spriteTypeData = spriteAttributes.getValue("Sprite Type");
                                if (spriteTypeData == null)
                                {
                                    return(null);
                                }
                                SpriteType spriteType = Sprite.parseType(spriteTypeData);
                                if (spriteType == SpriteType.Unknown)
                                {
                                    return(null);
                                }

                                // get the offset of the sprite
                                String offsetData = spriteAttributes.getValue("Pixel Offset");
                                if (offsetData == null)
                                {
                                    return(null);
                                }
                                String[] offsetValues = offsetData.Split(',');
                                if (offsetValues.Length != 2)
                                {
                                    return(null);
                                }

                                // get the size of the sprite
                                String sizeData = spriteAttributes.getValue("Size");
                                if (sizeData == null)
                                {
                                    return(null);
                                }
                                String[] sizeValues = sizeData.Split(',');
                                if (sizeValues.Length != 2)
                                {
                                    return(null);
                                }

                                // create a rectangle representing the first cell in the current grid
                                Rectangle grid;
                                try {
                                    grid = new Rectangle(int.Parse(offsetValues[0]),
                                                         int.Parse(offsetValues[1]),
                                                         int.Parse(sizeValues[0]),
                                                         int.Parse(sizeValues[1]));
                                }
                                catch (Exception) { return(null); }

                                Sprite sprite = new Sprite(spriteSheetFileName, content);
                                sprite.name       = spriteNameData;
                                sprite.parentName = spriteSheetName;
                                sprite.index      = 0;
                                sprite.type       = spriteType;

                                spriteSheet       = new SpriteSheet();
                                spriteSheet.image = sprite;
                                spriteSheet.name  = spriteSheetName;
                                spriteSheet.addSprite(sprite);
                            }
                            // ===============================================================================
                            // Arbitrary Offset SpriteSheet ==================================================
                            // ===============================================================================
                            else if (spriteSheetType == SpriteSheetType.ArbitraryOffsets)
                            {
                                VariableSystem spriteAttributes = new VariableSystem();
                                int            numberOfSprites;

                                // verify that the number of sprites is valid
                                try { numberOfSprites = int.Parse(v.value); }
                                catch (Exception) { return(null); }
                                if (numberOfSprites <= 0)
                                {
                                    return(null);
                                }

                                int          spriteIndex;
                                string       spriteName, spriteType;
                                Rectangle    grid;
                                Rectangle[]  offsets     = new Rectangle[numberOfSprites];
                                string[]     spriteNames = new string[numberOfSprites];
                                SpriteType[] spriteTypes = new SpriteType[numberOfSprites];
                                for (int i = 0; i < numberOfSprites; i++)
                                {
                                    spriteNames[i] = null;
                                    spriteTypes[i] = SpriteType.Unknown;
                                    offsets[i]     = new Rectangle(0, 0, 0, 0);
                                }
                                // loop through and collect the attributes for each sprite
                                for (int i = 0; i < numberOfSprites; i++)
                                {
                                    spriteAttributes.clear();
                                    // get the 5 sprite attributes (index, name, type, offset, size)
                                    for (int j = 0; j < 5; j++)
                                    {
                                        spriteAttributes.add(Variable.parseFrom(instream.ReadLine()));
                                    }

                                    // store the sprite index value and validate it
                                    try { spriteIndex = int.Parse(spriteAttributes.getValue("Sprite")); }
                                    catch (Exception) { return(null); }
                                    if (spriteIndex < 0 || spriteIndex >= numberOfSprites)
                                    {
                                        return(null);
                                    }

                                    // get the sprite name
                                    spriteName = spriteAttributes.getValue("Name");
                                    if (spriteName == null)
                                    {
                                        return(null);
                                    }

                                    // get the sprite type (as a string)
                                    spriteType = spriteAttributes.getValue("Type");
                                    if (spriteType == null)
                                    {
                                        return(null);
                                    }

                                    // parse the sprite's offset in its parent sprite sheet
                                    string temp = spriteAttributes.getValue("Pixel Offset");
                                    if (temp == null)
                                    {
                                        return(null);
                                    }
                                    string[] offsetValues = temp.Split(',');
                                    if (offsetValues.Length != 2)
                                    {
                                        return(null);
                                    }

                                    // parse the size of the sprite
                                    temp = spriteAttributes.getValue("Size");
                                    if (temp == null)
                                    {
                                        return(null);
                                    }
                                    string[] sizeValues = temp.Split(',');
                                    if (sizeValues.Length != 2)
                                    {
                                        return(null);
                                    }

                                    // attempt to create a source grid based off of these specifications
                                    try { grid = new Rectangle(int.Parse(offsetValues[0]),
                                                               int.Parse(offsetValues[1]),
                                                               int.Parse(sizeValues[0]),
                                                               int.Parse(sizeValues[1])); }
                                    catch (Exception) { return(null); }

                                    // assign the values for temporary storage
                                    spriteNames[spriteIndex] = spriteName;
                                    spriteTypes[spriteIndex] = Sprite.parseType(spriteType);
                                    offsets[spriteIndex]     = new Rectangle(grid.X, grid.Y, grid.Width, grid.Height);
                                }

                                // once the attributes and offsets for all of the sprites have been collected, create the sprite sheet
                                spriteSheet      = new SpriteSheet(spriteSheetImage, offsets);
                                spriteSheet.name = spriteSheetName;

                                // loop through the temporarily stored sprite attributes and assign them to each corresponding sprite
                                for (int i = 0; i < numberOfSprites; i++)
                                {
                                    spriteSheet.getSprite(i).name       = spriteNames[i];
                                    spriteSheet.getSprite(i).index      = i;
                                    spriteSheet.getSprite(i).parentName = spriteSheetName;
                                    spriteSheet.getSprite(i).type       = spriteTypes[i];
                                }
                            }

                            // ===============================================================================
                            // Single Grid SpriteSheet =======================================================
                            // ===============================================================================
                            else if (spriteSheetType == SpriteSheetType.SingleGrid)
                            {
                                VariableSystem spriteAttributes = new VariableSystem();
                                Rectangle      grid;
                                Axis           direction;
                                int            numberOfRows, numberOfColumns, numberOfSprites;

                                // get the number of sprites to obtain attributes for
                                try { numberOfSprites = int.Parse(v.value); }
                                catch (Exception) { return(null); }

                                // get the grid offset
                                string temp = properties.getValue("Pixel Offset");
                                if (temp == null)
                                {
                                    return(null);
                                }
                                string[] offsetValues = temp.Split(',');
                                if (offsetValues.Length != 2)
                                {
                                    return(null);
                                }

                                // get the size of each cell within the grid
                                temp = properties.getValue("Size");
                                if (temp == null)
                                {
                                    return(null);
                                }
                                string[] sizeValues = temp.Split(',');
                                if (sizeValues.Length != 2)
                                {
                                    return(null);
                                }

                                // convert the offset and cell size to a rectangle
                                try { grid = new Rectangle(int.Parse(offsetValues[0]),
                                                           int.Parse(offsetValues[1]),
                                                           int.Parse(sizeValues[0]),
                                                           int.Parse(sizeValues[1])); }
                                catch (Exception) { return(null); }

                                // get the direction to parse the sprites in
                                direction = parseAxis(properties.getValue("Direction"));

                                // get the number of rows in the grid
                                try { numberOfRows = int.Parse(properties.getValue("Number of Rows")); }
                                catch (Exception) { return(null); }

                                // get the number of columns in the grid
                                try { numberOfColumns = int.Parse(properties.getValue("Number of Columns")); }
                                catch (Exception) { return(null); }

                                // create the sprite sheet based on the corresponding specifications
                                spriteSheet = new SpriteSheet(spriteSheetImage,
                                                              grid,
                                                              direction,
                                                              numberOfRows,
                                                              numberOfColumns);
                                spriteSheet.name = spriteSheetName;

                                int    spriteIndex;
                                string spriteName, spriteType;
                                // loop through the sprite sheet specifications
                                for (int i = 0; i < numberOfSprites; i++)
                                {
                                    // obtain the 3 specifications for the current sprite (index, name, type)
                                    for (int j = 0; j < 3; j++)
                                    {
                                        spriteAttributes.add(Variable.parseFrom(instream.ReadLine()));
                                    }

                                    // get the sprite index and verify it
                                    try { spriteIndex = int.Parse(spriteAttributes.getValue("Sprite")); }
                                    catch (Exception) { return(null); }
                                    if (spriteIndex < 0 || spriteIndex >= spriteSheet.size())
                                    {
                                        return(null);
                                    }

                                    // get the sprite name
                                    spriteName = spriteAttributes.getValue("Name");
                                    if (spriteName == null)
                                    {
                                        return(null);
                                    }

                                    // get the sprite type (as a string)
                                    spriteType = spriteAttributes.getValue("Type");
                                    if (spriteType == null)
                                    {
                                        return(null);
                                    }

                                    // assign the attributes to the corresponding sprite
                                    spriteSheet.getSprite(spriteIndex).name       = spriteName;
                                    spriteSheet.getSprite(spriteIndex).index      = spriteIndex;
                                    spriteSheet.getSprite(spriteIndex).parentName = spriteSheetName;
                                    spriteSheet.getSprite(spriteIndex).type       = Sprite.parseType(spriteType);

                                    // clear the list of attributes presently associated with the current sprite
                                    spriteAttributes.clear();
                                }
                            }

                            // ===============================================================================
                            // Multiple Grids SpriteSheet ====================================================
                            // ===============================================================================
                            else if (spriteSheetType == SpriteSheetType.MultipleGrids)
                            {
                                int numberOfGrids;
                                int spriteIndexOffset = 0;

                                // verify that the number of grids to parse is specified and valid
                                try { numberOfGrids = int.Parse(v.value); }
                                catch (Exception) { return(null); }
                                if (numberOfGrids < 1)
                                {
                                    return(null);
                                }

                                // create an empty sprite sheet
                                spriteSheet       = new SpriteSheet();
                                spriteSheet.name  = spriteSheetName;
                                spriteSheet.image = spriteSheetImage;

                                // temporary storage
                                VariableSystem gridAttributes  = new VariableSystem();
                                int[]          numberOfSprites = new int[numberOfGrids];
                                Rectangle[]    grid            = new Rectangle[numberOfGrids];
                                Axis[]         direction       = new Axis[numberOfGrids];
                                int[]          numberOfRows    = new int[numberOfGrids];
                                int[]          numberOfColumns = new int[numberOfGrids];
                                for (int i = 0; i < numberOfGrids; i++)
                                {
                                    numberOfSprites[i] = -1;
                                    grid[i]            = new Rectangle(0, 0, 0, 0);
                                    direction[i]       = Axis.Horizontal;
                                    numberOfRows[i]    = -1;
                                    numberOfColumns[i] = -1;
                                }

                                // loop through all of the grids
                                for (int i = 0; i < numberOfGrids; i++)
                                {
                                    // obtain the 7 attributes for each grid (index, offset, size, parse direction, number of rows, number of columns, number of sprite attributes)
                                    for (int j = 0; j < 7; j++)
                                    {
                                        gridAttributes.add(Variable.parseFrom(instream.ReadLine()));
                                    }

                                    // get the index of the current grid
                                    int gridIndex;
                                    try { gridIndex = int.Parse(gridAttributes.getValue("Grid")); }
                                    catch (Exception) { return(null); }
                                    if (gridIndex < 0 || gridIndex >= numberOfGrids)
                                    {
                                        return(null);
                                    }

                                    // get the number of sprites within the current grid and validate it
                                    try { numberOfSprites[gridIndex] = int.Parse(gridAttributes.getValue("Number of Sprites")); }
                                    catch (Exception) { return(null); }

                                    // get the offset of the current grid
                                    string temp = gridAttributes.getValue("Pixel Offset");
                                    if (temp == null)
                                    {
                                        return(null);
                                    }
                                    string[] offsetValues = temp.Split(',');
                                    if (offsetValues.Length != 2)
                                    {
                                        return(null);
                                    }

                                    // get the size of each cell within the current grid
                                    temp = gridAttributes.getValue("Size");
                                    if (temp == null)
                                    {
                                        return(null);
                                    }
                                    string[] sizeValues = temp.Split(',');
                                    if (sizeValues.Length != 2)
                                    {
                                        return(null);
                                    }

                                    // create a rectangle representing the first cell in the current grid
                                    try { grid[gridIndex] = new Rectangle(int.Parse(offsetValues[0]),
                                                                          int.Parse(offsetValues[1]),
                                                                          int.Parse(sizeValues[0]),
                                                                          int.Parse(sizeValues[1])); }
                                    catch (Exception) { return(null); }

                                    // obtain the direction in which to parse the sprites from the current sprite sheet grid
                                    direction[gridIndex] = parseAxis(gridAttributes.getValue("Direction"));

                                    // get the number of rows in the current grid
                                    try { numberOfRows[gridIndex] = int.Parse(gridAttributes.getValue("Number of Rows")); }
                                    catch (Exception) { return(null); }

                                    // get the number of columns in the current grid
                                    try { numberOfColumns[gridIndex] = int.Parse(gridAttributes.getValue("Number of Columns")); }
                                    catch (Exception) { return(null); }

                                    // start parsing at the initial offset
                                    // loop through all of the rows and columns incrementing the x position and y position as appropriate
                                    // parse each sprite according to the current offset and size and store it in the main sprite collection
                                    int xPos = grid[gridIndex].X;
                                    int yPos = grid[gridIndex].Y;
                                    for (int j = 0; j < numberOfRows[gridIndex]; j++)
                                    {
                                        for (int k = 0; k < numberOfColumns[gridIndex]; k++)
                                        {
                                            spriteSheet.addSprite(new Sprite(spriteSheetImage, new Rectangle(xPos, yPos, grid[gridIndex].Width, grid[gridIndex].Height)));
                                            if (direction[gridIndex] == Axis.Horizontal)
                                            {
                                                xPos += grid[gridIndex].Width + 2;
                                            }
                                            else
                                            {
                                                yPos += grid[gridIndex].Height + 2;
                                            }
                                        }
                                        if (direction[gridIndex] == Axis.Horizontal)
                                        {
                                            yPos += grid[gridIndex].Height + 2; xPos = grid[gridIndex].X;
                                        }
                                        else
                                        {
                                            xPos += grid[gridIndex].Width + 2; yPos = grid[gridIndex].Y;
                                        }
                                    }

                                    int            spriteIndex;
                                    string         spriteName, spriteType;
                                    VariableSystem spriteAttributes = new VariableSystem();
                                    // loop through the sprite attribute specifications for the current grid
                                    for (int j = 0; j < numberOfSprites[gridIndex]; j++)
                                    {
                                        // read in the 3 sprite attributes (index, name, type) and store them
                                        for (int k = 0; k < 3; k++)
                                        {
                                            spriteAttributes.add(Variable.parseFrom(instream.ReadLine()));
                                        }

                                        // get the sprite index and validate it
                                        try { spriteIndex = spriteIndexOffset + int.Parse(spriteAttributes.getValue("Sprite")); }
                                        catch (Exception) { return(null); }
                                        if (spriteIndex < spriteIndexOffset || spriteIndex >= spriteSheet.size())
                                        {
                                            return(null);
                                        }

                                        // get the sprite name
                                        spriteName = spriteAttributes.getValue("Name");
                                        if (spriteName == null)
                                        {
                                            return(null);
                                        }

                                        // get the sprite type
                                        spriteType = spriteAttributes.getValue("Type");
                                        if (spriteType == null)
                                        {
                                            return(null);
                                        }

                                        // assign the current set of attributes to the corresponding sprite
                                        spriteSheet.getSprite(spriteIndex).name       = spriteName;
                                        spriteSheet.getSprite(spriteIndex).index      = spriteIndex;
                                        spriteSheet.getSprite(spriteIndex).parentName = spriteSheetName;
                                        spriteSheet.getSprite(spriteIndex).type       = Sprite.parseType(spriteType);

                                        // clear the current collection of sprite attributes
                                        spriteAttributes.clear();
                                    }

                                    // clear the current collection of grid attributes and update the Sprite index offset (current position in the main SpriteSheet collection)
                                    gridAttributes.clear();
                                    spriteIndexOffset = spriteSheet.size();
                                }
                            }

                            // return null if sprite sheet type is invalid
                            else
                            {
                                return(null);
                            }

                            // return the current sprite sheet
                            return(spriteSheet);
                        }
                    }
                }
            }
            catch (Exception) { }

            return(null);
        }
Ejemplo n.º 6
0
        public static SpriteAnimation parseFrom(StreamReader input, SpriteSheetCollection spriteSheets)
        {
            if (input == null || spriteSheets == null)
            {
                return(null);
            }

            SpriteAnimation animation;
            VariableSystem  animationProperties = new VariableSystem();

            // store all of the animation properties
            String   data;
            Variable property;

            do
            {
                data = input.ReadLine();
                if (data == null)
                {
                    return(null);
                }

                data = data.Trim();
                if (data.Length == 0)
                {
                    continue;
                }

                property = Variable.parseFrom(data);
                if (property == null)
                {
                    return(null);
                }

                animationProperties.add(property);
            } while(animationProperties.size() < 7);

            // parse the animation name
            String animationName = animationProperties.getValue("Animation Name");

            if (animationName == null)
            {
                return(null);
            }

            // parse the animation type
            SpriteAnimationType animationType = parseType(animationProperties.getValue("Animation Type"));

            if (animationType == SpriteAnimationType.Invalid)
            {
                return(null);
            }

            // parse the duration of the animation
            float duration;

            try {
                duration = float.Parse(animationProperties.getValue("Animation Duration"));
            }
            catch (Exception) { return(null); }
            if (duration <= 0)
            {
                return(null);
            }

            // parse the number of frames in the animation
            int numberOfFrames;

            try {
                numberOfFrames = int.Parse(animationProperties.getValue("Number of Frames"));
            }
            catch (Exception) { return(null); }
            if (numberOfFrames <= 0)
            {
                return(null);
            }

            // get the sprite sheet name
            String spriteSheetName = animationProperties.getValue("SpriteSheet Name");

            if (spriteSheetName == null)
            {
                return(null);
            }

            // get the sprite name
            String spriteName = animationProperties.getValue("Sprite Name");

            if (spriteName == null)
            {
                return(null);
            }

            string startIndex  = animationProperties.getValue("Start Index");
            int    iStartIndex = 1;

            if (startIndex != null)
            {
                iStartIndex = int.Parse(startIndex);
            }

            animation = new SpriteAnimation(animationName, duration, animationType);

            // get the sprite sheet which contains the animation
            SpriteSheet spriteSheet = spriteSheets.getSpriteSheet(spriteSheetName);

            if (spriteSheet == null)
            {
                return(null);
            }

            // obtain and add the sprites to the sprite animation
            Sprite sprite;

            for (int i = 0; i < numberOfFrames; i++)
            {
                sprite = spriteSheet.getSprite(spriteName + " " + (i + iStartIndex));
                if (sprite == null)
                {
                    return(null);
                }

                animation.addSprite(sprite);
            }

            return(animation);
        }