ArrowUnit GetArrow()
{
if (listArrowDisable.Count == 0)
{
return((Instantiate(arrowPrefab) as GameObject).GetComponent <ArrowUnit>());
}
else
{
ArrowUnit arrow = listArrowDisable[0];
listArrowDisable.RemoveAt(0);
return(arrow);
}
}
public RoadUnit ExtendPath(RoadUnit road, int depth)
{
if (depth < 0)
{
return(road);
}
if (!road)
{
road = CreateRoad(Vector3.zero, GameDefine.Direction.Forward, 14, true);
}
if (depth == 0)
{
return(road);
}
if (road.arrow == null)
{
Vector3 crossingPoint = road.startPoint + road.length * RoadDirections[(int)road.direction];
ArrowUnit arrow = MainObjControl.Instant.arrowCtrl.CreateArrow(crossingPoint, road.direction);
float[] nextLengths = { GameDefine.roadRandSize, GameDefine.roadRandSize };
bool[] colors = { Random.value > 0.5 ? true : false, true };
colors[1] = !colors[0];
arrow.road = road;
road.next = new RoadUnit[2];
for (int i = 0; i < 2; i++)
{
GameDefine.Direction turn = arrow.directions[i];
bool color = colors[i];
float nextLength = nextLengths[i];
road.next[i] = CreateRoad(crossingPoint, turn, nextLength, color);
road.next[i].father = road;
// MainObjControl.Instant.blockCtrl.GetBlock(crossingPoint, turn, color, true);
}
road.arrow = arrow;
}
if (depth >= 1)
{
foreach (RoadUnit nextRoad in road.next)
{
ExtendPath(nextRoad, depth - 1);
}
}
return(road);
}
/// <summary>
/// return arrow to pool
/// </summary>
/// <param name="arrow">arrow to return</param>
private static void returnToPool(Arrow arrow)
{
#if DEBUG_INFO
if (m_arrowPool == null)
{
Debug.LogError("object cannot be null");
return;
}
#endif
ArrowUnit aunit = m_arrowPool.Find(x => x.arrow == arrow);
if (aunit == null)
{
return;
}
aunit.inUse = false;
aunit.arrow.gobject.SetActive(false);
aunit.arrow.gobject.transform.SetParent(null);
aunit.arrow.advanceLifetime = false;
aunit.arrow.lifetime = 0f;
aunit.arrow.state = Arrow.STATES.READY;
#if DEBUG_ARROW_PATH
arrow_debug_paths[arrow].Clear();
#endif
// reset trail object if present
if (aunit.arrow.trailObj != null)
{
aunit.arrow.trailObj.gameObject.SetActive(false);
}
// disable collider
if (aunit.arrow.Collider)
{
aunit.arrow.Collider.enabled = false;
aunit.arrow.Collider.isTrigger = true;
}
// disable rigid body
if (aunit.arrow.RigidBody)
{
aunit.arrow.RigidBody.isKinematic = true;
aunit.arrow.RigidBody.detectCollisions = false;
aunit.arrow.RigidBody.useGravity = false;
}
}
IEnumerator Move(ArrowUnit unit, Vector3 to, float duration, bool isSet)
{
float elapsed = 0;
Vector3 from = unit.transform.position;
while (elapsed <= duration)
{
unit.transform.position = Vector3.Lerp(from, to, elapsed / duration);
elapsed += Time.deltaTime;
yield return(null);
}
if (isSet)
{
listArrowDisable.Add(unit);
}
unit.transform.position = to;
}
public void Set(Vector3 startPoint, GameDefine.Direction direction, float length)
{
this.startPoint = startPoint;
this.length = length;
this.direction = direction;
arrow = null;
block = null;
next = null;
Vector3 scale;
Vector3 pos;
float scaleLength = length - GameDefine.roadDistance;
if (direction == GameDefine.Direction.Forward)
{
scale.x = GameDefine.roadWidth;
scale.z = scaleLength;
pos = startPoint + Vector3.forward * (0.5f * GameDefine.roadWidth + 0.5f * scale.z + GameDefine.roadDistance);
}
else
{
scale.z = GameDefine.roadWidth;
if (direction == GameDefine.Direction.Right)
{
scale.x = scaleLength;
pos = startPoint + Vector3.right * (0.5f * GameDefine.roadWidth + 0.5f * scale.x + GameDefine.roadDistance);
}
else
{
scale.x = scaleLength;
pos = startPoint + Vector3.left * (0.5f * GameDefine.roadWidth + 0.5f * scale.x + GameDefine.roadDistance);
}
}
scale.y = GameDefine.roadTall;
transform.localScale = scale;
transform.position = pos;
}
public ArrowUnit CreateArrow(Vector3 forkPos, GameDefine.Direction pathDir)
{
GameDefine.Direction[] turns = new GameDefine.Direction[2];
if (pathDir == GameDefine.Direction.Forward)
{
turns[0] = GameDefine.Direction.Forward;
turns[1] = Random.value > 0.5 ? GameDefine.Direction.Right : GameDefine.Direction.Left;
}
else
{
turns[0] = pathDir;
turns[1] = GameDefine.Direction.Forward;
}
// TODO: Create Fork
ArrowUnit arrow = GetArrow();
arrow.SetPosition(forkPos, pathDir, turns);
arrow.directions = turns;
return(arrow);
}
/// <summary>
/// creates arrow and sets it up in hand
/// </summary>
/// <param name="arrowPrefab">arrow prefab to instantiate</param>
/// <param name="arrowAttachBone">transform on which to attach arrow</param>
/// <returns></returns>
public static Arrow CreateArrow(
GameObject arrowPrefab,
Transform arrowAttachBone,
float maxLifetime,
float arrowLength,
LayerMask layers,
IGameCharacter _owner)
{
#if DEBUG_INFO
if (m_arrowPool == null)
{
Debug.LogError("object cannot be null"); return(null);
}
if (m_active_arrows == null)
{
Debug.LogError("object cannot be null"); return(null);
}
if (!arrowPrefab)
{
Debug.LogError("_currentArrowPrefab is null. Cannot create arrow"); return(null);
}
if (!arrowAttachBone)
{
Debug.LogError("object cannot be null"); return(null);
}
#endif
ArrowUnit newArrowUnit = null;
// try to find available arrow
for (int i = 0; i < m_arrowPool.Count; i++)
{
if (!m_arrowPool[i].inUse)
{
newArrowUnit = m_arrowPool[i];
newArrowUnit.inUse = true;
break;
}
}
// if not create new
if (newArrowUnit == null)
{
GameObject arrowObject =
(GameObject)MonoBehaviour.Instantiate(arrowPrefab);
Arrow newArrow = new Arrow(arrowObject, _owner);
newArrowUnit = new ArrowUnit(newArrow);
m_arrowPool.Add(newArrowUnit);
newArrow.gobject.name = arrowPrefab.name + m_arrowPool.Count;
#if DEBUG_ARROW_PATH
arrow_debug_paths[newArrow] = new List <Vector3>();
#endif
}
#if DEBUG_INFO
if (newArrowUnit == null)
{
Debug.LogError("creating arrow failed."); return(null);
}
#endif
newArrowUnit.arrow.gobject.transform.position = Vector3.zero;
newArrowUnit.arrow.gobject.transform.rotation = Quaternion.identity;
newArrowUnit.arrow.gobject.transform.SetParent(arrowAttachBone, false);
newArrowUnit.arrow.gobject.SetActive(true);
newArrowUnit.arrow.position = Vector3.zero;
newArrowUnit.arrow.prevPosition = Vector3.zero;
newArrowUnit.arrow.direction = Vector3.zero;
newArrowUnit.arrow.fly_time = 0.0f;
newArrowUnit.arrow.state = Arrow.STATES.READY;
newArrowUnit.arrow.speed = 0.0f;
newArrowUnit.arrow.advanceLifetime = false;
newArrowUnit.arrow.RigidBody.detectCollisions = false;
newArrowUnit.arrow.RigidBody.isKinematic = true;
newArrowUnit.arrow.Collider.enabled = false;
newArrowUnit.arrow.layers = layers;
newArrowUnit.arrow.length = arrowLength;
newArrowUnit.arrow.maxLifetime = maxLifetime;
m_active_arrows.Add(newArrowUnit.arrow);
return(newArrowUnit.arrow);
}
public void SetArrow(ArrowUnit arrow)
{
listArrowDisable.Add(arrow);
}
public void SetNewArrow(Vector3 p1, Vector3 p2, Vector3 p3)
{
CheckArrow();
currentArrow = GetArrow();
Vector3 pos;
if (p1.z == p3.z)
{
pos = Vector3.back * f;
if (p1.x > p3.x)
{
listDirect[0] = foward;
listDirect[1] = left;
}
else
{
listDirect[0] = foward;
listDirect[1] = right;
}
}
else if (p1.x == p3.x)
{
pos = Vector3.right * f;
listDirect[0] = foward;
listDirect[1] = left;
}
else
{
if (p1.x == p2.x)
{
if (p2.x < p3.x)
{
pos = Vector3.left * f;
listDirect[0] = foward;
listDirect[1] = right;
}
else
{
pos = Vector3.right * f;
listDirect[0] = foward;
listDirect[1] = left;
}
}
else
{
pos = Vector3.back * f;
if (p1.x < p2.x)
{
listDirect[0] = foward;
listDirect[1] = right;
}
else
{
listDirect[0] = foward;
listDirect[1] = left;
}
}
}
if (isFirst)
{
currentArrow.transform.position = p2;
isFirst = false;
}
else
{
currentArrow.transform.position = new Vector3(p2.x, -5.5f, p2.z);
}
currentArrow.arrow.localPosition = new Vector3(pos.x, 2.81f, pos.z);
int rand = Random.Range(0, 2);
currentArrow.arrow.transform.eulerAngles = listDirect[rand];
currentArrow.roadR.transform.eulerAngles = listDirect[rand];
if (rand == 0)
{
isDirect0 = true;
}
else
{
isDirect0 = false;
}
}
