예제 #1
0
        /// <summary>
        /// Performs several functions to prepare a Level for the Gameplay state,
        /// including setting up the WorldState, TileGrid, determining cover positions,
        /// adding objects to the collision detector, etc.
        /// </summary>
        public void initializeForGameplay()
        {
            Tile[,] tilesForCollisionGeneration = new Tile[getHeight(), getWidth()];
            for (int i = 0; i < getHeight(); i++)
            {
                for (int j = 0; j < getWidth(); j++)
                {
                    Height h = tileSet_.getHeight(tiles_[i, j]);

                    if (h.blocksHigh_)
                    {
                        tilesForCollisionGeneration[i, j].highDistance_ = 0f;
                    }
                    else
                    {
                        tilesForCollisionGeneration[i, j].highDistance_ = 1f;
                    }

                    if (h.blocksLow_)
                    {
                        tilesForCollisionGeneration[i, j].lowDistance_ = 0f;
                    }
                    else
                    {
                        tilesForCollisionGeneration[i, j].lowDistance_ = 1f;
                    }
                }
            }
            List<BoxObject> boxesToBeAddedForReal = Tiler.mergeBoxes(tilesForCollisionGeneration);

            // Calculate distances from walls to each tile
            Tile[,] tilesForGrid = CoverGenerator.generateRealTileDistances(tilesForCollisionGeneration);
            if (Settings.getInstance().IsInDebugMode_)
            {
                for (int i = 0; i < tilesForGrid.GetLength(0); i++)
                {
                    for (int j = 0; j < tilesForGrid.GetLength(1); j++)
                    {
                        Console.Write(tilesForGrid[i, j].highDistance_.ToString("F1"));
                        Console.Write(" ");
                    }
                    Console.WriteLine();
                }
            }
            GlobalHelper.getInstance().setCurrentLevelTileGrid(new TileGrid(tilesForGrid));

            // Generate cover objects and add them to collision detection
            List<CoverObject> coverObjects = CoverGenerator.generateCoverObjects(tilesForGrid);
            for (int i = 0; i < boxesToBeAddedForReal.Count; i++)
            {
                CollisionDetector_.register(boxesToBeAddedForReal[i]);
            }

            // Add other entities to collision detection and WorldState
            for (int i = 0; i < getEnemies().Count; i++)
            {
                getEnemies()[i].setCollisionDetector(CollisionDetector_);
            }
            for (int i = 0; i < getItems().Count; i++)
            {
                getItems()[i].setCollisionDetector(CollisionDetector_);
                if (getItems()[i] is AmmoBox)
                    WorldState.AmmoList_.Add(getItems()[i] as AmmoBox);
            }
            for (int i = 0; i < coverObjects.Count; i++)
            {
                coverObjects[i].setCollisionDetector(CollisionDetector_);
                WorldState.CoverList_.Add(coverObjects[i]);
            }
            List<CharacterAbstract> characterList = new List<CharacterAbstract>();
            for (int i = 0; i < getEnemies().Count; i++)
            {
                characterList.Add(getEnemies()[i]);
            }
            if (player_ != null)
            {
                characterList.Add(player_);
            }
            WorldState.CharacterList_ = characterList;
        }
예제 #2
0
 protected static bool collision(Tile tile)
 {
     return tile.collides(searchHeight_, searchRadius_);
 }
예제 #3
0
        public void initializeForEditor()
        {
            Tile[,] tilesForCollisionGeneration = new Tile[getHeight(), getWidth()];
            for (int i = 0; i < getHeight(); i++)
            {
                for (int j = 0; j < getWidth(); j++)
                {
                    Height h = tileSet_.getHeight(tiles_[i, j]);

                    if (h.blocksHigh_)
                    {
                        tilesForCollisionGeneration[i, j].highDistance_ = 0f;
                    }
                    else
                    {
                        tilesForCollisionGeneration[i, j].highDistance_ = 1f;
                    }

                    if (h.blocksLow_)
                    {
                        tilesForCollisionGeneration[i, j].lowDistance_ = 0f;
                    }
                    else
                    {
                        tilesForCollisionGeneration[i, j].lowDistance_ = 1f;
                    }
                }
            }
            List<BoxObject> boxesToBeAddedForReal = Tiler.mergeBoxes(tilesForCollisionGeneration);

            // Calculate distances from walls to each tile
            Tile[,] tilesForGrid = CoverGenerator.generateRealTileDistances(tilesForCollisionGeneration);
            if (Settings.getInstance().IsInDebugMode_)
            {
                for (int i = 0; i < tilesForGrid.GetLength(0); i++)
                {
                    for (int j = 0; j < tilesForGrid.GetLength(1); j++)
                    {
                        Console.Write(tilesForGrid[i, j].highDistance_.ToString("F1"));
                        Console.Write(" ");
                    }
                    Console.WriteLine();
                }
            }
            GlobalHelper.getInstance().setCurrentLevelTileGrid(new TileGrid(tilesForGrid));

            // Generate cover objects and add them to collision detection
        }
예제 #4
0
        public static List<CoverObject> generateCoverObjects(Tile[,] tiles)
        {
            List<CoverObject> returnList = new List<CoverObject>();
            newTiles_ = tiles;

            for (int i = 0; i < newTiles_.GetLength(0); i++)
            {
                for (int j = 0; j < newTiles_.GetLength(1); j++)
                {
                    //Are we on an edge
                    if (get(j, i, HeightEnum.LOW) == 1f && get(j, i, HeightEnum.HIGH) > 0f)
                    {
                        // We're checking to make sure that this is the case:
                        //     >0  |       |   >0
                        //     ------------------
                        //     >0  |   j,i | 0, low only
                        //     ------------------
                        //         |   >0  | 0, low only
                        //
                        if (((get(j - 1, i - 1, HeightEnum.LOW) > 0f //Upper Left is not a wall
                                && get(j + 1, i - 1, HeightEnum.LOW) > 0f) //Upper Right not a wall
                            || ((get(j - 1, i - 1, HeightEnum.LOW) == 0f //Upper Left is a wall
                                && get(j + 1, i - 1, HeightEnum.LOW) == 0f) //Upper Right is a wall
                                && get(j, i - 1, HeightEnum.LOW) == 0f) //Top is a wall
                            )
                            && get(j - 1, i, HeightEnum.LOW) > 0f //Left is not a wall
                            && get(j, i + 1, HeightEnum.LOW) > 0f //Below is not a wall
                            && get(j + 1, i, HeightEnum.LOW) == 0f //Right is a wall
                            && get(j + 1, i + 1, HeightEnum.LOW) == 0f //Lower Right is a wall
                            && get(j + 1, i, HeightEnum.HIGH) > 0f //Right is not blocked high
                            && get(j + 1, i + 1, HeightEnum.HIGH) > 0f //Lower Right is not blocked high
                            )
                        {
                            //We are now sure that we need to start cover going down
                            CoverObject temp = genVerticalCoverObjectLeft(j, i);
                            if (temp != null)
                            {
                                returnList.Add(temp);
                            }
                        }
                        // We're checking to make sure that this is the case:
                        //     >0  |       |   >0
                        //     ------------------
                        //  0, low |   j,i |   >0
                        //     ------------------
                        //  0, low |   >0  |
                        //
                        else if (get(j - 1, i - 1, HeightEnum.LOW) > 0f //Upper Left is not a wall
                            && get(j + 1, i - 1, HeightEnum.LOW) > 0f //Upper Right not a wall
                            && get(j + 1, i, HeightEnum.LOW) > 0f //Right is not a wall
                            && get(j, i + 1, HeightEnum.LOW) > 0f //Below is not a wall
                            && get(j - 1, i, HeightEnum.LOW) == 0f //Left is a wall
                            && get(j - 1, i + 1, HeightEnum.LOW) == 0f //Lower Left is a wall
                            && get(j - 1, i, HeightEnum.HIGH) > 0f //Left is not blocked high
                            && get(j - 1, i + 1, HeightEnum.HIGH) > 0f //Lower Left is not blocked high
                            )
                        {
                            //We are now sure that we need to start cover going down
                            CoverObject temp = genVerticalCoverObjectRight(j, i);
                            if (temp != null)
                            {
                                returnList.Add(temp);
                            }
                        }

                        // We're checking to make sure that this is the case:
                        //     >0  | 0, l  | 0, low only
                        //     ------------------
                        //         |   j,i | >0
                        //     ------------------
                        //     >0  |   >0  |
                        //
                        if (((get(j - 1, i - 1, HeightEnum.LOW) > 0f //Upper Left is not a wall
                                && get(j - 1, i + 1, HeightEnum.LOW) > 0f) //Lower Left not a wall
                            ||  ((get(j - 1, i + 1, HeightEnum.LOW) == 0f //Lower Left is a wall
                                && get(j - 1, i, HeightEnum.LOW) == 0f) //Left is a wall
                                && get(j - 1, i - 1, HeightEnum.LOW) == 0f) //Upper Left is a wall
                            )
                            && get(j, i + 1, HeightEnum.LOW) > 0f //Bottom is not a wall
                            && get(j + 1, i, HeightEnum.LOW) > 0f //Right is not a wall
                            && get(j, i - 1, HeightEnum.LOW) == 0f //Top is a wall
                            && get(j + 1, i - 1, HeightEnum.LOW) == 0f //Upper Right is a wall
                            && get(j, i - 1, HeightEnum.HIGH) > 0f //Top is not blocked high
                            && get(j + 1, i - 1, HeightEnum.HIGH) > 0f //Upper Right is not blocked high
                            )
                        {
                            //We are now sure that we need to start cover going right
                            CoverObject temp = genHorizontalCoverObjectBottom(j, i);
                            if (temp != null)
                            {
                                returnList.Add(temp);
                            }
                        }
                        // We're checking to make sure that this is the case:
                        //     >0  |  >0   |
                        //     ------------------
                        //         |   j,i | >0
                        //     ------------------
                        //     >0  | 0, l  | 0, low only
                        //
                        else if (((get(j - 1, i - 1, HeightEnum.LOW) > 0f //Upper Left is not a wall
                                    && get(j - 1, i + 1, HeightEnum.LOW) > 0f) //Lower Left not a wall
                                || ((get(j - 1, i + 1, HeightEnum.LOW) == 0f //Lower Left is a wall
                                    && get(j - 1, i, HeightEnum.LOW) == 0f) //Left is a wall
                                    && get(j - 1, i - 1, HeightEnum.LOW) == 0f) //Upper Left is a wall
                                )
                                && get(j, i - 1, HeightEnum.LOW) > 0f //Top is not a wall
                                && get(j + 1, i, HeightEnum.LOW) > 0f //Right is not a wall
                                && get(j, i + 1, HeightEnum.LOW) == 0f //Bottom is a wall
                                && get(j + 1, i + 1, HeightEnum.LOW) == 0f //Lower Right is a wall
                                && get(j, i + 1, HeightEnum.HIGH) > 0f //Bottom is not blocked high
                                && get(j + 1, i + 1, HeightEnum.HIGH) > 0f //Lower Right is not blocked high
                                )
                        {
                            //We are now sure that we need to start cover going right
                            CoverObject temp = genHorizontalCoverObjectTop(j, i);
                            if (temp != null)
                            {
                                returnList.Add(temp);
                            }
                        }
                    }
                }
            }
            return returnList;
        }
예제 #5
0
        /*
         * public static List<CoverObject> generateCoverObjects(Tile[,] tiles)
        {
            List<CoverObject> returnList = new List<CoverObject>();
            newTiles_ = tiles;

            for (int i = 0; i < newTiles_.GetLength(0); i++)
            {
                for (int j = 0; j < newTiles_.GetLength(1); j++)
                {
                    //Are we on an edge
                    if (get(j, i, HeightEnum.LOW) == 0.5f && get(j, i, HeightEnum.HIGH) > 0f)
                    {
                        /// We're checking to make sure that this is the case:
                        ///     >0  |       |   >0
                        ///     ------------------
                        ///     >0  |   j,i | 0, low only
                        ///     ------------------
                        ///         |   >0  | 0, low only
                        ///
                        if (((get(j - 1, i - 1, HeightEnum.LOW) > 0f //Upper Left is not a wall
                                && get(j + 1, i - 1, HeightEnum.LOW) > 0f) //Upper Right not a wall
                            || ((get(j - 1, i - 1, HeightEnum.LOW) == 0f //Upper Left is a wall
                                && get(j + 1, i - 1, HeightEnum.LOW) == 0f) //Upper Right is a wall
                                && get(j, i - 1, HeightEnum.LOW) == 0f) //Top is a wall
                            )
                            && get(j - 1, i, HeightEnum.LOW) > 0f //Left is not a wall
                            && get(j, i + 1, HeightEnum.LOW) > 0f //Below is not a wall
                            && get(j + 1, i, HeightEnum.LOW) == 0f //Right is a wall
                            && get(j + 1, i + 1, HeightEnum.LOW) == 0f //Lower Right is a wall
                            && get(j + 1, i, HeightEnum.HIGH) > 0f //Right is not blocked high
                            && get(j + 1, i + 1, HeightEnum.HIGH) > 0f //Lower Right is not blocked high
                            )
                        {
                            ///We are now sure that we need to start cover going down
                            CoverObject temp = genVerticalCoverObjectLeft(j, i);
                            if (temp != null)
                            {
                                returnList.Add(temp);
                            }
                        }
                        /// We're checking to make sure that this is the case:
                        ///     >0  |       |   >0
                        ///     ------------------
                        ///  0, low |   j,i |   >0
                        ///     ------------------
                        ///  0, low |   >0  |
                        ///
                        else if (get(j - 1, i - 1, HeightEnum.LOW) > 0f //Upper Left is not a wall
                            && get(j + 1, i - 1, HeightEnum.LOW) > 0f //Upper Right not a wall
                            && get(j + 1, i, HeightEnum.LOW) > 0f //Right is not a wall
                            && get(j, i + 1, HeightEnum.LOW) > 0f //Below is not a wall
                            && get(j - 1, i, HeightEnum.LOW) == 0f //Left is a wall
                            && get(j - 1, i + 1, HeightEnum.LOW) == 0f //Lower Left is a wall
                            && get(j - 1, i, HeightEnum.HIGH) > 0f //Left is not blocked high
                            && get(j - 1, i + 1, HeightEnum.HIGH) > 0f //Lower Left is not blocked high
                            )
                        {
                            ///We are now sure that we need to start cover going down
                            CoverObject temp = genVerticalCoverObjectRight(j, i);
                            if (temp != null)
                            {
                                returnList.Add(temp);
                            }
                        }

                        /// We're checking to make sure that this is the case:
                        ///     >0  | 0, l  | 0, low only
                        ///     ------------------
                        ///         |   j,i | >0
                        ///     ------------------
                        ///     >0  |   >0  |
                        ///
                        if (((get(j - 1, i - 1, HeightEnum.LOW) > 0f //Upper Left is not a wall
                                && get(j - 1, i + 1, HeightEnum.LOW) > 0f) //Lower Left not a wall
                            ||  ((get(j - 1, i + 1, HeightEnum.LOW) == 0f //Lower Left is a wall
                                && get(j - 1, i, HeightEnum.LOW) == 0f) //Left is a wall
                                && get(j - 1, i - 1, HeightEnum.LOW) == 0f) //Upper Left is a wall
                            )
                            && get(j, i + 1, HeightEnum.LOW) > 0f //Bottom is not a wall
                            && get(j + 1, i, HeightEnum.LOW) > 0f //Right is not a wall
                            && get(j, i - 1, HeightEnum.LOW) == 0f //Top is a wall
                            && get(j + 1, i - 1, HeightEnum.LOW) == 0f //Upper Right is a wall
                            && get(j, i - 1, HeightEnum.HIGH) > 0f //Top is not blocked high
                            && get(j + 1, i - 1, HeightEnum.HIGH) > 0f //Upper Right is not blocked high
                            )
                        {
                            ///We are now sure that we need to start cover going right
                            CoverObject temp = genHorizontalCoverObjectBottom(j, i);
                            if (temp != null)
                            {
                                returnList.Add(temp);
                            }
                        }
                        /// We're checking to make sure that this is the case:
                        ///     >0  |  >0   |
                        ///     ------------------
                        ///         |   j,i | >0
                        ///     ------------------
                        ///     >0  | 0, l  | 0, low only
                        ///
                        else if (((get(j - 1, i - 1, HeightEnum.LOW) > 0f //Upper Left is not a wall
                                    && get(j - 1, i + 1, HeightEnum.LOW) > 0f) //Lower Left not a wall
                                || ((get(j - 1, i + 1, HeightEnum.LOW) == 0f //Lower Left is a wall
                                    && get(j - 1, i, HeightEnum.LOW) == 0f) //Left is a wall
                                    && get(j - 1, i - 1, HeightEnum.LOW) == 0f) //Upper Left is a wall
                                )
                                && get(j, i - 1, HeightEnum.LOW) > 0f //Top is not a wall
                                && get(j + 1, i, HeightEnum.LOW) > 0f //Right is not a wall
                                && get(j, i + 1, HeightEnum.LOW) == 0f //Bottom is a wall
                                && get(j + 1, i + 1, HeightEnum.LOW) == 0f //Lower Right is a wall
                                && get(j, i + 1, HeightEnum.HIGH) > 0f //Bottom is not blocked high
                                && get(j + 1, i + 1, HeightEnum.HIGH) > 0f //Lower Right is not blocked high
                                )
                        {
                            ///We are now sure that we need to start cover going right
                            CoverObject temp = genHorizontalCoverObjectTop(j, i);
                            if (temp != null)
                            {
                                returnList.Add(temp);
                            }
                        }
                    }
                }
            }
            return returnList;
        }

        protected static CoverObject genVerticalCoverObjectLeft(int j, int i)
        {
            float top = (float)i * 15f;
            float bottom = (float)i * 15f;
            float rightEdge = (float)(j + 1) * 15f;
            float leftEdge = (float)(j - 1) * 15f;
            /// We're checking to make sure that this is the case:
            ///         |       |
            ///     ------------------
            ///     >0  |   j,i | 0
            ///     ------------------
            ///         |       |
            ///
            while (get(j, i, HeightEnum.LOW) == 0.5f
                    && get(j, i, HeightEnum.HIGH) > 0f
                    && get(j + 1, i, HeightEnum.LOW) == 0f
                    && get(j + 1, i, HeightEnum.HIGH) > 0f
                    && get(j - 1, i, HeightEnum.LOW) > 0f
                    )
            {
                bottom += 15f;
                i++;
            }
            if (bottom - top < 45f)
            {
                return null;
            }
            Vector2 position = new Vector2((rightEdge + leftEdge) / 2f, (bottom + top) / 2f);
            List<Vector2> bounds = new List<Vector2>();
            bounds.Add(new Vector2(leftEdge - position.X, top - position.Y));
            bounds.Add(new Vector2(rightEdge - position.X, top - position.Y));
            bounds.Add(new Vector2(rightEdge - position.X, bottom - position.Y));
            bounds.Add(new Vector2(leftEdge - position.X, bottom - position.Y));
            return new CoverObject(null, bounds, position, new Vector2(rightEdge, top), new Vector2(rightEdge, bottom));
        }

        protected static CoverObject genVerticalCoverObjectRight(int j, int i)
        {
            float top = (float)i * 15f;
            float bottom = (float)i * 15f;
            float rightEdge = (float)(j + 2) * 15f;
            float leftEdge = (float)j * 15f;
            /// We're checking to make sure that this is the case:
            ///         |       |
            ///     ------------------
            ///     0   |   j,i | >0
            ///     ------------------
            ///         |       |
            ///
            while (get(j, i, HeightEnum.LOW) == 0.5f
                    && get(j, i, HeightEnum.HIGH) > 0f
                    && get(j - 1, i, HeightEnum.LOW) == 0f
                    && get(j - 1, i, HeightEnum.HIGH) > 0f
                    && get(j + 1, i, HeightEnum.LOW) > 0f
                    )
            {
                bottom += 15f;
                i++;
            }
            if (bottom - top < 45f)
            {
                return null;
            }
            Vector2 position = new Vector2((rightEdge + leftEdge) / 2f, (bottom + top) / 2f);
            List<Vector2> bounds = new List<Vector2>();
            bounds.Add(new Vector2(leftEdge - position.X, top - position.Y));
            bounds.Add(new Vector2(rightEdge - position.X, top - position.Y));
            bounds.Add(new Vector2(rightEdge - position.X, bottom - position.Y));
            bounds.Add(new Vector2(leftEdge - position.X, bottom - position.Y));
            return new CoverObject(null, bounds, position, new Vector2(leftEdge, top), new Vector2(leftEdge, bottom));
        }

        protected static CoverObject genHorizontalCoverObjectTop(int j, int i)
        {
            float topEdge = (float)(i - 1) * 15f;
            float bottomEdge = (float)(i + 1) * 15f;
            float right = (float)j * 15f;
            float left = (float)j * 15f;
            /// We're checking to make sure that this is the case:
            ///         |   >0  |
            ///     ------------------
            ///         |   j,i |
            ///     ------------------
            ///         | 0, l  |
            ///
            while (get(j, i, HeightEnum.LOW) == 0.5f
                    && get(j, i, HeightEnum.HIGH) > 0f
                    && get(j, i + 1, HeightEnum.LOW) == 0f
                    && get(j, i + 1, HeightEnum.HIGH) > 0f
                    && get(j, i - 1, HeightEnum.LOW) > 0f
                    )
            {
                right += 15f;
                j++;
            }
            if (right - left < 45f)
            {
                return null;
            }
            Vector2 position = new Vector2((right + left) / 2f, (bottomEdge + topEdge) / 2f);
            List<Vector2> bounds = new List<Vector2>();
            bounds.Add(new Vector2(left - position.X, topEdge - position.Y));
            bounds.Add(new Vector2(right - position.X, topEdge - position.Y));
            bounds.Add(new Vector2(right - position.X, bottomEdge - position.Y));
            bounds.Add(new Vector2(left - position.X, bottomEdge - position.Y));
            return new CoverObject(null, bounds, position, new Vector2(left, topEdge), new Vector2(right, topEdge));
        }

        protected static CoverObject genHorizontalCoverObjectBottom(int j, int i)
        {
            float topEdge = (float)i * 15f;
            float bottomEdge = (float)(i + 2) * 15f;
            float right = (float)j * 15f;
            float left = (float)j * 15f;
            /// We're checking to make sure that this is the case:
            ///         |   0   |
            ///     ------------------
            ///         |   j,i |
            ///     ------------------
            ///         |   >0  |
            ///
            while (get(j, i, HeightEnum.LOW) == 0.5f
                    && get(j, i, HeightEnum.HIGH) > 0f
                    && get(j, i - 1, HeightEnum.LOW) == 0f
                    && get(j, i - 1, HeightEnum.HIGH) > 0f
                    && get(j, i + 1, HeightEnum.LOW) > 0f
                    )
            {
                right += 15f;
                j++;
            }
            if (right - left < 45f)
            {
                return null;
            }
            Vector2 position = new Vector2((right + left) / 2f, (bottomEdge + topEdge) / 2f);
            List<Vector2> bounds = new List<Vector2>();
            bounds.Add(new Vector2(left - position.X, topEdge - position.Y));
            bounds.Add(new Vector2(right - position.X, topEdge - position.Y));
            bounds.Add(new Vector2(right - position.X, bottomEdge - position.Y));
            bounds.Add(new Vector2(left - position.X, bottomEdge - position.Y));
            return new CoverObject(null, bounds, position, new Vector2(left, bottomEdge), new Vector2(right, bottomEdge));
        }

        */
        public static Tile[,] generateRealTileDistances(Tile[,] tiles)
        {
            oldTiles_ = tiles;
            newTiles_ = new Tile[tiles.GetLength(0), tiles.GetLength(1)];
            initialize();
            for (int i = 0; i < newTiles_.GetLength(0); i++)
            {
                for (int j = 0; j < newTiles_.GetLength(1); j++)
                {
                    set(j, i, HeightEnum.HIGH);
                    set(j, i, HeightEnum.LOW);
                }
            }
            return newTiles_;
        }
예제 #6
0
 public TileGrid(Tile[,] tiles)
 {
     tiles_ = tiles;
     width_ = tiles.GetLength(1);
     height_ = tiles.GetLength(0);
 }
예제 #7
0
 /// <summary>
 /// Generate a list of TileObjects from a two dimensional array of ints, where each 
 /// number in the array represents the type of tile to use at that cooridinate.
 /// </summary>
 /// <param name="pipeline">Drawing pipeline in which to register the object</param>
 /// <param name="tiles">Array of ints representing types of tiles</param>
 /// <returns>List of TileObjects</returns>
 /*        public static List<TileObject> getTiles(List<DrawableObjectAbstract> pipeline, int[,] tiles)
 {
     List<TileObject> retList = new List<TileObject>();
     for (int y = 0; y < tiles.GetLength(0); y++)
     {
         for (int x = 0; x < tiles.GetLength(1); x++)
         {
             retList.Add(new TileObject(tiles[y, x], pipeline, TextureMap.getInstance().getTexture("Tile_" + tiles[y, x]), new Vector2((float)x * tileSideLength_, (float)y * tileSideLength_), Vector2.Zero, 0.0f));
         }
     }
     return retList;
 }
  */
 public static List<BoxObject> mergeBoxes(Tile[,] boxes)
 {
     //List<List<BoxObject>> tempMergedBoxes = new List<List<BoxObject>>();
     List<List<int[]>> tempMergedDimsHigh = new List<List<int[]>>();
     List<List<int[]>> tempMergedDimsLow = new List<List<int[]>>();
     List<Vector2> tempPoints = new List<Vector2>();
     tempPoints.Add(new Vector2(-7.5f, -7.5f));
     tempPoints.Add(new Vector2(7.5f, -7.5f));
     tempPoints.Add(new Vector2(7.5f, 7.5f));
     tempPoints.Add(new Vector2(-7.5f, 7.5f));
     int[] tempSetHigh = new int[4];
     int[] tempSetLow = new int[4];
     bool startedHigh = false;
     bool startedLow = false;
     List<BoxObject> returnBoxes = new List<BoxObject>();
     for (int y = 0; y < boxes.GetLength(0); y++)
     {
         tempMergedDimsHigh.Add(new List<int[]>());
         tempMergedDimsLow.Add(new List<int[]>());
         for (int x = 0; x < boxes.GetLength(1); x++)
         {
             if (!startedHigh && boxes[y,x].highDistance_ == 0)
             {
                 startedHigh = true;
                 tempSetHigh[0] = x;
                 tempSetHigh[1] = y;
                 tempSetHigh[2] = x;
                 tempSetHigh[3] = y;
             }
             else if (startedHigh && boxes[y,x].highDistance_ == 0)
             {
                 tempSetHigh[2] = x;
             }
             else if (startedHigh && !(boxes[y,x].highDistance_ == 0))
             {
                 tempMergedDimsHigh[y].Add(tempSetHigh);
                 tempSetHigh = new int[4];
                 startedHigh = false;
             }
             if (!startedLow && boxes[y, x].lowDistance_ == 0)
             {
                 startedLow = true;
                 tempSetLow[0] = x;
                 tempSetLow[1] = y;
                 tempSetLow[2] = x;
                 tempSetLow[3] = y;
             }
             else if (startedLow && boxes[y, x].lowDistance_ == 0)
             {
                 tempSetLow[2] = x;
             }
             else if (startedLow && !(boxes[y, x].lowDistance_ == 0))
             {
                 tempMergedDimsLow[y].Add(tempSetLow);
                 tempSetLow = new int[4];
                 startedLow = false;
             }
         }
         if (startedHigh)
         {
             tempMergedDimsHigh[y].Add(tempSetHigh);
             tempSetHigh = new int[4];
             startedHigh = false;
         }
         if (startedLow)
         {
             tempMergedDimsLow[y].Add(tempSetLow);
             tempSetLow = new int[4];
             startedLow = false;
         }
     }
     for (int i = 0; i < boxes.GetLength(0); i++)
     {
         for (int j = tempMergedDimsHigh[i].Count - 1; j >= 0; j--)
         {
             bool finished = false;
             int[] tempCheckingSet = tempMergedDimsHigh[i][j];
             tempMergedDimsHigh[i].RemoveAt(j);
             for (int k = i + 1; k < boxes.GetLength(0); k++)
             {
                 finished = true;
                 for (int l = tempMergedDimsHigh[k].Count - 1; l >= 0; l--)
                 {
                     int[] temp = tempMergedDimsHigh[k][l];
                     if (temp[0] == tempCheckingSet[0] && temp[2] == tempCheckingSet[2])
                     {
                         tempCheckingSet[3] = temp[3];
                         finished = false;
                         tempMergedDimsHigh[k].RemoveAt(l);
                         break;
                     }
                 }
                 if (finished)
                 {
                     break;
                 }
             }
             returnBoxes.Add(createBox(tempCheckingSet[0], tempCheckingSet[1], tempCheckingSet[2], tempCheckingSet[3], HeightEnum.HIGH));
         }
         for (int j = tempMergedDimsLow[i].Count - 1; j >= 0; j--)
         {
             bool finished = false;
             int[] tempCheckingSet = tempMergedDimsLow[i][j];
             tempMergedDimsLow[i].RemoveAt(j);
             for (int k = i + 1; k < boxes.GetLength(0); k++)
             {
                 finished = true;
                 for (int l = tempMergedDimsLow[k].Count - 1; l >= 0; l--)
                 {
                     int[] temp = tempMergedDimsLow[k][l];
                     if (temp[0] == tempCheckingSet[0] && temp[2] == tempCheckingSet[2])
                     {
                         tempCheckingSet[3] = temp[3];
                         finished = false;
                         tempMergedDimsLow[k].RemoveAt(l);
                         break;
                     }
                 }
                 if (finished)
                 {
                     break;
                 }
             }
             returnBoxes.Add(createBox(tempCheckingSet[0], tempCheckingSet[1], tempCheckingSet[2], tempCheckingSet[3], HeightEnum.LOW));
         }
     }
     return returnBoxes;
 }