private void cleanPool()
{
while (_arrowIndicatorPool.Count > _arrowPoolUsedCount)
{
Image lastArrow = _arrowIndicatorPool[_arrowIndicatorPool.Count - 1];
_arrowIndicatorPool.Remove(lastArrow);
Destroy(lastArrow.gameObject);
}
while (_boxIndicatorPool.Count > _boxPoolUsedCount)
{
TargetIndicator lastBox = _boxIndicatorPool[_boxIndicatorPool.Count - 1];
_boxIndicatorPool.Remove(lastBox);
Destroy(lastBox.gameObject);
}
// Objective waypoint offscreen arrows
while (_objectiveArrowPool.Count > _objectiveArrowPoolUsedCount)
{
Image lastArrow = _objectiveArrowPool[_objectiveArrowPool.Count - 1];
_objectiveArrowPool.Remove(lastArrow);
Destroy(lastArrow.gameObject);
}
// Objective waypoint onscreen indicator
while (_objectiveIconPool.Count > _objectiveIconPoolUsedCount)
{
ObjectiveIndicator lastIcon = _objectiveIconPool[_objectiveIconPool.Count - 1];
_objectiveIconPool.Remove(lastIcon);
Destroy(lastIcon.gameObject);
}
}
private BasicObjective processBasicObjective(XmlNode node)
{
BasicObjectiveBuilder builder = new BasicObjectiveBuilder();
if (node ["descriptionCompleted"] != null)
{
builder.descriptionCompleted(node ["descriptionCompleted"].InnerText);
}
if (node ["message"] != null)
{
builder.message(node ["message"].InnerText);
}
foreach (XmlNode n in node["indicators"].ChildNodes)
{
ObjectiveIndicator oi = gom.getIndicator(n.InnerText);
if (n.Attributes["chat"] != null && oi is PopupTriggerIndicator)
{
(oi as PopupTriggerIndicator).setMessage(n.Attributes["chat"].Value);
}
if (n.Attributes["chat"] != null && oi is PopupAnimatorTriggerIndicator)
{
(oi as PopupAnimatorTriggerIndicator).setMessage(n.Attributes["chat"].Value);
}
builder.indicator(oi);
}
return(builder.build(node["description"].InnerText));
}
public BasicObjectiveBuilder indicator(ObjectiveIndicator o)
{
if (!objectiveIndicators.Contains(o))
{
objectiveIndicators.Add(o);
}
return(this);
}
void finishedObjective(ObjectiveIndicator o, EventArgs e)
{
if (active && !done)
{
done = true;
deactivate();
reportDone(this);
}
}
// Check objective distance.
private IEnumerator CheckObjectiveDistance()
{
float closestDistance = float.MaxValue;
bool isAnyObjectiveAvailable = false;
foreach (var objective in Objectives)
{
if (!objective.IsActivated)
{
float distance = Vector3.Distance(Player.Instance.transform.position, objective.transform.position);
if (distance < closestDistance)
{
closestDistance = distance;
ClosestPoint = objective.transform.position;
}
isAnyObjectiveAvailable = true;
}
}
// If final objective only one available.
if (!isAnyObjectiveAvailable)
{
// Point towards final objective.
if (!FinalObjective.IsActivated)
{
// Reveal final objective.
if (!FinalObjective.gameObject.activeSelf)
{
FinalObjective.gameObject.SetActive(true);
}
closestDistance = Vector3.Distance(Player.Instance.transform.position, FinalObjective.transform.position);
ClosestPoint = FinalObjective.transform.position;
}
// If final objective is also activated.
else
{
ObjectiveHandler.Instance.ShowDirectionArrow(DirectionType.None);
GameController.Instance.ChangeGameState(GameState.End); // The end.
yield break;
}
}
var grainSettings = PostProcessingProfile.grain.settings;
if (closestDistance < HighIndicator.IndicatorDistance)
{
checkDistance = false;
currentIndicator = HighIndicator;
}
else if (closestDistance < MediumIndicator.IndicatorDistance)
{
checkDistance = false;
currentIndicator = MediumIndicator;
}
else if (closestDistance < LowIndicator.IndicatorDistance)
{
checkDistance = true;
currentIndicator = LowIndicator;
}
else
{
checkDistance = true;
currentIndicator = DefaultIndicator;
}
float playbackSpeed = currentIndicator.AnimatorSpeed;
ObjectiveHandler.Instance.SetIndicatorProximity(playbackSpeed, currentIndicator.ProximityFill);
grainSettings.intensity = currentIndicator.GrainIntensity;
if (currentIndicator != DefaultIndicator)
{
AudioController.Instance.PlaySound(SoundType.Interference, false, 1.0f, false, currentIndicator.InterferenceVolume);
}
PostProcessingProfile.grain.settings = grainSettings;
Debug.Log("Closest distance: " + closestDistance + " / Objectives available: " + isAnyObjectiveAvailable);
if (checkDistance)
{
Player.Instance.CheckNearestPoint();
}
else
{
ObjectiveHandler.Instance.ShowDirectionArrow(DirectionType.None);
}
yield return(new WaitForSeconds(DistanceCheckWaitTime));
yield return(CheckObjectiveDistance());
}
void LateUpdate()
{
resetPool();
if (!GameManager.instance.IsMenuOpen)
{
// POSITION OBJECTIVE ARROWS AND INDICATORS
Vector3[] waypoints = GameManager.questManager.GetActiveQuestObjectiveTargets();
if (waypoints != null)
{
foreach (Vector3 waypoint in waypoints)
{
Vector3 targetPosition = Camera.main.WorldToScreenPoint(waypoint);
// If the target is onscreen show the onscreen indicator
if (targetPosition.z > 0f && targetPosition.x >= 0f && targetPosition.x <= Screen.width && targetPosition.y >= 0f && targetPosition.y <= Screen.height)
{
if (targetPosition.z > 500f)
{
ObjectiveIndicator indicatorImage = getObjectiveIcon();
indicatorImage.GetComponent <RectTransform>().anchoredPosition = new Vector3(targetPosition.x, targetPosition.y, 0f);
indicatorImage.SetDistance(Vector3.Distance(waypoint, GameManager.playerTransform.position));
}
}
else
{
PositionArrowIndicator(targetPosition, ArrowType.waypoint);
}
}
}
// POSITION ENEMY ARROWS AND BOXES
var enemies = GameManager.instance.TargetableObjects.Where(t => t.Allegiance == Enums.Allegiance.Enemy);
foreach (TargetableObject obj in enemies)
{
if (GameManager.playerTransform != null)
{
if (Vector3.Distance(obj.transform.position, GameManager.playerTransform.position) < 500f)
{
Vector3 targetPosition = Camera.main.WorldToScreenPoint(obj.transform.position);
// If the target is onscreen show the onscreen indicator & health bar
if (targetPosition.z > 0f && targetPosition.x >= 0f && targetPosition.x <= Screen.width && targetPosition.y >= 0f && targetPosition.y <= Screen.height)
{
TargetIndicator box = getBoxIndicator();
box.anchoredPosition = new Vector3(targetPosition.x, targetPosition.y, 0f);
box.healthBarFillAmount = (float)obj.GetComponent <HealthController>().Health / (float)obj.GetComponent <HealthController>().MaxHealth;
float multiplier = (maxAlpha - minAlpha) / alphaThreshold;
float currentAlpha = maxAlpha;
box.healthBarVisible = false;
if (targetPosition.z < alphaThreshold)
{
box.healthBarVisible = true;
currentAlpha = minAlpha + (targetPosition.z * multiplier);
}
box.boxAlpha = currentAlpha / 255f;
//Vector3 lead = CalculateLead(player.transform.position, obj.transform.position, projectileSpeed * 1.5f, obj.gameObject.GetComponent<Rigidbody>().velocity, player.GetComponent<Rigidbody>().velocity);
//box.trajectory.rectTransform.anchoredPosition = Camera.main.WorldToScreenPoint(lead) - screenCenter;
}
else // Offscreen - show directional arrow
{
if (waypoints == null || !OverlapsWaypoint(waypoints, obj.transform.position))
{
PositionArrowIndicator(targetPosition, ArrowType.enemy);
}
}
}
}
}
// Warp target indicators
_warpIndicatorInstance.gameObject.SetActive(false);
if (GameManager.instance.IsCursorVisible)
{
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
RaycastHit hit;
int layerMask = 1 << 2;
layerMask = ~layerMask;
if (Physics.Raycast(ray, out hit, Mathf.Infinity, layerMask))
{
WarpTarget target = hit.collider.gameObject.GetComponent <WarpTarget>();
if (target != null)
{
_warpIndicatorInstance.gameObject.SetActive(true);
_warpIndicatorInstance.SetDestinationName(target.TargetName);
// Works with sphere colliders
Vector3 centerPosition = Camera.main.WorldToScreenPoint(target.Bounds.center);
float diffPosition = Camera.main.WorldToScreenPoint(target.Bounds.max).y - centerPosition.y;
Vector3 topPosition = centerPosition + new Vector3(0f, diffPosition * 0.8f, 0f);
_warpIndicatorInstance.SetNamePosition(topPosition);
// Disable entry point indicator if it is currently overlapping an objective marker
if (waypoints == null || !OverlapsWaypoint(waypoints, target.Position))
{
_warpIndicatorInstance.SetEntryPointPosition(target.Position);
}
else
{
_warpIndicatorInstance.DisableEntryPoint();
}
}
}
}
}
cleanPool();
}
