public void CmdAddUnit(SquadUnit unit)
{
print("Called");
units.Add(unit);
unit.Follower.target = transform;
unit.Follower.minDistance = 0;
}
protected override IEnumerator AttackAnimation(SquadUnit targetSquadUnit)
{
myNavMeshAgent.enabled = false;
GameObject clone = ObjectPools.CurrentObjectPool.RockProjectilePool.GetPooledObject();
if (clone != null)
{
Vector3 start = transform.position + Vector3.up;
Vector3 end = targetSquadUnit.transform.position;
clone.SetActive(true);
RockProjectile projectile = clone.GetComponent <RockProjectile>();
projectile.SetDestination(start, targetSquadUnit.transform,
attackDamage, damageType);
start.y = 0f;
end.y = 0f;
Vector3 direction = end - start;
direction.Normalize();
transform.forward = direction;
}
AnimateAttack();
yield return(new WaitForSeconds(attackTime));
myNavMeshAgent.enabled = true;
}
public override Vector3 CalculateMove(SquadUnit squadUnit, List <Transform> context, Squad squad)
{
List <Transform> filteredContext = (filter == null) ? context : filter.Filter(squadUnit, context);
//if no neighbors, return no adjustment
if (filteredContext.Count == 0)
{
return(Vector3.zero);
}
//add all points together and average
Vector3 cohesionMove = Vector3.zero;
for (int i = 0; i < filteredContext.Count; ++i)
{
cohesionMove += filteredContext[i].position;
}
cohesionMove /= filteredContext.Count;
//create offset from agent position
cohesionMove -= squadUnit.PathTransform.position;
//cohesionMove.y = 0f;
return(cohesionMove);
}
public override void CollectObservations()
{
//Debug.Log("Collecting observations");
currentSquadIntervalCount++;
if (currentSquadIntervalCount >= squadDataInterval)
{
squad.UpdateCollectiveInformation();
currentSquadIntervalCount = 0;
}
AddVectorObs(squad.playerWithinSquadRange); //NOTE THIS WILL ENABLE WALLHACK FOR THE AGNETS!!! TODO: make a sensor that uses the combination of this and the unit.seeingPlayer-observation
AddVectorObs(squad.physicalObjectsWithinRange.Count > 0);
AddVectorObs(squad.weaponsWithinRange.Count > 0);
AddVectorObs(squad.GetActivityHistogram());
foreach (bool unitDescision in lastDescision)
{
AddVectorObs(unitDescision);
}
//NOTE maybe add observations on what stuff the player has: weapons, ammo, health etc.
for (int i = 0; i < MAX_SQUAD_SIZE; i++)
{
SquadUnit unit = (i < squad.units.Length) ? squad.units[i] : null;
foreach (bool observation in Squad.GetAgentBooleanObservation(unit))
{
AddVectorObs(observation);
}
AddVectorObs(Squad.GetAgentFloatObservations(unit));
}
}
private static void SetMaterialColor(SquadUnit unit, Color c)
{
foreach (var r in unit.GetComponentsInChildren <MeshRenderer>())
{
r.materials[0].SetColor("_Color", c);
}
}
public override Vector3 CalculateMove(SquadUnit squadUnit, List <Transform> context, Squad squad)
{
if (Weights.Length != Behaviours.Length)
{
Debug.LogError("Data mismatch in " + name, this);
return(Vector3.zero);
}
Vector3 move = Vector3.zero;
for (int i = 0; i < Behaviours.Length; ++i)
{
Vector3 partialMove = Behaviours[i].CalculateMove(squadUnit, context, squad) * Weights[i];
if (partialMove != Vector3.zero)
{
if (partialMove.sqrMagnitude > Weights[i] * Weights[i])
{
partialMove = partialMove.normalized * Weights[i];
}
move += partialMove;
}
}
return(move);
}
public override Vector3 CalculateMove(SquadUnit squadUnit, List <Transform> context, Squad squad)
{
Vector3 followPathVector = Vector3.zero;
followPathVector = squadUnit.TargetTransform.position - squadUnit.PathTransform.position;
return(followPathVector);
}
public async Task DecreaseUnitTypeNumber(Squad squad, UnitTypes unitType, int amount)
{
SquadUnit squadUnit = squad.SquadUnits
.Where(su => su.Unit.Type == unitType)
.SingleOrDefault();
squadUnit.NumberOfUnits -= amount;
await _dbContext.SaveChangesAsync();
}
public async Task UpdateUnitTypeNumber(Squad squad, UnitTypes unitType, int newUnitNumber)
{
SquadUnit squadUnit = squad.SquadUnits
.Where(su => su.Unit.Type == unitType)
.SingleOrDefault();
squadUnit.NumberOfUnits = newUnitNumber;
await _dbContext.SaveChangesAsync();
}
private void Awake()
{
mySquadUnit = GetComponentInParent <SquadUnit>();
myAnimator = GetComponent <Animator>();
mySquadUnit.OnAnimateIdle += MySquadUnit_OnAnimateIdle;
mySquadUnit.OnAnimateMovement += MySquadUnit_OnAnimateMovement;
mySquadUnit.OnAnimateAttack += MySquadUnit_OnAnimateAttack;
mySquadUnit.OnAnimateDeath += MySquadUnit_OnAnimateDeath;
}
void CmdAddUnitToSquad(SquadUnit s)
{
s.Follower.target = transform;
s.Follower.minDistance = minFollowerDistance;
//Reset speed multiplier to normal
s.unit.GetComponent <CharacterMovement>().speedMultiplier = 1;
s.unit.GetComponent <Rigidbody2D>().simulated = true;
squad.Add(s);
}
public static bool[] GetAgentBooleanObservation(SquadUnit unit)
{
if (unit == null)
{
bool[] deadState = new bool[SquadUnit.SENSOR_COUNT];
deadState[0] = true;
return(deadState);
}
return(unit.GetObservations());
}
protected virtual void SpawnSquadUnits()
{
for (int i = 0; i < SquadPositions.Length; ++i)
{
GameObject clone = Instantiate(SquadUnitGameObject);
clone.transform.position = SquadPositions[i].position;
clone.transform.rotation = SquadPositions[i].rotation;
SquadUnit squadUnit = clone.GetComponent <SquadUnit>();
squadUnit.InitializeSquadUnit(this, SquadPositions[i]);
squadUnits.Add(squadUnit);
}
}
public void AddUnit(SquadUnit unit)
{
for (int i = 0; i < units.Length; i++)
{
if (units[i] == null)
{
unit.squadUnitIndex = i;
units[i] = unit;
return;
}
}
Debug.LogError("THERES NO MORE SPACE FOR UNITS, YOU MUST'VE FFFED UP SOMEWHERE!");
}
void CmdTestSpawnSquad()
{
int count = 3;
for (int i = 0; i < count; i++)
{
GameObject go = GameObject.Instantiate(TestUnit, transform.position + (Vector3)(Random.insideUnitCircle * .1f), Quaternion.identity);
//go.GetComponent<AddBody>().BuildBody(unitData);
NetworkServer.Spawn(go);
SquadUnit su = SquadUnit.GameObjectToSquadUnit(go);
//Should be assigned at authority, in this case the server
CmdAddUnitToSquad(su);
}
}
public override List <Transform> Filter(SquadUnit agent, List <Transform> original)
{
List <Transform> filtered = new List <Transform>();
for (int i = 0; i < original.Count; ++i)
{
if (mask == (mask | 1 << original[i].gameObject.layer))
{
filtered.Add(original[i]);
}
}
return(filtered);
}
public override List <Transform> Filter(SquadUnit squadUnit, List <Transform> original)
{
List <Transform> filtered = new List <Transform>();
for (int i = 0; i < original.Count; ++i)
{
SquadUnit itemSquadUnit = original[i].GetComponent <SquadUnit>();
if (itemSquadUnit != null && itemSquadUnit.CommandingSquad == squadUnit.CommandingSquad)
{
filtered.Add(original[i]);
}
}
return(filtered);
}
List <Transform> GetNearbyObjects(SquadUnit squadUnit)
{
List <Transform> context = new List <Transform>();
Collider[] contextColliders = Physics.OverlapSphere(
squadUnit.PathTransform.position + Vector3.up, NeighborRadius);
for (int i = 0; i < contextColliders.Length; ++i)
{
if (contextColliders[i] != squadUnit.UnitCollider)
{
context.Add(contextColliders[i].transform);
}
}
return(context);
}
public override Vector3 CalculateMove(SquadUnit squadUnit, List <Transform> context, Squad squad)
{
List <Transform> filteredContext = (filter == null) ? context : filter.Filter(squadUnit, context);
//if no neighbors, return no adjustment
if (filteredContext.Count == 0)
{
return(Vector3.zero);
}
//find closest unit to attack
float closestSqrMagnitude = 100f;
if (squad.SquareAttackRadius > closestSqrMagnitude)
{
closestSqrMagnitude = squad.SquareAttackRadius;
}
Transform closestTransform = null;
for (int i = 0; i < filteredContext.Count; ++i)
{
float sqrMagnitude = Vector3.SqrMagnitude(filteredContext[i].position - squadUnit.transform.position);
if (sqrMagnitude < closestSqrMagnitude)
{
closestSqrMagnitude = sqrMagnitude;
closestTransform = filteredContext[i];
}
}
if (closestTransform == null)
{
return(Vector3.zero);
}
TownCenter targetTownCenter = closestTransform.GetComponent <TownCenter>();
if (targetTownCenter != null)
{
squadUnit.Attack(targetTownCenter);
}
return(Vector3.zero);
}
public async Task InsertUnitType(Squad squad, UnitTypes unitType, int unitNumber)
{
var unit = await _dbContext.Units.Where(u => u.Type == unitType).SingleOrDefaultAsync();
if (unit == null)
{
throw new NotFoundException($"Nincs ilyen egység típusod!");
}
var squadUnit = new SquadUnit
{
SquadId = squad.Id,
UnitId = unit.Id,
NumberOfUnits = unitNumber
};
_dbContext.SquadUnits.Add(squadUnit);
squad.SquadUnits.Add(squadUnit);
await _dbContext.SaveChangesAsync();
}
protected virtual IEnumerator AttackAnimation(SquadUnit targetSquadUnit)
{
myNavMeshAgent.enabled = false;
Vector3 start = transform.position + Vector3.up;
Vector3 end = targetSquadUnit.transform.position;
start.y = 0f;
end.y = 0f;
Vector3 direction = end - start;
direction.Normalize();
transform.forward = direction;
AnimateAttack();
targetSquadUnit.ReceiveDamage(transform, attackDamage, damageType);
yield return(new WaitForSeconds(attackTime));
myNavMeshAgent.enabled = true;
}
public override Vector3 CalculateMove(SquadUnit squadUnit, List <Transform> context, Squad squad)
{
List <Transform> filteredContext = (filter == null) ? context : filter.Filter(squadUnit, context);
//if no neighbors, maintain current direction
if (filteredContext.Count == 0)
{
return(squadUnit.PathTransform.forward);
}
//add all forwards together and average
Vector3 alignmentMove = Vector3.zero;
for (int i = 0; i < filteredContext.Count; ++i)
{
alignmentMove += filteredContext[i].forward;
}
alignmentMove /= filteredContext.Count;
alignmentMove.y = 0f;
return(alignmentMove);
}
public void SpawnInSquad(SquadUnit squad)
{
m_Squad = squad;
}
public abstract Vector3 CalculateMove(SquadUnit squadUnit,
List <Transform> context, Squad squad);
private void Start()
{
_agent = GetComponent <SquadUnit>();
_commander = transform.parent.GetComponent <CommanderAgent>();
}
public ScalingText(SingleUnit single, SquadUnit squad)
{
this.single = single;
this.squad = squad;
}
//TODO add support for multiple
public static void CreateNewSquad(GameObject squad, GameObject unitPrefab, HashSet <Vector2Int> tiles,
Vector2Int minMax, System.Random random, MLAgents.Brain Brain, Room room, Vector2Int offset, GameObject player)
{
if (unitPrefab == null)
{
Debug.LogError("create squad need unit prefab");
return;
}
CommanderAgent prefabCommander = squad.GetComponent <CommanderAgent>();
if (prefabCommander == null)
{
Debug.LogError("create squad need squad prefab");
return;
}
if (prefabCommander.squad.units.Length > 0)
{
Debug.LogError("squad prefab needs to contain no units");
return;
}
if (player == null)
{
Debug.LogError("Squad needs to be initialized with player reference");
return;
}
GameObject newSquadObject = Object.Instantiate(squad, Vector3.zero, Quaternion.identity);
CommanderAgent commanderAgent = newSquadObject.GetComponent <CommanderAgent>();
commanderAgent.squad.currentRoom = room;
commanderAgent.GiveBrain(Brain);
commanderAgent.squadColor = Random.ColorHSV(0, 1, 0.25f, 1f);
int squadSize = random.NextInclusive(minMax.x, minMax.y);
int tilesPerUnit = 6;
int maxUnits = tiles.Count / tilesPerUnit;
if (squadSize > maxUnits)
{
squadSize = maxUnits;
}
if (squadSize > CommanderAgent.MAX_SQUAD_SIZE)
{
squadSize = CommanderAgent.MAX_SQUAD_SIZE;
}
for (int i = 0; i < squadSize; i++)
{
Vector2 tile = tiles.GetRandom(random);
Vector3 position = new Vector3((tile.x * 2) + offset.x, 1.055f, (tile.y * 2) + offset.y);
var unit = Object.Instantiate(unitPrefab, position, Quaternion.identity, newSquadObject.transform);
SquadUnit newUnit = unit.GetComponent <SquadUnit>();
var unitSensor = newUnit.GetComponent <UnitSensor>();
unitSensor.player = player;
unitSensor.headColliderTransform = player.transform;
SetMaterialColor(newUnit, commanderAgent.squadColor);
commanderAgent.squad.AddUnit(newUnit);
}
return;
}
public void Attack(SquadUnit targetSquadUnit)
{
StartCoroutine(AttackAnimation(targetSquadUnit));
}
public static float[] GetAgentFloatObservations(SquadUnit unit)
{
return((unit == null) ? new float[1] {
0
} : unit.GetFloatObservations());
}
public int NumberOfOtherAgentsInSameActivity(SquadUnit agent)
{
int activity = agent.StateMachineController.GetInteger("RoutineStatus");
return((activity < 0) ? 0 : numberOfUnitsInActivity[activity] - 1); // -1 to account for self
}
public void AddUnit(Combatant unit)
{
if (!_units.ContainsKey(unit)) {
_units[unit] = new SquadUnit(unit);
}
}
