public void Init()
{
gameObject.layer = LayerMask.NameToLayer(layerName);
// Tunnel dimensions exclude ceiling thickness and any additional ramp
// structure
m_vehicleDimensions = Footprint.Measure(vehiclePrefab);
Vector3 tunnelDimensions = new Vector3(m_vehicleDimensions.x * (1 + tunnelWiggleroom), m_vehicleDimensions.y * (1 + tunnelHeadroom), maxVehiclesInTunnel * m_vehicleDimensions.z * (1 + tunnelVehicleSpacing));
m_tunnelObject = CreateNewObject("TunnelInterior", tunnelMaterial, true);
m_occluderObject = CreateNewObject("TunnelOccluder", occlusionMaterial, false);
switch (type)
{
case Type.StraightRamp:
m_tunnelBuilder = new TunnelWithStraightRamp(m_tunnelObject, m_occluderObject, tunnelDimensions, m_vehicleDimensions, rampAngle);
break;
case Type.SmoothRamp:
m_tunnelBuilder = new TunnelWithSmoothRamp(m_tunnelObject, m_occluderObject, tunnelDimensions, m_vehicleDimensions, rampAngle, numRampSegments);
break;
case Type.RampOnly:
m_tunnelBuilder = new AngledTunnel(m_tunnelObject, m_occluderObject, tunnelDimensions, m_vehicleDimensions, rampAngle);
break;
}
m_tunnelBuilder.CreateMeshes();
// Disable sub-objects. They will be re-enabled upon being embedded.
m_tunnelObject.obj.SetActive(false);
m_occluderObject.obj.SetActive(false);
}
//private List<Collider>
private void FixedUpdate()
{
UpdateDynamics();
BoxCollider box = GetComponent <BoxCollider>();
Vector3 halfExtents = 0.5f * Footprint.Measure(gameObject);
Collider[] overlapping = Physics.OverlapBox(transform.TransformPoint(box.center), halfExtents, transform.rotation, PlayspaceManager.spatialLayerMask);
if (overlapping.Length > 0)
{
Vector3 resolution = Vector3.zero;
foreach (Collider c in overlapping)
{
Vector3 direction = Vector3.zero;
float distance = 0;
Physics.ComputePenetration(box, transform.position, transform.rotation, c, c.transform.position, c.transform.rotation, out direction, out distance);
resolution += distance * direction;
}
Vector3 reactionDirection = resolution.normalized;
Vector3 velocity = m_rb.velocity;
m_rb.velocity = Vector3.zero;
m_rb.angularVelocity = Vector3.zero;
m_rb.AddForce(reactionDirection * 1.5f, ForceMode.VelocityChange);
Debug.Log("Velocity " + velocity + " -> " + m_rb.velocity);
}
return;
// Layers must be set up such that helicopter cannot collide with itself
/*
* BoxCollider box = GetComponent<BoxCollider>();
* Vector3 halfExtents = 0.5f * Footprint.Measure(gameObject);
* Collider[] overlapping = Physics.OverlapBox(transform.TransformPoint(box.center), halfExtents, transform.rotation, PlayspaceManager.spatialLayerMask);
* Vector3 reactionDirection = Vector3.zero;
* foreach (Collider c in overlapping)
* {
* //Debug.Log("overlapping " + c.name);
* //Debug.Log("closest point: " + c.ClosestPoint(transform.position));
* //reactionDirection += (transform.position - c.ClosestPoint(transform.position)).normalized;
* }
* if (overlapping.Length > 0)
* reactionDirection = -m_rb.velocity;
* m_rb.AddForce(reactionDirection.normalized * 0.5f, ForceMode.VelocityChange);
* LineRenderer lr = GetComponent<LineRenderer>();
* lr.positionCount = 2;
* lr.SetPosition(0, transform.position);
* lr.SetPosition(1, reactionDirection.normalized + transform.position);
* lr.useWorldSpace = true;
*/
}
private void OnEnable()
{
if (target == null)
{
m_localScale = Vector3.zero;
return;
}
Vector3 targetSize = Footprint.Measure(target.gameObject);
float width = margin * Mathf.Sqrt(targetSize.x * targetSize.x + targetSize.z * targetSize.z);
float height = margin * targetSize.y;
width = maxSize.x == 0 ? width : Mathf.Min(maxSize.x, width);
height = maxSize.y == 0 ? height : Mathf.Min(maxSize.y, height);
m_width = width;
m_height = height;
Vector3 xDir = Vector3.right;
Vector3 yDir = Vector3.up;
Vector3 xDirBend = Mathf.Cos(bendAngle * Mathf.Deg2Rad) * Vector3.right;
Vector3 yDirBend = Mathf.Sin(bendAngle * Mathf.Deg2Rad) * Vector3.up;
LineRenderer line1 = lineRenderers[0];
LineRenderer line2 = lineRenderers[1];
line1.positionCount = 4;
line2.positionCount = 4;
// Left side
line1.SetPosition(0, -xDir * 0.5f * width + 0.5f * height * yDir + (xDirBend + yDirBend).normalized * bendLength * width);
line1.SetPosition(1, -xDir * 0.5f * width + 0.5f * height * yDir);
line1.SetPosition(2, -xDir * 0.5f * width - 0.5f * height * yDir);
line1.SetPosition(3, -xDir * 0.5f * width - 0.5f * height * yDir + (xDirBend - yDirBend).normalized * bendLength * width);
// Right side
line2.SetPosition(0, xDir * 0.5f * width + 0.5f * height * yDir + (-xDirBend + yDirBend).normalized * bendLength * width);
line2.SetPosition(1, xDir * 0.5f * width + 0.5f * height * yDir);
line2.SetPosition(2, xDir * 0.5f * width - 0.5f * height * yDir);
line2.SetPosition(3, xDir * 0.5f * width - 0.5f * height * yDir + (-xDirBend - yDirBend).normalized * bendLength * width);
// Text line disabled for now
LineRenderer line3 = lineRenderers[2];
line3.gameObject.SetActive(false);
textMesh.gameObject.SetActive(false);
m_startPosition = Camera.main.transform.position + zoomPosition;
m_localScale = transform.localScale;
m_startTime = Time.time;
ResetCoroutine();
}
private IEnumerator DrawTextCoroutine()
{
if (textMesh.text.Length == 0)
{
yield break;
}
Vector2 textSize = Footprint.Measure(textMesh);
Vector3 xDir = Vector3.right;
Vector3 yDir = Vector3.up;
LineRenderer line3 = lineRenderers[2];
line3.positionCount = 3;
Vector3[] points = new Vector3[3];
points[0] = xDir * 0.5f * m_width * 1.25f + 0 * m_height * yDir;
points[1] = points[0] + (xDir + yDir).normalized * 0.5f * m_width;
points[2] = points[1] + xDir * textSize.x;
float[] tParams = ComputePiecewiseInterpolationParams(points);
float startTime = Time.time;
float t = 0;
do
{
yield return(null);
line3.gameObject.SetActive(true);
t = textLineDrawTime == 0 ? 1 : (Time.time - startTime) / textLineDrawTime;
InterpolateLineSegments(line3, points, tParams, t);
} while (t < 1);
// Draw text
textMesh.gameObject.transform.localPosition = line3.GetPosition(1) + yDir * textHeight * textSize.y;
textMesh.gameObject.SetActive(true);
}
private void PlaceBuildings()
{
Vector3[] homeBaseSizes = new Vector3[homeBasePrefab.Length];
Vector3[] besiegedBuildingSizes = new Vector3[besiegedBuildingPrefab.Length];
for (int i = 0; i < homeBasePrefab.Length; i++)
{
homeBaseSizes[i] = Footprint.Measure(homeBasePrefab[i]);
}
for (int i = 0; i < besiegedBuildingPrefab.Length; i++)
{
besiegedBuildingSizes[i] = Footprint.Measure(besiegedBuildingPrefab[i]);
}
Vector3 homeBaseControlTowerSize = Footprint.Measure(homeBaseControlTowerPrefab);
//TODO: query playspace alignment and iterate over a large radius from playspace center for first building
// in order to ensure that it is placed somewhere on the edge of playspace.
TaskManager.Instance.Schedule(
() =>
{
for (float distanceApart = idealDistanceApart; distanceApart >= minDistanceApart; distanceApart -= distanceStepSize)
{
for (int i = 0; i < besiegedBuildingPrefab.Length; i++)
{
for (int j = 0; j < homeBasePrefab.Length; j++)
{
string name1;
string name2;
Vector3 position1 = Vector3.zero;
Vector3 position2 = Vector3.zero;
Vector3 homeBaseControlTowerPosition = Vector3.zero;
Quaternion rotation1;
Quaternion rotation2;
Quaternion homeBaseControlTowerRotation;
bool placed1 = PlayspaceManager.Instance.TryPlaceOnFloor(out name1, out position1, out rotation1, besiegedBuildingSizes[i]);
List <PlayspaceManager.Rule> rules = new List <PlayspaceManager.Rule>()
{
PlayspaceManager.Rule.AwayFrom(position1, distanceApart)
};
bool placed2 = PlayspaceManager.Instance.TryPlaceOnFloor(out name2, out position2, out rotation2, homeBaseSizes[j], rules);
if (placed1 && placed2)
{
// Record positions so that subsequent dependent placement queries can use them
m_besiegedBuildingPosition = position1;
m_homeBasePosition = position2;
// Try to place air control tower near home base
bool placedHomeBaseControlTower = PlaceBuildingNear(out homeBaseControlTowerPosition, out homeBaseControlTowerRotation, homeBaseControlTowerSize, m_homeBasePosition, 1);
// Instantiate the buildings later on main thread
return(() =>
{
// Place buildings
Debug.Log("Building placement results: i=" + i + ", j=" + j + ", distanceApart=" + distanceApart + (placedHomeBaseControlTower ? ", tower placed" : ", tower failed"));
m_besiegedBuilding = Instantiate(besiegedBuildingPrefab[i], position1, rotation1);
m_homeBase = Instantiate(homeBasePrefab[j], position2 - Vector3.up * homeBaseSizes[j].y * 0.5f, rotation2);
if (placedHomeBaseControlTower)
{
Instantiate(homeBaseControlTowerPrefab, homeBaseControlTowerPosition - Vector3.up * homeBaseControlTowerSize.y * 0.5f, homeBaseControlTowerRotation);
}
// Place transport helicopter
Instantiate(transportHelicopterPrefab, m_homeBase.transform.Find("LandingPoint").position, rotation2);
});
}
else if (placed1)
{
PlayspaceManager.Instance.RemoveObject(name2);
}
else if (placed2)
{
PlayspaceManager.Instance.RemoveObject(name1);
}
}
}
}
return(() => Debug.Log("Failed to place buildings!"));
});
//TODO: failed -- try placing anywhere and then if that also fails, need to re-scan.
}
private void PlaceEnemies()
{
PlayspaceManager pm = PlayspaceManager.Instance;
string placementName;
Vector3 agent1Size = Footprint.Measure(agentPrefab1);
float agent1Width = Mathf.Max(agent1Size.x, agent1Size.z);
for (int i = 0; i < 3; i++)
{
TaskManager.Instance.Schedule(
() =>
{
Vector3 position;
if (pm.TryPlaceOnPlatform(out position, 0.25f, 1.5f, 1.5f * agent1Width))
{
return(() =>
{
NavMeshHit hit;
if (NavMesh.SamplePosition(position, out hit, 2, NavMesh.AllAreas))
{
position = hit.position;
}
GameObject agent = Instantiate(agentPrefab1, position, Quaternion.identity);
SetTarget(agent, playerHelicopter);
});
}
return(null);
});
}
Vector3 agent2Size = Footprint.Measure(agentPrefab2);
float agent2Width = Mathf.Max(agent2Size.x, agent2Size.z);
for (int i = 0; i < 2; i++)
{
TaskManager.Instance.Schedule(
() =>
{
Vector3 position;
Quaternion rotation;
if (pm.TryPlaceOnPlatform(out position, 0.25f, 1.5f, 1.5f * agent2Width))
{
return(() =>
{
NavMeshHit hit;
if (NavMesh.SamplePosition(position, out hit, 2, NavMesh.AllAreas))
{
position = hit.position;
}
GameObject agent = Instantiate(agentPrefab2, position, Quaternion.identity);
SetTarget(agent, playerHelicopter);
});
}
else if (pm.TryPlaceOnFloor(out placementName, out position, out rotation, agent2Size))
{
return(() =>
{
NavMeshHit hit;
if (NavMesh.SamplePosition(position, out hit, 2, NavMesh.AllAreas))
{
position = hit.position;
}
GameObject agent = Instantiate(agentPrefab2, position, rotation);
SetTarget(agent, playerHelicopter);
});
}
return(null);
});
}
Vector3 agent3Size = Footprint.Measure(agentPrefab3);
float agent3Width = Mathf.Max(agent3Size.x, agent3Size.z);
for (int i = 0; i < 1; i++)
{
TaskManager.Instance.Schedule(
() =>
{
Vector3 position;
Quaternion rotation;
if (pm.TryPlaceOnPlatform(out position, 0.25f, 1.5f, 1.5f * agent3Width))
{
return(() =>
{
NavMeshHit hit;
if (NavMesh.SamplePosition(position, out hit, 2, NavMesh.AllAreas))
{
position = hit.position;
}
GameObject agent = Instantiate(agentPrefab3, position, Quaternion.identity);
SetTarget(agent, playerHelicopter);
});
}
else if (pm.TryPlaceOnFloor(out placementName, out position, out rotation, agent3Size))
{
return(() =>
{
NavMeshHit hit;
if (NavMesh.SamplePosition(position, out hit, 2, NavMesh.AllAreas))
{
position = hit.position;
}
GameObject agent = Instantiate(agentPrefab3, position, rotation);
SetTarget(agent, playerHelicopter);
});
}
return(null);
});
}
Vector3 enemyHelicopter1Size = Footprint.Measure(enemyHelicopterPrefab1.gameObject);
for (int i = 0; i < 1; i++)
{
TaskManager.Instance.Schedule(
() =>
{
Vector3 position;
Quaternion rotation;
List <PlayspaceManager.Rule> rules = new List <PlayspaceManager.Rule>()
{
PlayspaceManager.Rule.Nearby(m_besiegedBuildingPosition, 0f, 0.25f)
};
if (pm.TryPlaceInAir(out position, out rotation, enemyHelicopter1Size, rules))
{
return(() =>
{
HelicopterEnemy enemyHelicopter = Instantiate(enemyHelicopterPrefab1, position, rotation);
SetTarget(enemyHelicopter.gameObject, playerHelicopter);
});
}
return(() => { Debug.Log("Failed to place enemy helicopter"); });
});
}
}
