public void Move(Vector3 target)
{
int troopCounter = 0;
int segmentLength = 1;
Vector3 lastPosition = target;
Vector3 currentDirection = Vector3.forward;
TroopBase[] troops = GetTroops();
while (troopCounter < troops.Length)
{
for (int i = 0; i < segmentLength / 2;)
{
TroopBase troop = troops[troopCounter];
if (troop.gameObject.activeInHierarchy)
{
troop.Target = lastPosition;
lastPosition += currentDirection * troop.radius;
i++;
}
troopCounter += 1;
if (troopCounter >= troops.Length)
{
break;
}
}
currentDirection = currentDirection.Rotate(90, Vector3.up);
segmentLength += 1;
}
}
public static void AddTroopToGroup(int playerId, int groupId, TroopBase troop)
{
if (playerIdGroupDict.ContainsKey(playerId))
{
playerIdGroupDict[playerId].AddTroopToGroup(groupId, troop);
}
}
public void AddTroopToGroup(int groupId, TroopBase troop)
{
if (idGroupDict.ContainsKey(groupId))
{
idGroupDict[groupId].AddTroop(troop);
}
}
public void UpdateLights()
{
TroopBase[] troops = GetTroops();
TroopBase centerTroop = troops[0];
float centerIntensityTarget = 0;
float centerRangeTarget = 0;
for (int i = 1; i < troops.Length; i++)
{
TroopBase troop = troops[i];
float distanceToCenter = Vector3.Distance(troop.transform.position, centerTroop.transform.position);
const float intensityTarget = -1;
const float rangeTarget = -1;
troop.childLight.intensity = Mathf.Lerp(troop.childLight.intensity, intensityTarget, Time.deltaTime * lightFadeSpeed);
troop.childLight.range = Mathf.Lerp(troop.childLight.range, rangeTarget, Time.deltaTime * lightFadeSpeed);
troop.childLight.enabled = troop.childLight.intensity > 0 && troop.childLight.range > 0;
centerIntensityTarget += Mathf.Clamp(1 - distanceToCenter / troop.sightRadius, 0, 1) * troop.lightIntensity * lightGrowFactor;
centerRangeTarget += Mathf.Clamp(1 - distanceToCenter / troop.sightRadius, 0, 1) * troop.lightRange * lightGrowFactor;
NetworkController.instance.clientController.sendUnitLightingData(troop.playerId, troop.id, troop.childLight.intensity, troop.childLight.range, troop.childLight.enabled);
}
centerTroop.childLight.intensity = Mathf.Lerp(centerTroop.childLight.intensity, centerIntensityTarget.Pow(0.75), Time.deltaTime * lightFadeSpeed * 5);
centerTroop.childLight.range = Mathf.Lerp(centerTroop.childLight.range, centerRangeTarget.Pow(0.75), Time.deltaTime * lightFadeSpeed * 5);
centerTroop.childLight.enabled = centerTroop.childLight.intensity > 0 && centerTroop.childLight.range > 0;
NetworkController.instance.clientController.sendUnitLightingData(centerTroop.playerId, centerTroop.id, centerTroop.childLight.intensity, centerTroop.childLight.range, centerTroop.childLight.enabled);
}
public bool CheckForEnemies()
{
TroopBase enemy = TroopManager.GetClosestInRangeEnemy(this);
closestInRangeEnemy = (enemy == null || enemy.playerId == playerId) ? null : enemy;
return(closestInRangeEnemy != null);
}
public void DamageTroop(int troopId, float damage)
{
TroopBase troop = GetTroop(troopId);
if (troop != null)
{
troop.Damage(damage);
}
}
public void MoveTroop(int troopId, Vector3 position)
{
TroopBase troop = GetTroop(troopId);
if (troop != null)
{
troop.Move(position);
}
}
public void KillTroop(int troopId)
{
TroopBase troop = GetTroop(troopId);
if (troop != null)
{
troop.Kill();
}
}
public void FadeTroopLight(int troopId, float intensity, float range, bool enabled)
{
TroopBase troop = GetTroop(troopId);
if (troop != null)
{
troop.FadeLight(intensity, range, enabled);
}
}
public static bool GroupZoneContains(int playerId, int groupId, TroopBase troop)
{
if (playerIdGroupDict.ContainsKey(playerId))
{
return(playerIdGroupDict[playerId].GroupZoneContains(groupId, troop));
}
return(false);
}
public static bool TroopZoneContains(int playerId, TroopBase troop)
{
if (!playerIdTroopDict.ContainsKey(playerId))
{
return(false);
}
return(playerIdTroopDict[playerId].ZoneContains(troop, true));
}
public bool GroupZoneContains(int groupId, TroopBase troop)
{
if (idGroupDict.ContainsKey(groupId))
{
return(idGroupDict[groupId].ZoneContains(troop, false));
}
return(false);
}
public static void Despawn(int playerId, int troopId)
{
TroopBase troop = GetTroop(playerId, troopId);
if (troop != null)
{
Despawn(troop);
}
}
public void SetTroopTarget(int troopId, Vector3 target)
{
TroopBase troop = GetTroop(troopId);
if (troop != null)
{
troop.SetTarget(target);
}
}
void dammageTroop(TroopBase troop, float damage)
{
if (!NetworkController.instance.isConnected)
{
troop.Damage(source.damage);
}
else
{
NetworkController.instance.clientController.sendUnitDamage(troop.playerId, troop.id, damage);
}
}
void OnTriggerEnter(Collider collision)
{
TroopBase troop = collision.GetComponent <TroopBase>();
if (troop != null && playerId != troop.playerId && playerId == NetworkController.CurrentPlayerId)
{
dammageTroop(troop, damage);
}
Kill();
}
public static void Despawn(TroopBase troop)
{
if (playerIdTroopDict.ContainsKey(troop.playerId))
{
playerIdTroopDict[troop.playerId].RemoveTroop(troop);
}
References.InputManager.selectedTroops.Remove(troop);
troop.Selected = false;
RemoveTroopFromGroup(troop);
hObjectPool.Instance.Despawn(troop.gameObject);
}
void Shoot()
{
if (!NetworkController.instance.isConnected)
{
BulletManager.Spawn(Random.Range(0, int.MaxValue), Layer, Layer.closestInRangeEnemy);
}
else
{
TroopBase other = Layer.closestInRangeEnemy;
NetworkController.instance.clientController.spawnBullet(Layer.playerId, Layer.id, other.playerId, other.id);
}
}
public static int[] ContainingTroopZones(TroopBase troop, bool includeOwn = false)
{
List <int> zoneIds = new List <int>();
foreach (int playerId in playerIdTroopDict.Keys)
{
if ((includeOwn || playerId != troop.playerId) && TroopZoneContains(playerId, troop))
{
zoneIds.Add(playerId);
}
}
return(zoneIds.ToArray());
}
void UpdateAgents()
{
TroopBase[] troops = TroopManager.GetTroops(NetworkController.CurrentPlayerId);
troopFogAgents = new FogAgent[troops.Length];
for (int i = 0; i < troops.Length; i++)
{
TroopBase troop = troops[i];
troopFogAgents[i] = new FogAgent(troop.transform, troop.sightRadius * 2);
}
foreach (FogAgent fogAgent in fogAgents)
{
fogAgent.Update();
}
}
void Select()
{
if (!Input.GetKey(Layer.addToSelectionKey1) && !Input.GetKey(Layer.addToSelectionKey2))
{
DeselectAll();
}
TroopBase[] troops = TroopManager.GetTroops(NetworkController.CurrentPlayerId);
if (selectionRect.size.magnitude <= minBoxSize)
{
Ray selectionRay = Camera.main.ScreenPointToRay(Input.mousePosition);
RaycastHit selectionRayInfo;
if (Physics.Raycast(selectionRay, out selectionRayInfo))
{
TroopBase troop = selectionRayInfo.collider.GetComponent <TroopBase>();
if (troop != null && troop.playerId == NetworkController.CurrentPlayerId)
{
troop.Selected = true;
if (!Layer.selectedTroops.Contains(troop))
{
Layer.selectedTroops.Add(troop);
}
}
}
}
else
{
foreach (TroopBase troop in troops)
{
Vector3 troopScreenPosition = Camera.main.WorldToScreenPoint(troop.transform.position);
troopScreenPosition.y = Screen.height - troopScreenPosition.y;
if (selectionRect.Contains(troopScreenPosition, true))
{
troop.Selected = true;
Layer.selectedTroops.Add(troop);
}
}
}
}
public static TroopBase[] GetInRangeTroops(TroopBase troop, params int[] playerIds)
{
List <TroopBase> inRangeTroops = new List <TroopBase>();
foreach (int playerId in playerIds)
{
foreach (TroopBase otherTroop in GetTroops(playerId))
{
float distance = Vector3.Distance(otherTroop.transform.position, troop.transform.position);
if (distance <= troop.sightRadius)
{
inRangeTroops.Add(otherTroop);
}
}
}
return(inRangeTroops.ToArray());
}
public static bool HasAdvantage(TroopBase source, TroopBase target)
{
bool hasAdvantage;
if (source is TroopHexa)
{
hasAdvantage = target is TroopIcosa;
}
else if (source is TroopIcosa)
{
hasAdvantage = target is TroopTetra;
}
else
{
hasAdvantage = target is TroopHexa;
}
return(hasAdvantage);
}
public static Bullet Spawn(int bulletId, TroopBase source, TroopBase target)
{
Bullet bullet = hObjectPool.Instance.Spawn(TypeIdToPrefab(ToTypeId(source)), source.transform.position, Quaternion.identity).GetComponent <Bullet>();
if (!playerIdBulletDict.ContainsKey(source.playerId))
{
playerIdBulletDict[source.playerId] = new PlayerBulletManager(source.playerId);
}
bullet.gameObject.layer = source.playerId == NetworkController.CurrentPlayerId ? 9 : 10;
bullet.lifeCounter = source.bulletLifeTime;
bullet.source = source;
bullet.target = target;
bullet.damage = source.damage;
bullet.playerId = source.playerId;
bullet.id = bulletId;
playerIdBulletDict[source.playerId].AddBullet(bullet);
return(bullet);
}
public static TroopBase Spawn(int playerId, int troopId, int troopTypeId, Vector3 position, Quaternion rotation)
{
TroopBase troop = hObjectPool.Instance.Spawn(TypeIdToPrefab(troopTypeId), position, rotation).GetComponent <TroopBase>();
if (!playerIdTroopDict.ContainsKey(playerId))
{
playerIdTroopDict[playerId] = new PlayerTroopManager(playerId);
}
troop.childLight.enabled = false;
troop.gameObject.layer = playerId == NetworkController.CurrentPlayerId ? 9 : 10;
troop.playerId = playerId;
troop.id = troopId;
troop.childLight.color = TeamStaticStuff.getColorForTeam(playerId);
playerIdTroopDict[playerId].AddTroop(troop);
References.Fow.UpdateFow = true;
return(troop);
}
public static TroopBase GetClosestInRangeTroop(TroopBase troop, params int[] playerIds)
{
TroopBase closestTroop = null;
float closestDistance = float.MaxValue;
foreach (int playerId in playerIds)
{
foreach (TroopBase otherTroop in GetTroops(playerId))
{
float distance = Vector3.Distance(troop.transform.position, otherTroop.transform.position);
if (otherTroop.gameObject.activeInHierarchy && distance <= troop.sightRadius && distance < closestDistance)
{
closestTroop = otherTroop;
closestDistance = distance;
}
}
}
return(closestTroop);
}
public void RemoveTroopFromGroup(int groupId, TroopBase troop)
{
RemoveTroopFromGroup(groupId, troop.id);
}
public static int ToTypeId(TroopBase troop)
{
return(TroopManager.ToTypeId(troop));
}
public bool ZoneContains(TroopBase troop, bool useSightRadius)
{
return(useSightRadius ? sightZone.Intersects(troop.GetSightRect()) : troopZone.Intersects(troop.GetRect()));
}
public void RemoveTroop(TroopBase troop)
{
troop.groupId = 0;
idTroopDict.Remove(troop.id);
}
