public static Vector3 AdjustPosition(Transform pars)
{
Vector3 pos;
Tree_Segment_Script parsSegInfo = pars.GetComponent <Tree_Segment_Script>();
pos = new Vector3(parsSegInfo.updatePos.x, parsSegInfo.updatePos.y, 0);
return(pos);
}
void MakeBaseTree(Vector3 startPosTemp, float angleTemp, Vector2 scaleTemp, int depthTemp)
{
Debug.Log("StartedTree");
//create a quaternion specified with euler angles where we rotate around 'x'
Quaternion rot = Quaternion.Euler(0, 0, angleTemp); // * Quaternion.AngleAxis( Random.Range(0,360), Vector3.up);
//make a trunk
Vector3 topPos = startPosTemp + (rot * (TreeParms.trunkTopOffset * scaleTemp.y));
GameObject obj = (GameObject)GameObject.Instantiate(trunkPrefab, startPos, rot);
GameObject anchorRootObj = (GameObject)GameObject.Instantiate(anchorPoint, startPosTemp, rot);
anchorRootObj.name = "RootAnchor";
anchorRootObj.GetComponent <PositionManager>().curChild = obj.transform;
GameObject MainTree = CreateTree();
StartSeg = MainTree;
//Passing Over Current Tree Information to the Trunk
Tree_Segment_Script objSegment = obj.GetComponent <Tree_Segment_Script>();
objSegment.startPos = topPos;
objSegment.angle = angleTemp;
objSegment.scale = TreeParms.growthSplitPoint;
objSegment.depth = depthTemp;
objSegment.root = this.transform;
objSegment.master = GetComponent <Tree_Master>();
objSegment.treeSegmentTypes = Tree_Segment_Script.TreeSegmentType.ROOT;
objSegment.pos = anchorRootObj.transform;
obj.GetComponent <Segment_GrowthState>().growthSplitPoint = TreeParms.growthSplitPoint;
obj.GetComponent <Segment_GrowthState>().growthSplitPoint = TreeParms.growthSplitPoint;
obj.transform.parent = anchorRootObj.transform;
anchorRootObj.transform.parent = MainTree.transform;
obj.gameObject.name = "RootTrunk";
anchorList.Add(anchorRootObj);
allTreeSegment.Add(obj);
growthList.Add(obj);
}
public static void CreateSegment(Vector3 startPosTemp, Vector3 prevStartPosTemp, float angleTemp, Vector2 scaleTemp, int depthTemp, string name, GameObject curObj, GameObject treeMast, GameObject spawnObj, Tree_Segment_Script.TreeSegmentType treeinfo)
{
Quaternion rot = Quaternion.Euler(0, 0, angleTemp);
Tree_Segment_Script curTreeSeg = curObj.GetComponent <Tree_Segment_Script>();
if (!curTreeSeg.GetComponent <Segment_GrowthState>().hitEnd&& !curTreeSeg.GetComponent <Tree_Segment_Script>().isMasterBranch&& curTreeSeg.GetComponent <Segment_GrowthState>().treeStages == Segment_GrowthState.TreeStage.GROWING)
{
curTreeSeg.masterSegment.GetComponent <Tree_Segment_Script>().masterSegGroup.GetComponent <Tree_Master_SegmentGroup_Info>().SegmentsList.Add(curTreeSeg.gameObject);
curTreeSeg.transform.parent = curTreeSeg.masterSegment.GetComponent <Tree_Segment_Script>().masterSegGroup.transform;
if (curTreeSeg.pos != null)
{
curTreeSeg.pos.GetComponent <PositionManager>().Explode();
curTreeSeg.pos = null;
}
Tree_Master.growthList.Remove(curTreeSeg.gameObject);
}
if (scaleTemp.y <= TreeParms.minScale && curObj.GetComponent <Segment_GrowthState>().treeStages == Segment_GrowthState.TreeStage.GROWING ||
scaleTemp.y >= curObj.GetComponent <Segment_GrowthState>().growthSplitPoint.y&& curObj.GetComponent <Segment_GrowthState>().treeStages == Segment_GrowthState.TreeStage.SPURT)
{
if (depthTemp >= maxDepth && curTreeSeg.treeSegmentTypes == Tree_Segment_Script.TreeSegmentType.BRANCH)
{
CreateLeaf(curTreeSeg.angle, curTreeSeg.transform.position, curObj);
Tree_Master.growthList.Remove(curTreeSeg.gameObject);
return;
}
CreateLeaf(curTreeSeg.angle, curTreeSeg.transform.position, curObj);
curObj.GetComponent <Segment_GrowthState>().hitEnd = true;
return; //done with this 'leaf'!
}
GameObject obj = (GameObject)GameObject.Instantiate(spawnObj, startPosTemp, rot);
obj.name = name;
GameObject anchrObj = (GameObject)GameObject.Instantiate(Tree_Master.anchorPoint, startPosTemp, rot);
PositionManager anchor = anchrObj.GetComponent <PositionManager>();
if (depthTemp == 1 && treeinfo == Tree_Segment_Script.TreeSegmentType.BRANCH)
{
anchrObj.transform.name = "MASTER_Anchor" + depthTemp + " " + obj.name;
}
else
{
anchrObj.transform.name = "Anchor" + depthTemp + " " + obj.name;
}
Tree_Segment_Script segMan = obj.GetComponent <Tree_Segment_Script>();
anchor.startPosTemp = startPosTemp;
anchor.angleTemp = angleTemp;
anchor.prevSegment = curObj.transform;
anchor.curChild = obj.transform;
anchor.trunkTopOffset = trunkTopOffset;
segMan.startPos = startPosTemp;
segMan.angle = angleTemp;
segMan.scale = new Vector2(scaleTemp.x, scaleTemp.y);
segMan.depth = depthTemp;
segMan.masterSegment = curObj.GetComponent <Tree_Segment_Script>().masterSegment;
segMan.master = treeMast.GetComponent <Tree_Master>();
segMan.pos = anchrObj.transform;
segMan.prevSeg = curObj.transform;
segMan.GetComponentInChildren <SpriteRenderer>().sortingOrder = -depthTemp;
//Current Branches Position and Rotation Point
segMan.transform.parent = anchrObj.transform;
anchrObj.transform.parent = Tree_Master.StartSeg.transform;
if (treeinfo == Tree_Segment_Script.TreeSegmentType.BRANCH)
{
segMan.treeSegmentTypes = Tree_Segment_Script.TreeSegmentType.BRANCH;
segMan.transform.name = "Branch" + "_" + depthTemp;
}
else if (treeinfo == Tree_Segment_Script.TreeSegmentType.TRUNK)
{
segMan.treeSegmentTypes = Tree_Segment_Script.TreeSegmentType.TRUNK;
segMan.transform.name = "Trunk" + "_" + depthTemp;
}
// Tree_Master.AddSegment(obj);
Tree_Master.growthList.Add(obj);
Tree_Master.allTreeSegment.Add(obj);
Tree_Master.anchorList.Add(anchrObj);
//Control of Current Segments Growth
Segment_GrowthState growthState = obj.GetComponent <Segment_GrowthState>();
growthState.growthSplitPoint = new Vector2(scaleTemp.x, scaleTemp.y);
growthState.prevSeg = curObj.transform;
growthState.depth = depthTemp;
}
// Use this for initialization
void Start()
{
anchorInfo = GetComponent<PositionManager>();
treeSegInfo = anchorInfo.curChild.GetComponent<Tree_Segment_Script>();
}
// Update is called once per frame
void Update()
{
if (Tree_Master.treeTrunkList.Count != 0)
{
topBranch = Tree_Master.treeTrunkList[(CustomExtensions.GetHighestPoint(Tree_Master.treeTrunkList))];
}
float wiggle = Mathf.Sin(Time.time) * 2;
//Dynamic Angle Placement of Current Segments Based on User Input
if (Tree_Master.allTreeSegment.Count != 0)
{
for (int i = 0; i < Tree_Master.allTreeSegment.Count; i++)
{
Tree_Segment_Script trunk = Tree_Master.allTreeSegment[i].GetComponent <Tree_Segment_Script>();
if (trunk != null && trunk.GetComponent <Tree_Segment_Script>().masterSegment != null)
{
if (trunk.GetComponent <Tree_Segment_Script>().masterSegment.GetComponent <Tree_Segment_Script>().masterSegGroup != null)
{
GameObject masterSegGroup = trunk.GetComponent <Tree_Segment_Script>().masterSegment.GetComponent <Tree_Segment_Script>().masterSegGroup;
if (trunk.GetComponent <Segment_GrowthState>().hitEnd)
{
trunk.updatePos = CustomExtensions.TrunkPositionUpdate(trunk.angle, new Vector2(trunk.transform.localScale.x, trunk.transform.localScale.y), trunk.transform);
}
else if (trunk.transform.parent == masterSegGroup.transform)
{
trunk.updatePos = CustomExtensions.TrunkPositionUpdate(trunk.angle, new Vector2(trunk.transform.localScale.x * masterSegGroup.transform.localScale.x,
trunk.transform.localScale.y * masterSegGroup.transform.localScale.y), trunk.transform);
}
}
else
{
trunk.updatePos = CustomExtensions.TrunkPositionUpdate(trunk.angle, new Vector2(trunk.transform.localScale.x, trunk.transform.localScale.y), trunk.transform);
}
if (trunk.pos != null && trunk.transform.parent != trunk.GetComponent <Tree_Segment_Script>().masterSegment.GetComponent <Tree_Segment_Script>().masterSegGroup.transform)
{
trunk.transform.position = trunk.pos.position;
}
else if (trunk.prevSeg != null)
{
trunk.transform.position = trunk.prevSeg.GetComponent <Tree_Segment_Script>().updatePos;
}
trunk.inputAngle = Tree_Input_Manager.treeInputAngle;
Quaternion rot = new Quaternion();
if (trunk.treeSegmentTypes == Tree_Segment_Script.TreeSegmentType.TRUNK)
{
rot = Quaternion.Euler(0, 0, trunk.angle + (Tree_Input_Manager.treeInputAngle / 4) * trunk.depth + wiggle);
rot = Quaternion.Lerp(trunk.transform.rotation, rot, 0.05f);
trunk.transform.rotation = rot;
}
else if (trunk.isMasterBranch && trunk.pos != null && trunk.prevSeg != null)
{
rot = Quaternion.Euler(0, 0, trunk.angle + trunk.prevSeg.GetComponent <Tree_Segment_Script>().angle + (Tree_Input_Manager.treeInputAngle / 2) * trunk.depth + wiggle);
rot = Quaternion.Lerp(trunk.pos.transform.rotation, rot, 0.05f);
trunk.pos.transform.rotation = rot;
}
}
}
}
if (Tree_Master.anchorList.Count != 0)
{
for (int i = 0; i < Tree_Master.anchorList.Count; i++)
{
PositionManager posMan = Tree_Master.anchorList[i].GetComponent <PositionManager>();
if (posMan.prevSegment != null)
{
posMan.transform.position = CustomExtensions.AdjustPosition(posMan.prevSegment);
}
if (anchorList.Count > 1)
{
}
}
}
}
// Use this for initialization
void Start()
{
anchorInfo = GetComponent <PositionManager>();
treeSegInfo = anchorInfo.curChild.GetComponent <Tree_Segment_Script>();
}
// Update is called once per frame
void Update()
{
if (Tree_Master.treeTrunkList.Count != 0)
{
topTrunk = Tree_Master.treeTrunkList[(CustomExtensions.GetHighestPoint(Tree_Master.treeTrunkList))];
}
if (Tree_Master.creatorListMaster.Count != 0)
{
for (int i = 0; i < Tree_Master.creatorListMaster.Count; i++)
{
Tree_Segment_Script trunk = Tree_Master.creatorListMaster[i].GetComponent <Tree_Segment_Script>();
//==========================================
//Creation of Random Branches
//==========================================
if (trunk.GetComponent <Segment_GrowthState>().treeStages == Segment_GrowthState.TreeStage.GROWING && trunk.treeSegmentTypes == Tree_Segment_Script.TreeSegmentType.BRANCH)
{
if (Random.value <= spawnChance && !trunk.randomSegment && trunk.depth >= 5)
{
trunk.randomSegment = true;
CreateBranchSegment(trunk.startPos, trunk.angle, new Vector2(trunk.scale.x, trunk.scale.y), trunk.depth, trunk.gameObject);
}
}
if (trunk.createBranch)
{
if (trunk.transform.parent == trunk.GetComponent <Tree_Segment_Script>().masterSegment.GetComponent <Tree_Segment_Script>().masterSegment)
{
GameObject masterSeg = trunk.GetComponent <Tree_Segment_Script>().masterSegment.GetComponent <Tree_Segment_Script>().masterSegment;
CreateBranchSegment(trunk.transform.position, trunk.angle, new Vector2(trunk.scale.x * masterSeg.transform.localScale.x,
trunk.scale.y * masterSeg.transform.localScale.y), 0, trunk.gameObject);
Tree_Master.creatorListMaster.Remove(trunk.gameObject);
}
else
{
CreateBranchSegment(trunk.transform.position, trunk.angle, new Vector2(trunk.scale.x, trunk.scale.y), 0, trunk.gameObject);
Tree_Master.creatorListMaster.Remove(trunk.gameObject);
}
trunk.createBranch = false;
}
if (!trunk.nextSegmentMade)
{
//==========================================
//Creates Next Brnach Gen of Tree
//==========================================
//Create 2 Branches
//Create a Branch to the Left
//Create a Branch to the Right
//Create Continuation of Current Branch/Trunk
//No Branch is Created
trunk.nextSegmentMade = true;
if (trunk.treeSegmentTypes == Tree_Segment_Script.TreeSegmentType.TRUNK || trunk.treeSegmentTypes == Tree_Segment_Script.TreeSegmentType.ROOT)
{
CreateTrunkSegment(trunk.transform.position, trunk.angle, new Vector2(trunk.scale.x, trunk.scale.y), trunk.depth, Tree_Input_Manager.treeInputAngle, trunk.gameObject);
}
else
{
CreateBranchSegment(trunk.transform.position, trunk.angle, new Vector2(trunk.scale.x, trunk.scale.y), trunk.depth, trunk.gameObject);
}
}
Tree_Master.creatorListMaster.Remove(trunk.gameObject);
}
}
}
public static void CreateSegment(Vector3 startPosTemp, Vector3 prevStartPosTemp, float angleTemp, Vector2 scaleTemp, int depthTemp, string name, GameObject curObj, GameObject treeMast, GameObject spawnObj, Tree_Segment_Script.TreeSegmentType treeinfo)
{
Quaternion rot = Quaternion.Euler( 0, 0, angleTemp);
Tree_Segment_Script curTreeSeg = curObj.GetComponent<Tree_Segment_Script>();
if(!curTreeSeg.GetComponent<Segment_GrowthState>().hitEnd && !curTreeSeg.GetComponent<Tree_Segment_Script>().isMasterBranch && curTreeSeg.GetComponent<Segment_GrowthState>().treeStages == Segment_GrowthState.TreeStage.GROWING)
{
curTreeSeg.masterSegment.GetComponent<Tree_Segment_Script>().masterSegGroup.GetComponent<Tree_Master_SegmentGroup_Info>().SegmentsList.Add(curTreeSeg.gameObject);
curTreeSeg.transform.parent = curTreeSeg.masterSegment.GetComponent<Tree_Segment_Script>().masterSegGroup.transform;
if(curTreeSeg.pos != null)
{
curTreeSeg.pos.GetComponent<PositionManager>().Explode();
curTreeSeg.pos = null;
}
Tree_Master.growthList.Remove(curTreeSeg.gameObject);
}
if(scaleTemp.y <= TreeParms.minScale && curObj.GetComponent<Segment_GrowthState>().treeStages == Segment_GrowthState.TreeStage.GROWING ||
scaleTemp.y >= curObj.GetComponent<Segment_GrowthState>().growthSplitPoint.y && curObj.GetComponent<Segment_GrowthState>().treeStages == Segment_GrowthState.TreeStage.SPURT)
{
if(depthTemp >= maxDepth && curTreeSeg.treeSegmentTypes == Tree_Segment_Script.TreeSegmentType.BRANCH)
{
CreateLeaf(curTreeSeg.angle, curTreeSeg.transform.position, curObj);
Tree_Master.growthList.Remove(curTreeSeg.gameObject);
return;
}
CreateLeaf(curTreeSeg.angle, curTreeSeg.transform.position, curObj);
curObj.GetComponent<Segment_GrowthState>().hitEnd = true;
return; //done with this 'leaf'!
}
GameObject obj = (GameObject)GameObject.Instantiate(spawnObj, startPosTemp, rot);
obj.name = name;
GameObject anchrObj = (GameObject)GameObject.Instantiate(Tree_Master.anchorPoint, startPosTemp, rot);
PositionManager anchor = anchrObj.GetComponent<PositionManager>();
if(depthTemp == 1 && treeinfo == Tree_Segment_Script.TreeSegmentType.BRANCH)
{
anchrObj.transform.name = "MASTER_Anchor" + depthTemp +" "+ obj.name;
}else{
anchrObj.transform.name = "Anchor" + depthTemp +" "+ obj.name;
}
Tree_Segment_Script segMan = obj.GetComponent<Tree_Segment_Script>();
anchor.startPosTemp = startPosTemp;
anchor.angleTemp = angleTemp;
anchor.prevSegment = curObj.transform;
anchor.curChild = obj.transform;
anchor.trunkTopOffset = trunkTopOffset;
segMan.startPos = startPosTemp;
segMan.angle = angleTemp;
segMan.scale = new Vector2 (scaleTemp.x, scaleTemp.y);
segMan.depth = depthTemp;
segMan.masterSegment = curObj.GetComponent<Tree_Segment_Script>().masterSegment;
segMan.master = treeMast.GetComponent<Tree_Master>();
segMan.pos = anchrObj.transform;
segMan.prevSeg = curObj.transform;
segMan.GetComponentInChildren<SpriteRenderer>().sortingOrder = -depthTemp;
//Current Branches Position and Rotation Point
segMan.transform.parent = anchrObj.transform;
anchrObj.transform.parent = Tree_Master.StartSeg.transform;
if(treeinfo == Tree_Segment_Script.TreeSegmentType.BRANCH)
{
segMan.treeSegmentTypes = Tree_Segment_Script.TreeSegmentType.BRANCH;
segMan.transform.name = "Branch" + "_" + depthTemp;
}
else if(treeinfo == Tree_Segment_Script.TreeSegmentType.TRUNK)
{
segMan.treeSegmentTypes = Tree_Segment_Script.TreeSegmentType.TRUNK;
segMan.transform.name = "Trunk" + "_" + depthTemp;
}
// Tree_Master.AddSegment(obj);
Tree_Master.growthList.Add(obj);
Tree_Master.allTreeSegment.Add(obj);
Tree_Master.anchorList.Add(anchrObj);
//Control of Current Segments Growth
Segment_GrowthState growthState = obj.GetComponent<Segment_GrowthState>();
growthState.growthSplitPoint = new Vector2(scaleTemp.x, scaleTemp.y);
growthState.prevSeg = curObj.transform;
growthState.depth = depthTemp;
}
// Update is called once per frame
void Update()
{
currentTime += Time.deltaTime;
if (Tree_Master.growthList.Count != 0)
{
for (int i = 0; i < Tree_Master.growthList.Count; i++)
{
//Grabbing Current Tree Segment's Growth Information
//Incriments Threw and Increases Scale According to Current Segment State
//Spurt = Newly Created
//Growth = Global Growth Rate For all Segments
//Paused = Stops Growing
Segment_GrowthState trunkGrowthState = Tree_Master.growthList[i].GetComponent <Segment_GrowthState>();
Tree_Segment_Script trunkSeginfo = Tree_Master.growthList[i].GetComponent <Tree_Segment_Script>();
Vector2 tempVector = new Vector2(trunkGrowthState.transform.localScale.x, trunkGrowthState.transform.localScale.y);
if (currentTime >= spawnTime)
{
//==========================================
//Creation of Master Branches at set intervals
//==========================================
curIndex = Random.Range(0, Tree_Master.treeTrunkList.Count - 1);
if (curIndex > Tree_Master.treeTrunkList.Count - 1 || curIndex < 0)
{
curIndex = 0;
}
GameObject branchCreator = Tree_Master.treeTrunkList[curIndex].gameObject;
branchCreator.GetComponent <Tree_Segment_Script>().createBranch = true;
Tree_Master.creatorListMaster.Add(branchCreator);
currentTime = 0;
}
if (SessionManager.instance != null)
{
if (currentTime >= SessionManager.instance.SessionTime_minutes * 60)
{
trunkGrowthState.treeStages = Segment_GrowthState.TreeStage.PUASED;
}
}
else
{
}
//controls splitting when a segment has reached a minimum scale
if (trunkGrowthState.hitEnd && trunkGrowthState.transform.localScale.y >= trunkGrowthState.growthSplitPoint.y && !trunkSeginfo.isTree)
{
trunkSeginfo.nextSegmentMade = false;
trunkGrowthState.hitEnd = false;
Tree_Master.creatorListMaster.Add(trunkSeginfo.gameObject);
}
//This will just toggle between the first two results after the scale meets the condition, is this intended?
if (trunkGrowthState.transform.localScale.y >= trunkGrowthState.growthSplitPoint.y && !trunkGrowthState.hitEnd && !trunkSeginfo.isTree)
{
Tree_Master.creatorListMaster.Add(trunkSeginfo.gameObject);
trunkGrowthState.treeStages = Segment_GrowthState.TreeStage.GROWING;
trunkGrowthState.growthSplitPoint = new Vector2(trunkGrowthState.growthSplitPoint.x, trunkGrowthState.growthSplitPoint.y / 2);
}
if (trunkGrowthState.growthSplitPoint.y < TreeParms.minScale && trunkGrowthState.treeStages == Segment_GrowthState.TreeStage.GROWING && !trunkSeginfo.isTree ||
trunkGrowthState.transform.localScale.y > trunkGrowthState.growthSplitPoint.y && trunkGrowthState.treeStages == Segment_GrowthState.TreeStage.GROWING && !trunkSeginfo.isTree)
{
}
if (trunkGrowthState.treeStages == Segment_GrowthState.TreeStage.SPURT)
{
//If the Segment Hits its Current Split Point
//It will Slow Down and Create a new Segment
// trunkSeginfo.GetComponent<SpriteRenderer>().color = new Color (trunkSeginfo.GetComponent<SpriteRenderer>().color.r,
// trunkSeginfo.GetComponent<SpriteRenderer>().color.g,
// trunkSeginfo.GetComponent<SpriteRenderer>().color.b,
// (float)tempVector.y * 2);
tempVector.y = Mathf.Lerp(tempVector.y, tempVector.y + TreeParms.scaleChange, Time.deltaTime * TreeParms.growthRate.y);
tempVector.x = Mathf.Lerp(tempVector.x, trunkGrowthState.transform.localScale.y, Time.deltaTime * TreeParms.growthRate.y);
trunkGrowthState.transform.localScale = new Vector3(tempVector.x, tempVector.y, 1);
}
if (trunkSeginfo.isMasterBranch && trunkGrowthState.treeStages == Segment_GrowthState.TreeStage.GROWING)
{
Vector2 tempVector2 = new Vector2(trunkSeginfo.masterSegGroup.transform.localScale.x, trunkSeginfo.masterSegGroup.transform.localScale.y);
tempVector2.y = Mathf.Lerp(tempVector2.y, tempVector2.y + TreeParms.scaleChange, Time.deltaTime * TreeParms.globalGrowth.y);
tempVector2.x = Mathf.Lerp(tempVector2.x, trunkSeginfo.masterSegGroup.transform.localScale.y, (Time.deltaTime * TreeParms.globalGrowth.y) / 2);
trunkSeginfo.masterSegGroup.transform.localScale = new Vector3(tempVector2.x, tempVector2.y, 1);
}
else
{
if (trunkGrowthState.treeStages == Segment_GrowthState.TreeStage.GROWING &&
trunkSeginfo.transform.parent != trunkSeginfo.masterSegment.GetComponent <Tree_Segment_Script>().masterSegGroup&& trunkGrowthState.hitEnd)
{
tempVector.y = Mathf.Lerp(tempVector.y, tempVector.y + TreeParms.scaleChange, Time.deltaTime * TreeParms.globalGrowth.y);
tempVector.x = Mathf.Lerp(tempVector.x, trunkGrowthState.transform.localScale.y, Time.deltaTime * TreeParms.globalGrowth.y);
trunkGrowthState.transform.localScale = new Vector3(tempVector.x, tempVector.y, 1);
}
}
}
}
}
