public void ReturnChunkObjectsToPool(TerrainChunk chunk, Transform chunkTransform)
{
if (!chunk.hasTrees)
{
return;
}
chunk.hasTrees = false;
// Reverse iteration through list because you are removing ojects from the parent terrain
for (int i = chunkTransform.childCount - 1; i >= 0; i--)
{
Transform treeTrans = chunkTransform.GetChild(i);
TreeTypes treeTypeToSpawn = TreeTypes.Low;
if (treeTrans.position.y < terrainGen.heightMapSettings.maxHeight * treeLowHeight)
{
treeTypeToSpawn = TreeTypes.Low;
}
else if (treeTrans.position.y < terrainGen.heightMapSettings.maxHeight * treeMidHeight)
{
treeTypeToSpawn = TreeTypes.Mid;
}
else
{
treeTypeToSpawn = TreeTypes.High;
}
ReturnTreeToPool(treeTrans.gameObject, treeTypeToSpawn);
}
}
public GameObject GetTree(TreeTypes treeLevel)
{
GameObject treeObject = null;
Material spawnMaterial = lowMaterial;
switch (treeLevel)
{
case TreeTypes.Low:
treeObject = unusedLowTreesPool.GetChild(UnityEngine.Random.Range(0, unusedLowTreesPool.childCount - 1)).gameObject;
spawnMaterial = lowMaterial;
break;
case TreeTypes.Mid:
treeObject = unusedMidTreesPool.GetChild(UnityEngine.Random.Range(0, unusedMidTreesPool.childCount - 1)).gameObject;
spawnMaterial = midMaterial;
break;
case TreeTypes.High:
treeObject = unusedHighTreesPool.GetChild(UnityEngine.Random.Range(0, unusedHighTreesPool.childCount - 1)).gameObject;
spawnMaterial = highMaterial;
break;
}
foreach (Renderer renderer in treeObject.GetComponentsInChildren <Renderer>())
{
renderer.material = spawnMaterial;
}
// Return tree with proper material attached to it
return(treeObject);
}
public void BuildChunkTreesFromPoints(TerrainChunk chunk, List <Vector2> treePoints)
{
if (chunk.hasTrees)
{
return;
}
float newSizeX = chunk.bounds.size.x / regionSize.x;
float newSizeY = chunk.bounds.size.y / regionSize.y;
foreach (Vector2 point in treePoints)
{
RaycastHit raycastHit;
// Fire a ray going down
// multiply by 0.45f to allow some buffer space between chunks
if (Physics.Raycast((new Vector3(chunk.chunkPosition.x, 0f, chunk.chunkPosition.y) + new Vector3(offset.x * newSizeX, 0, offset.y * newSizeY)
+ (new Vector3(point.x * newSizeX, chunk.meshObject.transform.position.y + 300, point.y * newSizeY) - new Vector3(chunk.bounds.size.x / 2, 0, chunk.bounds.size.y / 2)) * fillPercent), new Vector3(0, -1, 0), out raycastHit))
{
//Debug.DrawRay(new Vector3(chunk.chunkPosition.x + point.x, 200, chunk.chunkPosition.y + point.y), new Vector3(0, -1, 0));
// If it collides with a terrainChunk
if (raycastHit.transform.CompareTag(GameConstants.TerrainChunkTag))
{
TreeTypes treeTypeToSpawn = TreeTypes.Low;
if (raycastHit.point.y < terrainGen.heightMapSettings.maxHeight * treeLowHeight)
{
treeTypeToSpawn = TreeTypes.Low;
}
else if (raycastHit.point.y < terrainGen.heightMapSettings.maxHeight * treeMidHeight)
{
treeTypeToSpawn = TreeTypes.Mid;
}
else
{
treeTypeToSpawn = TreeTypes.High;
}
GameObject newTree = GetTree(treeTypeToSpawn);
newTree.transform.SetParent(raycastHit.collider.transform);
newTree.transform.position = raycastHit.point;
newTree.SetActive(true);
//GameObject.Instantiate(spawnObjectPrefab, raycastHit.point, Quaternion.identity, raycastHit.collider.transform);
}
}
}
chunk.hasTrees = true;
}
// Returning Trees to pool
public void ReturnTreeToPool(GameObject treeToStore, TreeTypes treeType)
{
treeToStore.SetActive(false);
if (treeType == TreeTypes.Low)
{
treeToStore.transform.SetParent(unusedLowTreesPool);
}
else if (treeType == TreeTypes.Mid)
{
treeToStore.transform.SetParent(unusedMidTreesPool);
}
else if (treeType == TreeTypes.High)
{
treeToStore.transform.SetParent(unusedHighTreesPool);
}
treeToStore.transform.localScale = Vector3.one;
treeToStore.transform.position = Vector3.zero;
}
public override bool TryAdvanceStage(IGrowableBlock block, byte currentStageIndex)
{
Logger.Log("{0} TryAdvanceStage", filename);
Vector3Int pos = block.Position;
TreeTypes.GrowTreeOfType(TreeTypes.ETreeType.Taiga, pos);
// if (currentStageIndex == 0 && pos.IsValid) {
// for (int i = 0; i < logs.Count; i++) {
// ushort currentType;
// if (World.TryGetTypeAt(pos + logs[i], out currentType)) {
// if (currentType == 0 || currentType == saplingIndex) {
// if (!ServerManager.TryChangeBlock(pos + logs[i], logIndex)) {
// return false; // not loaded
// }
// }
// } else {
// return false; // not loaded
// }
// }
// for (int i = 0; i < leaves.Count; i++) {
// ushort currentType;
// if (World.TryGetTypeAt(pos + leaves[i], out currentType)) {
// if (currentType == 0) {
// if (!ServerManager.TryChangeBlock(pos + leaves[i], leavesIndex)) {
// return false; // not loaded
// }
// }
// } else {
// return false; // not loaded
// }
// }
//}
// succesfully grew, or invalid stage index. Either case, done.
block.SetInvalid();
return(true);
}
public void SetTreeType(int treetypeInt)
{
SelectedTreeType = (TreeTypes)treetypeInt;
loadAssets();
}
public string BuildTree <T>(TagBuilder html, Controller controller, T node, TreeTypes treeType) where T : INestedTreeNode <T>
{
var table = new TagBuilder("table");
table.Attributes.Add("cellpadding", "0");
table.Attributes.Add("cellspacing", "0");
table.Attributes.Add("border", "0");
table.Attributes.Add("width", "100%");
var tbody = new TagBuilder("tbody");
var tr = new TagBuilder("tr");
tr.AddCssClass("node-cells");
var td = new TagBuilder("td");
td.AddCssClass("node-cell");
if (node.Children.Count <= 1)
{
td.Attributes.Add("colspan", "2");
}
else
{
td.Attributes.Add("colspan", (node.Children.Count * 2).ToString());
}
// Node HTML
if (treeType == TreeTypes.Unilevel)
{
td.InnerHtml += controller.RenderPartialViewToString("UnilevelTreeNode", node);
}
else
{
td.InnerHtml += controller.RenderPartialViewToString("BinaryTreeNode", node);
}
NodeCounter++;
tr.InnerHtml = td.ToString();
tbody.InnerHtml = tr.ToString();
if (node.Children.Count > 0)
{
var downlineTr = new TagBuilder("tr");
var downlineTd = new TagBuilder("td");
downlineTd.Attributes.Add("colspan", (node.Children.Count * 2).ToString());
var nullNodeClass = (node.IsOpenPosition || node.IsNullPosition) ? "null-node" : "";
// Draw the connecting line from the parent node to the horizontal line
var verticalLine = new TagBuilder("div");
verticalLine.AddCssClass("line down");
verticalLine.AddCssClass(nullNodeClass);
downlineTd.InnerHtml += verticalLine.ToString();
downlineTr.InnerHtml += downlineTd.ToString();
tbody.InnerHtml += downlineTr.ToString();
// Draw the horizontal lines
var linesTr = new TagBuilder("tr");
var horizontalLineCounter = 0;
var maxHorizontalLines = node.Children.Count - 1;
foreach (var child in node.Children)
{
var leftLine = new TagBuilder("td");
leftLine.AddCssClass("line left");
leftLine.AddCssClass(nullNodeClass);
if (horizontalLineCounter > 0)
{
leftLine.AddCssClass("top");
}
linesTr.InnerHtml += leftLine.ToString();
var rightLine = new TagBuilder("td");
rightLine.AddCssClass("line right");
rightLine.AddCssClass(nullNodeClass);
if (horizontalLineCounter < maxHorizontalLines)
{
rightLine.AddCssClass("top");
}
linesTr.InnerHtml += rightLine.ToString();
horizontalLineCounter++;
}
;
// Horizontal line shouldn't extend beyond the first and last child branches
tbody.InnerHtml += linesTr.ToString();
var childNodesTr = new TagBuilder("tr");
foreach (var childNode in node.Children)
{
var childNodeTd = new TagBuilder("td");
childNodeTd.AddCssClass("node-container");
childNodeTd.AddCssClass(nullNodeClass);
childNodeTd.Attributes.Add("colspan", "2");
// Build recursively
BuildTree(childNodeTd, controller, childNode, treeType);
childNodesTr.InnerHtml += childNodeTd.ToString();
}
tbody.InnerHtml += childNodesTr.ToString();
}
table.InnerHtml += tbody.ToString();
html.InnerHtml += table.ToString();
return(html.ToString());
}
