public Cluster CreateCluster(int clusterX, int clusterY)
{
Cluster cluster = new Cluster(ClusterType.Evergreen, clusterX, clusterY);
for (int y = 0; y < Constants.ClusterHeight; ++y)
{
for (int x = 0; x < Constants.ClusterWidth; ++x)
{
Vector2 tilePos = new Vector2(
x - Constants.ClusterWidth / 2,
y - Constants.ClusterHeight / 2
);
Tile t = cluster.GetTileAt(x, y);
if ((x == 0 || x == Constants.ClusterWidth - 1) ||
(y == 0 || y == Constants.ClusterHeight - 1))
{
t.Type = TileType.Grass;
}
else
{
t.Type = TileType.Water;
}
//t.Type = (TileType)(rand.Next() % 2 + 1);
cluster.SetTileAt(x, y, t);
}
}
return cluster;
}
/// <summary>
/// Adds a cluster to the Worlds cluster list and sorts the list.
/// </summary>
/// <param name="x"></param>
/// <param name="y"></param>
public void AddCluster(Cluster cluster)
{
if (insertIndex == clusters.Length)
{
GrowClusterBuffer(ref clusters, 10);
}
cluster.SetHashCode();
clusters[insertIndex++] = cluster;
isSorted = false;
}
public void InsertCluster(Cluster data)
{
long hashcode = Cluster.GetHashFromXY(data.Coordinates.X, data.Coordinates.Y);
if (base.Select(string.Format(
"SELECT hashcode FROM clusters WHERE hashcode={0};", hashcode
)
).Rows.Count != 0)
{
throw new DataException(string.Format(
"Cluster with id --> {0} <-- already exists in database.",
hashcode
)
);
}
string sql = string.Format(
"INSERT INTO clusters(hashcode, data) VALUES({0}, @data);",
hashcode
);
AddToCommandHistory(sql);
byte[] bytes = data.GetClusterBytes();
//using (MemoryStream memStream = new MemoryStream())
//{
// serializer.Serialize(memStream, data);
// memStream.Close();
// bytes = memStream.GetBuffer();
//}
base.Connection.Open();
using (SQLiteCommand cmd = new SQLiteCommand(base.Connection))
{
cmd.CommandText = sql;
cmd.Parameters.Add(
"@data", DbType.Binary, bytes.Length
).Value = bytes;
cmd.ExecuteNonQuery();
}
base.Connection.Close();
}
// TODO(Martin): Move to world manager
public EntityManager(Cluster cluster)
{
parent = cluster;
entities = new List<Entity>();
}
/// <summary>
/// Insert a cluster at the given coordinates in cluster space.
/// </summary>
/// <param name="clusterCoordinates"></param>
private static void AddCluster(World world, Coordinates clusterCoordinates)
{
Cluster cluster = new Cluster(ClusterType.Evergreen, clusterCoordinates);
Matrix clusterOffset = Matrix.CreateTranslation(new Vector3(-0.5f, -0.5f, 0));
Matrix tileTranslate =
/*TilePositionTransform **/
TileClusterTransform *
clusterOffset *
ClusterTileTransform
;
for (int y = 0; y < Constants.ClusterHeight; ++y)
{
for (int x = 0; x < Constants.ClusterWidth; ++x)
{
Vector2 tilePos = Vector2.Transform(new Vector2(x, y), tileTranslate);
Tile t = cluster.GetTileAt(x, y);
t.Type = TileType.Grass;
cluster.SetTileAt(x, y, t);
}
}
world.AddCluster(cluster);
}
/// <summary>
/// Retrieves the bounding rectangle for a cluster in pixels.
/// </summary>
/// <param name="cluster">Cluster to get bounds from.</param>
public static Rectangle GetClusterBounds(Cluster cluster)
{
// Creates cluster edges with clockwise winding.
Vector2[] vertices = new[] {
new Vector2(-0.5f, -0.5f), // Top Left
new Vector2(0.5f, -0.5f), // Top Right
new Vector2(0.5f, 0.5f), // Bottom Right
new Vector2(-0.5f, 0.5f) // Bottom Left
};
// Matrix for translating into tilespace and then scaling to screen.
// Matrix mat = ClusterTileTransform * TileScreenTransform;
/* Translate all vertices to the correct cluster and transform
* into pixel coordinates. */
for (int i = 0; i < vertices.Length; ++i)
{
vertices[i] += cluster.Coordinates;
vertices[i] = WorldManager.GetClusterScreenCenter(vertices[i]);
//vertices[i] = Vector2.Transform(vertices[i], mat);
}
// Bounding Rectangle.
Rectangle rect = new Rectangle(
(int)vertices[0].X,
(int)vertices[0].Y,
(int)(vertices[1].X - vertices[0].X),
(int)(vertices[2].Y - vertices[1].Y)
);
return rect;
}
public void UnloadCluster(Cluster cluster)
{
if(cluster == null)
{
throw new Exception("Unloading null cluster!");
}
unloadList.Add(cluster);
if (loadList.Exists(delegate(Coordinates c) { return c == cluster.Coordinates; }))
{
loadList.Remove(cluster.Coordinates);
}
if(unloadList.Count > UnloadWaitLimit &&
unloadThread.IsAlive == false)
{
StartUnloading();
}
}
// TEST METHOD
private bool TestClusterRange(Cluster cluster)
{
Vector2 camCluster = WorldManager.TransformScreenToCluster(Camera2D.Position);
if (Convert.ToInt32(Math.Abs(cluster.Coordinates.X - camCluster.X)) > 2 ||
Convert.ToInt32(Math.Abs(cluster.Coordinates.Y - camCluster.Y)) > 2)
{
return false;
}
return true;
}
public static void GrowClusterBuffer(ref Cluster[] clusters, int amount)
{
Array.Resize<Cluster>(ref clusters, clusters.Length + amount);
}
/// <summary>
/// Determines if a given cluster is in view.
/// </summary>
/// <param name="cluster">The cluster to investigate.</param>
private bool IsInView(Cluster cluster)
{
return IsInView(cluster.Coordinates);
}
private void ClusterUnloadedHandler(Cluster cluster)
{
if (GetCluster(cluster.Coordinates.X, cluster.Coordinates.Y) != null)
{
return;
}
}
private void ClusterLoadedHandler(Cluster cluster)
{
if (BinaryClusterSearch(clusters, 0, insertIndex, cluster.HashCode) == null)
{
loadedClusters.Push(cluster);
}
}
/// <summary>
/// Sorts an array of cluster(ideally the buffer of a world) recursively
/// by their hash values through the Quicksort algorithm.
/// </summary>
/// <param name="array">Array to sort.</param>
/// <param name="pivot">Array index to begin lookup.</param>
private static Cluster[] QuickSortClusters(Cluster[] array, int pivot)
{
/* If the input array size is two or less, the sorting is done.
* the one exception is when an unsorted array with the size of two is
* given as an input parameter.
* TODO(Peter): Handle this edge-case.*/
if (array.Length <= 2)
{
return array;
}
/* Create two arrays of max value since the worst case scenario
* could allow for all numbers to be either greater or less than the pivot. */
Cluster[] less = new Cluster[array.Length];
Cluster[] more = new Cluster[array.Length];
// Index for less array
int lessIndex = 0;
// Index for more array
int moreIndex = 0;
for (int i = 0; i < array.Length; ++i)
{
// Skip the pivot as it will be appended to the less array.
if (i == pivot)
{
continue;
}
/* Null clusters are considered as 'more' than any cluster
* that actually exists as we want them in the end of the array. */
if (array[i] == null)
{
more[moreIndex++] = array[i];
}
// Like above, if the pivot is null, all clusters are less than the pivot.
else if (array[pivot] == null || array[i].HashCode < array[pivot].HashCode)
{
less[lessIndex++] = array[i];
}
else if (array[i].HashCode > array[pivot].HashCode)
{
more[moreIndex++] = array[i];
}
}
// Append the pivot to the less list.
less[lessIndex++] = array[pivot];
// Resize arrays to remove the extra allocated space.
Array.Resize(ref less, lessIndex);
Array.Resize(ref more, moreIndex);
// Sort the less segment recursively.
QuickSortClusters(less, lessIndex / 2);
// Sort the more segment recursively.
QuickSortClusters(more, moreIndex / 2);
// Re-assign with the two now sorted segments.
int arrIndex = 0;
for (int i = 0; i < less.Length; ++i, arrIndex++)
{
array[arrIndex] = less[i];
}
for (int i = 0; i < more.Length; ++i, arrIndex++)
{
array[arrIndex] = more[i];
}
return array;
}
/// <summary>
/// Finds a cluster in the cluster buffer through binary search.
/// </summary>
/// <param name="clusters">The list of clusters to search.</param>
/// <param name="start">Index to start search from.</param>
/// <param name="length">Distance to search.</param>
/// <param name="hashkey">The cluster hash key to look for.</param>
/// <returns>The cluster if present.</returns>
private static Cluster BinaryClusterSearch(Cluster[] clusters,
int start, int length, long hashkey)
{
int center = start + length / 2;
// Not found condition.
if (clusters[center] == null || clusters[center].HashCode != hashkey && length == 1)
{
return null;
}
if (clusters[center].HashCode == hashkey)
{
return clusters[center];
}
else if (clusters[center].HashCode > hashkey)
{
return BinaryClusterSearch(clusters, start, length / 2, hashkey);
}
else
{
return BinaryClusterSearch(
clusters,
center,
(length + start) - center,
hashkey
);
}
}