void Start()
{
horde = gameObject.GetComponent <Horde>();
minions = horde.minions;
axes = new LinkedList <GameObject>();
axeCount = minions.Count * axesPerViking;
}
public override Vector2 CalculateMove(Zombie zombie, List <Transform> context, Horde horde)
{
//Handles data mismatch
if (weights.Length != behaviours.Length)
{
Debug.LogError("Data mismatch in " + name, this);
return(Vector2.zero);
}
//set up move
Vector2 move = Vector2.zero;
//iterate through behaviours
for (int i = 0; i < behaviours.Length; i++)
{
Vector2 partialMove = behaviours[i].CalculateMove(zombie, context, horde) * weights[i];
if (partialMove != Vector2.zero)
{
if (partialMove.sqrMagnitude > weights[i] * weights [i])
{
partialMove.Normalize();
partialMove *= weights[i];
}
move += partialMove;
}
}
return(move);
}
void Start()
{
horde = FindObjectOfType <Horde>();
player = FindObjectOfType <PlayerMov>();
barriers = FindObjectsOfType <Barrier>();
checkDialogue();
}
public override Vector2 CalculateMove(Zombie zombie, List <Transform> context, Horde horde)
{
//if no neighbours, return no adjustment
if (context.Count == 0)
{
return(Vector2.zero);
}
//add all points together and average
Vector2 avoidanceMove = Vector2.zero;
int nAvoid = 0;
foreach (Transform item in context)
{
if (Vector2.SqrMagnitude(item.position - zombie.transform.position) < horde.SquareAvoidanceRadius)
{
nAvoid++;
avoidanceMove += (Vector2)(zombie.transform.position - item.position);
}
}
if (nAvoid > 0)
{
avoidanceMove /= nAvoid;
}
return(avoidanceMove);
}
public void CreateHorde(SpawnPosition position, float count)
{
Horde newHorde = Instantiate(hordePrefab, transform);
newHorde.name = "Horde " + hordeCounter;
hordeCounter++;
hordes.Add(newHorde);
switch (position)
{
case SpawnPosition.LEFT:
newHorde.Spawn(-10f, -1f, 0f, 62f, count);
break;
case SpawnPosition.TOP:
newHorde.Spawn(0f, 64f, 62f, 71f, count);
break;
case SpawnPosition.RIGHT:
newHorde.Spawn(64f, 73f, 0f, 62f, count);
break;
case SpawnPosition.BOTTOM:
newHorde.Spawn(0f, 64f, -10f, -1f, count);
break;
}
}
// this Ray happens instead when player wants to attack something
void AttackRay()
{
Vector3 m = Camera.main.ScreenToWorldPoint(Input.mousePosition);
RaycastHit2D hit = Physics2D.Raycast(new Vector2(m.x, m.y), -Vector2.up, maskForUnits.value);
Vector3 mouseRounded = new Vector3(Mathf.Round(m.x), Mathf.Round(m.y), 0);
if (hit.collider != null)
{
if (hit.collider.CompareTag("Badge"))
{
mouseIsBusy = true;
print("Hit the Horde!!");
Horde horde = hit.collider.gameObject.GetComponent <Horde>();
if (horde.nextToEnemy && Input.GetMouseButtonDown(0))
{
// spawn a spark over the horde for the player to see their hit
float randomZ = (float)Random.Range(0, 180);
GameObject spark = Instantiate(hitSparkFab, mouseRounded, Quaternion.Euler(new Vector3(0, 0, randomZ))) as GameObject;
}
}
else if (hit.collider.CompareTag("Horde Spawner"))
{
mouseIsBusy = true;
print("Hit the spawner!!");
Spawner_HitBox spawner = hit.collider.gameObject.GetComponent <Spawner_HitBox>();
if (spawner.visible && Input.GetMouseButtonDown(0))
{
// spawn a spark over the horde for the player to see their hit
float randomZ = (float)Random.Range(0, 180);
GameObject spark = Instantiate(hitSparkFab, mouseRounded, Quaternion.Euler(new Vector3(0, 0, randomZ))) as GameObject;
}
}
}
}
private void StartNewRound()
{
// At every turn, every character has the possibility to fight.
// The characters attack in order of speed: the faster obviously attacks first.
// The game select a target randomly between the other fighters(a character cannot attack himself or a dead character).
var myRandom = new Random();
this.NotifyState();
// Se ho ben capito come funziona l'ordinamento sulle liste, con la proprietà
// private IOrderedEnumerable<Hero> OrderedHeroes => this.Horde.OrderByDescending(Hero => Hero.Speed);
// creo una vista sulla lista Horde, quindi se le velocità dovessero cambiare tra un turno e l'altro
// dovrebbe riorganizzare la lettura automaticamente, giusto?
// Oppure devo mettere qui l'istruzione di OrderBy, per ricalcolarla ad ogni turno?
foreach (var hero in HeroesBySpeed)
{
if (hero.IsAlive)
{
// creo una nuova lista dei bersagli validi, escludendo sè stesso e tutti gli eroi morti
var validTarget = Horde.ToList();
validTarget.Remove(hero);
validTarget.RemoveAll(x => !x.IsAlive);
if (validTarget.Count > 0)
{
var target = validTarget.ElementAt(myRandom.Next(0, validTarget.Count));
hero.Attack(target);
}
}
}
this.Notifier.LittleBreak();
this.Notifier.Wait("Turno finito.");
this.Notifier.MediumBreak();
}
void OnTriggerEnter2D(Collider2D coll)
{
if (coll.gameObject.tag == "Badge")
{
Horde horde = coll.gameObject.GetComponent <Horde>();
horde.tileColl = myColl;
}
}
void OnTriggerEnter2D(Collider2D coll)
{
if (coll.gameObject.tag == "Badge")
{
Horde horde = coll.gameObject.GetComponent <Horde> ();
CalcDamage(horde);
}
}
public Horde SaveHorde(Horde horde)
{
DbHorde dbHorde = mapper.Map <DbHorde>(horde);
context.Hordes.Add(dbHorde);
context.SaveChanges();
return(mapper.Map <Horde>(dbHorde));
}
void OnTriggerEnter2D(Collider2D coll)
{
if (coll.gameObject.CompareTag("Badge"))
{
Horde horde = coll.gameObject.GetComponent <Horde>();
horde.TakeDamage(damage: 5f);
Debug.Log("Hit for damage: " + damage);
}
}
void OnTriggerExit2D(Collider2D coll)
{
if (coll.CompareTag("Badge"))
{
horde = coll.GetComponent <Horde>();
horde.nextToEnemy = false;
townTile.beingAttacked = false;
}
}
public HordeDetails UpdateHorde(int id, HordeCreateItem hordeCreateItem)
{
Horde horde = mapper.Map <Horde>(hordeCreateItem);
horde.Id = id;
Horde updatedHorde = hordeRepository.Update(id, horde);
return(mapper.Map <HordeDetails>(updatedHorde));
}
public override Vector2 CalculateMove(Zombie zombie, List <Transform> context, Horde horde)
{
Vector2 centerOffset = center - (Vector2)zombie.transform.position;
float t = centerOffset.magnitude / radius;
if (t < 0.9f)
{
return(Vector2.zero);
}
return(centerOffset * t * t);
}
public void InitHordeWithParameters()
{
ZombieParameter[] zombieParameters = { new ZombieParameter(ZombieType.Stalker, ZombieTrait.Normal, 1) };
Horde horde = new Horde(zombieParameters);
Assert.True(horde.IsAlive);
Assert.Single(horde.ZombiesAlive);
Assert.Equal(1, horde.ZombiesAlive[0].Id);
Assert.Equal(1, horde.ZombiesAlive[0].HealthPoints);
Assert.Equal(ZombieType.Stalker, horde.ZombiesAlive[0].Type);
Assert.Equal(ZombieTrait.Normal, horde.ZombiesAlive[0].Trait);
}
void Start()
{
//Se buscan los objetos y componentes necesarios
anim = GetComponentsInChildren <Animator>()[0];
horde = FindObjectOfType <Horde>();
gameObject.GetComponent <CubeEditor>().enabled = false; //Se desactiva el script de snap para que el alien pueda moverse
gun.startSpeed = shotSpeed;
StartCoroutine(fire()); //Comienza la subrutina de disparo que se ejecutará en el intervalo aleatorio entre los valores escogidos
}
// DETECT HORDES
void OnTriggerEnter2D(Collider2D coll)
{
if (coll.gameObject.CompareTag("Badge"))
{
attacking = true;
// Not idling anymore!
idling = false;
if (hordeAttacker == null)
{
hordeAttacker = coll.gameObject.GetComponent <Horde>();
}
}
}
public override string ToString()
{
StringBuilder builder = new StringBuilder();
foreach (var soldier in Soldiers.OrderBy(s => s.Id))
{
builder.AppendLine(soldier.ToString());
}
builder.AppendLine(Horde.ToString());
builder.AppendLine($"Wall HP = {WallHealthPoints}");
return(builder.ToString());
}
void OnTriggerEnter2D(Collider2D coll)
{
if (coll.gameObject.CompareTag("Badge"))
{
Horde horde = coll.gameObject.GetComponent <Horde>();
if (!horde.nextToEnemy)
{
horde.myDrone = GetComponent <Drone>();
horde.nextToEnemy = true;
}
horde.TakeDamage(damage: 5f);
Debug.Log("Hit for damage: " + damage);
}
}
public bool Damage(int incomingDamage)
{
health = health - incomingDamage;
if (health <= 0)
{
GameObject parentHorde = transform.parent.gameObject;
Horde hordeScript = parentHorde.GetComponent <Horde>();
hordeScript.removeZombie(this);
Destroy(this.gameObject);
this.dead = true;
}
return(dead);
}
public Horde Update(int id, Horde horde)
{
DbHorde dbHorde = context.Hordes
.Include(h => h.Orcs)
.FirstOrDefault(h => h.Id == id);
if (dbHorde != null)
{
context.Entry(dbHorde).CurrentValues
.SetValues(mapper.Map <DbHorde>(horde));
context.SaveChanges();
}
return(mapper.Map <Horde>(dbHorde));
}
public override Vector2 CalculateMove(Zombie zombie, List <Transform> context, Horde horde)
{
//if no enemies, maintain current alignment
Transform enemy = GetNearbyEnemies(zombie);
if (enemy == null)
{
return(zombie.transform.up);
}
//move towards enemy
Vector2 attackMove = (Vector2)(enemy.position - zombie.transform.position);
return(attackMove);
}
void Start()
{
Initialise();
rb2d = gameObject.GetComponent <Rigidbody2D>();
//isInfected = true;
skillSoundSource = GetComponent <AudioSource>();
foreach (GameObject horde in GameObject.FindGameObjectsWithTag("Horde"))
{
if (horde.gameObject.GetComponent <Horde>().GetPlayerName().Equals(playerName))
{
myHorde = horde.GetComponent <Horde>();
}
}
}
//Se detiene la horda, deja de disparar y se muestre la puntuación por pantalla con un botón para volver al menú
public void scoreAnimation()
{
horde = FindObjectOfType <Horde>();
horde.speed = 0.0f;
horde.stopFiring();
inp.gameObject.SetActive(true);
setNameText.gameObject.SetActive(true);
scoreText.gameObject.SetActive(true);
scoreText.text = "Puntos: " + playerScore.ToString();
setName = true;
if (horde.speed <= 0.0f)
{
horde.speed = 0.0f;
}
}
public override bool Equals(object obj)
{
if (!(obj is TurnResult other))
{
return(false);
}
var soldiersFound = from thisSoldier in Soldiers
join otherSoldier in other.Soldiers on thisSoldier.Id equals otherSoldier.Id
select Tuple.Create(thisSoldier, otherSoldier);
return(Soldiers.Length == other.Soldiers.Length &&
soldiersFound.Count() == Soldiers.Length &&
soldiersFound.All(tuple => tuple.Item1.Equals(tuple.Item2)) &&
Horde.Equals(other.Horde) &&
Money == other.Money &&
WallHealthPoints == other.WallHealthPoints);
}
void CalcDamage(Horde target)
{
int defense = target.hordeUnit.defenseRating;
int dmgRoll = (Random.Range(0, attackR) + 1) - defense;
Debug.Log(gameObject.name + " rolls: " + dmgRoll);
if (dmgRoll > 0)
{
float damage = (float)dmgRoll;
target.TakeDamage(damage);
Destroy(gameObject);
}
else
{
print("Miss!");
Destroy(gameObject);
}
}
public void HorderPriority()
{
ZombieParameter[] zombieParameters =
{
new ZombieParameter(ZombieType.Stalker, ZombieTrait.Normal, 1),
new ZombieParameter(ZombieType.Fatty, ZombieTrait.Normal, 1),
new ZombieParameter(ZombieType.Fatty, ZombieTrait.Tough, 1),
new ZombieParameter(ZombieType.Stalker, ZombieTrait.Tough, 1)
};
Horde horde = new Horde(zombieParameters);
Assert.True(horde.IsAlive);
Assert.Equal(4, horde.ZombiesAlive.Count);
Assert.Equal(3, horde.ZombiesAlive[0].Id);
Assert.Equal(2, horde.ZombiesAlive[1].Id);
Assert.Equal(4, horde.ZombiesAlive[2].Id);
Assert.Equal(1, horde.ZombiesAlive[3].Id);
}
private IOrderedEnumerable <Hero> HeroesBySpeed => this.Horde.OrderByDescending(Hero => Hero.Speed); // Mi è sembrato comodo avere una proprità per l'ordinamento
#endregion
public void StartToFight()
{
this.Notifier.LargeBreak();
this.Notifier.HighNotify(" *** Inizia un nuovo combattimento nell'arena! *** ");
this.Notifier.LargeBreak();
while (Horde.Count(x => x.IsAlive) > 1)
{
this.StartNewRound();
}
var winner = Horde.Find(x => x.IsAlive); // quando esco dal ciclo, l'unico rimasto in vita è il vincitore
NotifyState();
Notifier.Wait("Fine del combattimento.");
Notifier.LargeBreak();
Notifier.HighNotify($" *** {winner.EpicName} è il campione dell'arena! *** ");
Notifier.LargeBreak();
}
static public Transform GetContainer(Card card, bool isAlly, int ContainerIndex)
{
Transform container;
if (isAlly)
{
container = card.Allegiance.GetChild(ContainerIndex);
}
else if (card.Allegiance == Alliance)
{
container = Horde.GetChild(ContainerIndex);
}
else
{
container = Alliance.GetChild(ContainerIndex);
}
return(container);
}
public override Vector2 CalculateMove(Zombie zombie, List <Transform> context, Horde horde)
{
//if no neighbours, maintain alignment
if (context.Count == 0)
{
return(zombie.transform.up);
}
//add all points together and average
Vector2 alignmentMove = Vector2.zero;
foreach (Transform item in context)
{
alignmentMove += (Vector2)item.transform.up;
}
alignmentMove /= context.Count;
return(alignmentMove);
}
