public TileGrid(Tile[,] tiles)
{
tiles_ = tiles;
width_ = tiles.GetLength(1);
height_ = tiles.GetLength(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_;
}
/// <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;
}