private BattleFightResult CalculateResult()
{
/*
* foreach (var defender in Defenders)
* {
* int ResultDamage = Math.Abs(defender.Defesa - Attacker.Ataque);
* defender.Defesa = ResultDamage;
* }
*
* Attacker.Defesa = Attacker.Defesa - Defenders.Sum(d => d.Ataque);
*
* return new BattleFightResult(Attacker,Defenders);
*/
int ResultDamage = 0;
foreach (var defender in Defenders)
{
int ParcialResultDamage = Math.Abs(defender.Defesa - Attacker.Ataque);
ResultDamage = ParcialResultDamage > ResultDamage ?
ParcialResultDamage : ResultDamage;
defender.Defesa = defender.Defesa - Attacker.Ataque;
}
Attacker.Defesa = Attacker.Defesa - Defenders.Sum(d => d.Ataque);
return(new BattleFightResult(Attacker, Defenders, ResultDamage));
}
private void Start()
{
buttonArray = GameObject.FindObjectsOfType <Button>();
spriteRenderer = GetComponent <SpriteRenderer>();
defender = defenderPrefab.GetComponent <Defenders>();
starDisplay = FindObjectOfType <StarDisplay>().GetComponent <StarDisplay>();
}
/// <summary>
/// Spawns the defender.
/// </summary>
private void SpawnDefender()
{
// Gets static defender and then creates new one parented to Defenders GO
GameObject selDefender = Button.selectedDefender;
if (selDefender)
{
//Check whether defender already exists there
Vector2 snappedCoordinates = SnapToGrid(worldCoordinates);
Collider[] hitColliders = Physics.OverlapSphere(new Vector3(snappedCoordinates.x, snappedCoordinates.y, 0f), 0.3f);
foreach (Collider col in hitColliders)
{
Defenders def = col.gameObject.GetComponent <Defenders>();
if (def)
{
return;
}
}
GameObject newDefender = Instantiate(selDefender) as GameObject;
newDefender.transform.SetParent(defenderSpawner.transform);
// Set Position of defender
newDefender.transform.position = snappedCoordinates;
}
}
internal BattleState GetNextState()
{
IEnumerable <BattleStateForces> nextAttackers = Attackers.Select(item => item.GetNextState(Defenders, Attackers)).ToArray();
IEnumerable <BattleStateForces> nextDefenders = Defenders.Select(item => item.GetNextState(Attackers, Defenders)).ToArray();
return(new BattleState(nextAttackers, nextDefenders));
}
private void RemoveFromPool(Defender defender)
{
if (Defenders.Contains(defender))
{
Defenders.Remove(defender);
}
}
/// <summary>
///
/// </summary>
/// <param name="win"></param>
public override void EndFight(bool win = false)
{
base.EndFight(win);
if (win)
{
Guild.AddMessage(() =>
{
if (Guild.IsDeleted)
{
return;
}
StartAction(GameActionTypeEnum.MAP);
Guild.Dispatch(WorldMessage.GUILD_TAXCOLLECTOR_SURVIVED(Name, Map.X, Map.Y));
});
}
else
{
Guild.AddMessage(() =>
{
if (Guild.IsDeleted)
{
return;
}
Guild.RemoveTaxCollector(this);
Guild.Dispatch(WorldMessage.GUILD_TAXCOLLECTOR_DIED(Name, Map.X, Map.Y));
});
}
Defenders.Clear();
}
public override void Reset()
{
base.Reset();
if (Flag != null)
{
Flag.Delete();
Flag = null;
}
if (Attackers != null)
{
Attackers.Clear();
}
else
{
Attackers = new Dictionary <PlayerMobile, int>();
}
if (Defenders != null)
{
Defenders.Clear();
}
else
{
Defenders = new Dictionary <PlayerMobile, int>();
}
Caps = 0;
}
private void BattleEnded(bool writeReport)
{
if (writeReport)
{
BattleReport.CompleteBattle();
}
AboutToExitBattle(this, Attackers, Defenders);
ExitBattle(this, Attackers, Defenders);
foreach (var combatObj in Defenders.AllCombatObjects().Where(combatObj => !combatObj.IsDead))
{
combatObj.ExitBattle();
}
foreach (var combatObj in Attackers.AllCombatObjects().Where(combatObj => !combatObj.IsDead))
{
combatObj.ExitBattle();
}
foreach (var group in Attackers)
{
WithdrawAttacker(this, group);
}
foreach (var group in Defenders)
{
WithdrawDefender(this, group);
}
// Delete all groups
Attackers.Clear();
Defenders.Clear();
}
void Start()
{
rend = GetComponent <Renderer>();
startColor = rend.material.color;
set = false;
gamemane = GameObject.Find("GameManager").GetComponent <GameManager>();
defenders = GameObject.Find("GameManager").GetComponent <Defenders>();
placementManager = PlacementManager.instance;
}
/// <summary>
///
/// </summary>
public override void Dispose()
{
Guild = null;
Defenders.Clear();
Defenders = null;
base.Dispose();
}
public void UpdateDefender()
{
SelectedDefender = Button.SelectedDefender.GetComponent <Defenders>();
UpdateInfo();
if (!IsVisible)
{
TurnVisible();
}
}
private bool IsBattleValid()
{
if (Attackers.Count == 0 || Defenders.Count == 0)
{
return(false);
}
// Check to see if all units in the defense is dead
// and make sure units can still see each other
return(Attackers.AllAliveCombatObjects().Any(combatObj => Defenders.HasInRange(combatObj)));
}
private void OnTriggerEnter2D(Collider2D collision)
{
Defenders defenders = collision.gameObject.GetComponent <Defenders>();
Health health = collision.gameObject.GetComponent <Health>();
if (defenders && health)
{
health.dealDamage(damage);
Debug.Log(name + " Dealt " + damage);
Destroy(gameObject);
}
}
// Use this for initialization
void Start()
{
if (Button.SelectedDefender)
{
SelectedDefender = Button.SelectedDefender.GetComponent <Defenders>();
}
gameObject.transform.localScale = new Vector3(0, 0, 0);
NamePool = GameObject.Find("NamePool").GetComponent <Text>();
HealthPool = GameObject.Find("HealthPool").GetComponent <Text>();
DamagePool = GameObject.Find("DamagePool").GetComponent <Text>();
CostPool = GameObject.Find("CostPool").GetComponent <Text>();
}
public static void HeroesAction(int turn, Attackers attackers, Defenders defenders)
{
bool attackerTurn = IsHeroTurn(turn, attackers.CurrentHeroPower);
bool defenderTurn = IsHeroTurn(turn, defenders.CurrentHeroPower);
bool hasDiv = false;
if (attackerTurn || defenderTurn)
{
hasDiv = true;
Game.Log.Add("<div class='heroesActions'>");
}
while (attackerTurn || defenderTurn)
{
if (attackerTurn && defenderTurn)
{
int attackerInitiative = DiceRoller.Throw(attackers.CurrentHero.Speed);
int defenderInitiative = DiceRoller.Throw(defenders.CurrentHero.Speed);
if (attackerInitiative.BiggerThan(defenderInitiative))
{
HeroCombat(attackers, defenders);
if (defenders.CurrentHero.Life > 0 && IsHeroTurn(turn, defenders.CurrentHeroPower))
HeroCombat(defenders, attackers);
}
else
{
HeroCombat(defenders, attackers);
if (attackers.CurrentHero.Life > 0 && IsHeroTurn(turn, attackers.CurrentHeroPower))
HeroCombat(attackers, defenders);
}
}
else
{
if (attackerTurn)
HeroCombat(attackers, defenders);
else if (defenderTurn)
HeroCombat(defenders, attackers);
}
if (attackers.Powers.Count > 0 && attackers.CurrentHeroPower.Executed) attackers.Powers.RemoveAt(0);
if (defenders.Powers.Count > 0 && defenders.CurrentHeroPower.Executed) defenders.Powers.RemoveAt(0);
Game.Log.Add("<br />");
attackerTurn = IsHeroTurn(turn, attackers.CurrentHeroPower);
defenderTurn = IsHeroTurn(turn, defenders.CurrentHeroPower);
}
if (hasDiv)
Game.Log.Add("</div>");
}
private void SetAttackAndDefense()
{
Attackers.Clear();
Defenders.Clear();
List <Actor> units_within_range = FindObjectsOfType <Actor>().
Where(actor => Vector3.Distance(actor.transform.position, transform.position) < influence_zone_radius).
ToList();
if (NodeFaction != null)
{
// attack and defense is determined by who currently claims the node
for (int i = 0; i < units_within_range.Count; i++)
{
Actor actor = units_within_range[i];
if (actor != null)
{
if (actor.CurrentFaction.IsHostileTo(NodeFaction))
{
if (!Attackers.Contains(actor) && actor != null)
{
Attackers.Add(actor);
}
}
else
{
if (!Defenders.Contains(actor) && actor != null)
{
Defenders.Add(actor);
}
}
}
}
}
else
{
// the attackers are the faction with the most units; everybody else can try to kill them
// NOTE: the faction that has the most units for the last boost gains the node (of course, then they have to keep it)
var faction_units = units_within_range
.GroupBy(unit => unit.CurrentFaction,
(faction, factions) => new {
Key = faction,
Count = factions.Count()
})
.OrderByDescending(faction => faction.Count);
Attackers.AddRange(units_within_range.Where(unit => unit.CurrentFaction == faction_units.First().Key));
}
}
public void Remove(ICombatGroup group, BattleSide side, ReportState state)
{
lock (battleLock)
{
// Remove from appropriate combat list
if (side == BattleSide.Attack)
{
if (!Attackers.Remove(group))
{
return;
}
group.CombatObjectAdded -= AttackerGroupOnCombatObjectAdded;
group.CombatObjectRemoved -= AttackerGroupOnCombatObjectRemoved;
}
else
{
if (!Defenders.Remove(group))
{
return;
}
group.CombatObjectAdded -= DefenderGroupOnCombatObjectAdded;
group.CombatObjectRemoved -= DefenderGroupOnCombatObjectRemoved;
}
// If battle hasnt started then dont worry about cleaning anything up since nothing has happened to these objects
if (!BattleStarted)
{
return;
}
// Snap a report of exit
BattleReport.WriteReportGroup(group, side == BattleSide.Attack, state);
// Tell objects to exit from battle
foreach (var co in group.Where(co => !co.Disposed))
{
co.ExitBattle();
}
// Send exit events
if (side == BattleSide.Attack)
{
WithdrawAttacker(this, group);
}
else
{
WithdrawDefender(this, group);
}
}
}
public void DbLoaderAddToCombatList(ICombatGroup group, BattleSide side)
{
if (side == BattleSide.Defense)
{
Defenders.Add(group, false);
}
else
{
Attackers.Add(group, false);
}
groupIdGen.Set(group.Id);
}
// Use this for initialization
void Start()
{
buttonArray = GameObject.FindObjectsOfType <Button>();
defenders = GameObject.FindObjectOfType <Defenders>();
costText = GetComponentInChildren <Text>();
if (!costText)
{
Debug.LogWarning(name + " has no cost ");
}
costText.text = defenderPrefab.GetComponent <Defenders>().starCost.ToString();
}
public void DbFinishedLoading()
{
uint maxId =
Math.Max(
Attackers.SelectMany(group => group)
.DefaultIfEmpty()
.Max(combatObject => combatObject == null ? 0 : combatObject.Id),
Defenders.SelectMany(group => group)
.DefaultIfEmpty()
.Max(combatObject => combatObject == null ? 0 : combatObject.Id));
idGen.Set(maxId);
}
void OnTriggerEnter2D(Collider2D col)
{
Defenders def = col.gameObject.GetComponent <Defenders>();
if (def && def.GetComponent <Health>())
{
this.animator.SetBool("IsAttacking", true);
this.attacker.Attack(col.gameObject);
}
else
{
return;
}
}
private void BringWaitingTroopsIntoBattle()
{
foreach (var defender in Defenders.AllCombatObjects().Where(co => co.IsWaitingToJoinBattle))
{
defender.JoinBattle(Round);
dbManager.Save(defender);
}
foreach (var attacker in Attackers.AllCombatObjects().Where(co => co.IsWaitingToJoinBattle))
{
attacker.JoinBattle(Round);
dbManager.Save(attacker);
}
}
public void HeroesPowers(int turns, Attackers attackers, Defenders defenders)
{
attackers.Powers = new List<HeroPower>();
defenders.Powers = new List<HeroPower>();
foreach (Hero hero in attackers.Heroes)
PowerList(turns, hero.Powers, attackers.Powers);
foreach (Hero hero in defenders.Heroes)
PowerList(turns, hero.Powers, defenders.Powers);
attackers.Powers = attackers.Powers.OrderBy(x => x.Turn).ToList();
defenders.Powers = defenders.Powers.OrderBy(x => x.Turn).ToList();
}
void OnMouseDown()
{
Vector2 rawPos = CalculateWorldPointOfMouseClick();
Vector2 roundedPos = SnapToGrid(rawPos);
GameObject defender = Button.selectedDefender;
Defenders defOjb = defender.GetComponent <Defenders> ();
if (StarDisplay.Status.SUCCESS == starDispaly.UseStar(defOjb.starCost))
{
SpawnDefender(roundedPos, defender);
}
else
{
Debug.Log("Insufficient stars");
}
}
public override void GetHtmlStatistics(Mobile viewer, StringBuilder html)
{
base.GetHtmlStatistics(viewer, html);
html.AppendLine("----------");
html.AppendLine("Flags Captured: {0:#,0}", GetTotalFlagsCaptured());
html.AppendLine("Flags Dropped: {0:#,0}", GetTotalFlagsDropped());
html.AppendLine("Flags Stolen: {0:#,0}", GetTotalFlagsStolen());
html.AppendLine("Flags Returned: {0:#,0}", GetTotalFlagsReturned());
html.AppendLine();
html.Append(String.Empty.WrapUOHtmlColor(System.Drawing.Color.LawnGreen, false));
html.AppendLine("Defenders:");
html.AppendLine();
string t;
var i = 0;
foreach (var o in Defenders.OrderBy(kv => kv.Value))
{
t = String.Format("{0:#,0}: {1} ({2:#,0} Returns)", ++i, o.Key.RawName, o.Value);
t = t.WrapUOHtmlColor(viewer.GetNotorietyColor(o.Key), SuperGump.DefaultHtmlColor);
html.AppendLine(t);
}
html.AppendLine();
html.Append(String.Empty.WrapUOHtmlColor(System.Drawing.Color.OrangeRed, false));
html.AppendLine("Attackers:");
html.AppendLine();
i = 0;
foreach (var o in Attackers.OrderBy(kv => kv.Value))
{
t = String.Format("{0:#,0}: {1} ({2:#,0} Captures)", ++i, o.Key.RawName, o.Value);
t = t.WrapUOHtmlColor(viewer.GetNotorietyColor(o.Key), SuperGump.DefaultHtmlColor);
html.AppendLine(t);
}
html.Append(String.Empty.WrapUOHtmlColor(SuperGump.DefaultHtmlColor, false));
}
public override string ToString()
{
StringBuilder sb = new StringBuilder();
sb.AppendLine(Gk.Info);
sb.AppendLine(string.Join(", ", Defenders.Select(x => x.Info)));
sb.AppendLine(string.Join(", ", Midfielders.Select(x => x.Info)));
sb.AppendLine(string.Join(", ", Forwards.Select(x => x.Info)));
sb.AppendLine("--------------------------");
sb.AppendLine(SubGk.Info);
sb.AppendLine(string.Join(", ", SubDefenders.Select(x => x.Info)));
sb.AppendLine(string.Join(", ", SubMidfielders.Select(x => x.Info)));
sb.AppendLine(string.Join(", ", SubForwards.Select(x => x.Info)));
return(sb.ToString());
}
public virtual void OnFlagReturned(PlayerMobile defender)
{
if (defender == null || Flag == null || Flag.Deleted || CTFBattle == null || CTFBattle.Deleted)
{
return;
}
if (Defenders.ContainsKey(defender))
{
Defenders[defender]++;
}
else
{
Defenders.Add(defender, 1);
}
Broadcast("[{0}]: {1} has returned your flag!", Name, defender.RawName);
CTFBattle.OnFlagReturned(Flag, defender);
}
void OnTriggerEnter2D(Collider2D col)
{
Defenders def = col.gameObject.GetComponent <Defenders>();
if (def && def.GetComponent <Health>())
{
if (def.GetComponent <Gravestone>())
{
this.Jump();
}
else
{
this.Attack(def);
}
}
else
{
return;
}
}
// private
private IEnumerator CheckClaim()
{
// TODO: we may want to alter the amount units boost or reduce the claim
while (true)
{
SetAttackAndDefense();
int net_offense = Attackers.Count - Defenders.Count; // Attackers and Defenders lists are managed by trigger stay/exit
if (net_offense != 0)
{
Faction attacking_faction = Attackers.Any() ? Attackers.First().CurrentFaction : null;
Faction defending_faction = Defenders.Any() ? Defenders.First().CurrentFaction : null;
if (net_offense > 0)
{
if (Claimed && NodeFaction != attacking_faction)
{
ReduceClaim(net_offense);
}
else if (!Claimed)
{
BoostClaim(net_offense, attacking_faction);
}
}
else if (net_offense < 0)
{
if (Claimed && NodeFaction == defending_faction)
{
BoostClaim(Mathf.Abs(net_offense), defending_faction);
}
}
UpdateClaimBar();
}
yield return(new WaitForSeconds(Turn.ActionThreshold));
}
}
public void RoundReport(int turn, Attackers attackers, Defenders defenders)
{
Game.Log.Add("<hr>");
Game.Log.Add(string.Format("<a name='turno{0}'> </a><h2>Obituário do round {0}</h2>", turn));
Game.Log.Add("<div class='attacker'>Atacantes</div>");
var attackersDied = (from atk in attackers.cemitery
orderby atk.Type
group atk by atk.Type);
foreach (var group in attackersDied)
Game.Log.Add(string.Format("<b>Tipo {1}:</b> {0}", group.Count<Unit>(), group.Key));
Game.Log.Add("<br />");
Game.Log.Add("<div class='defender'>Defensores</div>");
var defendersDied = (from dfr in defenders.cemitery
orderby dfr.Type
group dfr by dfr.Type);
foreach (var group in defendersDied)
Game.Log.Add(string.Format("<b>Tipo {1}:</b> {0}", group.Count<Unit>(), group.Key));
Game.Log.Add("<hr>");
}
public override void GetHtmlStatistics(Mobile viewer, StringBuilder html)
{
base.GetHtmlStatistics(viewer, html);
html.AppendLine("* Flags Captured: {0:#,0} / {1:#,0}", Caps, CTFBattle != null ? CTFBattle.CapsToWin : 0);
html.AppendLine();
html.Append("".WrapUOHtmlColor(System.Drawing.Color.LawnGreen, false));
html.AppendLine("Defenders: ");
html.AppendLine();
Defenders.OrderBy(kv => kv.Value)
.For(
(i, kv) =>
html.AppendLine(
"{0:#,0}: {1} ({2:#,0} Returns)".WrapUOHtmlColor(viewer.GetNotorietyColor(kv.Key), SuperGump.DefaultHtmlColor),
i + 1,
kv.Key.RawName,
kv.Value));
html.AppendLine();
html.Append("".WrapUOHtmlColor(System.Drawing.Color.OrangeRed, false));
html.AppendLine("Attackers: ");
html.AppendLine();
Attackers.OrderBy(kv => kv.Value)
.For(
(i, kv) =>
html.AppendLine(
"{0:#,0}: {1} ({2:#,0} Captures)".WrapUOHtmlColor(viewer.GetNotorietyColor(kv.Key), SuperGump.DefaultHtmlColor),
i + 1,
kv.Key.RawName,
kv.Value));
html.AppendLine();
html.Append("".WrapUOHtmlColor(SuperGump.DefaultHtmlColor, false));
}
void Start()
{
anim = GetComponent <Animator>();
defender = GetComponent <Defenders>();
}
public static void StartCombat(int turns, Attackers attackers, Defenders defenders)
{
attackers.ResetCemitery();
defenders.ResetCemitery();
if (defenders.Units.Count > 0 && attackers.Units.Count > 0)
{
Unit defender = null;
Unit attacker = null;
int i = 1;
while (i < turns && defenders.Units.Count + defenders.Heroes.Count > 0 && attackers.Units.Count + attackers.Heroes.Count > 0)
{
HeroesAction(i, attackers, defenders);
if (defenders.Units.Count > 0 && attackers.Units.Count > 0)
{
attacker = attackers.CurrentUnit;
defender = defenders.CurrentUnit;
UnitCombat.Fight(attackers.CurrentUnit, defender);
defenders.Units.RemoveAt(0);
attackers.Units.RemoveAt(0);
if (defender.Life > 0)
defenders.Units.Add(defender);
else
defenders.BuryUnit(defender);
if (attacker.Life > 0)
attackers.Units.Add(attacker);
else
attackers.BuryUnit(attacker);
Game.Log.Add("<br />");
}
i++;
}
}
}
void Attack(Defenders def)
{
//Debug.Log (this.name + " is attacking " + def.gameObject.name);
this.animator.SetBool("IsAttacking", true);
this.attacker.Attack(def.gameObject);
}
//private static void round_OnRoundExecution()
//{
// Round.IsRunning = true;
// System.Threading.Thread.Sleep(20000);
// Round.IsRunning = false;
//}
private void round_OnRoundExecution()
{
Round.IsRunning = true;
Game.Log.Clear();
World davi = World.Load(1);
World golias = World.Load(2);
Attackers attackers = new Attackers();
Defenders defenders = new Defenders();
int number = 1;
attackers.Units = new List<Unit>();
Unit unit = null;
Unit baseUnit = null;
foreach (WorldUnits worldUnit in davi.Units)
{
baseUnit = Unit.Find(worldUnit.UnitId);
if (baseUnit != null)
{
for (int j = 0; j < worldUnit.Quantity; j++)
{
unit = (Unit)baseUnit.Clone();
unit.Number = number;
unit.PositionInCombat = Unit.CombatPosition.attacker;
attackers.Units.Add(unit);
number += 1;
}
}
}
number = 1;
defenders.Units = new List<Unit>();
unit = null;
baseUnit = null;
foreach (WorldUnits worldUnit in golias.Units)
{
baseUnit = Unit.Find(worldUnit.UnitId);
if (baseUnit != null)
{
for (int j = 0; j < worldUnit.Quantity; j++)
{
unit = (Unit)baseUnit.Clone();
unit.Number = number;
unit.PositionInCombat = Unit.CombatPosition.defender;
defenders.Units.Add(unit);
number += 1;
}
}
}
attackers.Units = Util.ScrambleList<Unit>(attackers.Units);
defenders.Units = Util.ScrambleList<Unit>(defenders.Units);
Hero hero = null;
attackers.Heroes = new List<Hero>();
hero = Hero.Find(davi.HeroId);
hero.SetPowers();
attackers.Heroes.Add(hero);
defenders.Heroes = new List<Hero>();
hero = Hero.Find(golias.HeroId);
hero.SetPowers();
defenders.Heroes.Add(hero);
int turns = attackers.Units.Count.BiggerThan(defenders.Units.Count) ? attackers.Units.Count : defenders.Units.Count;
int rounds = 1; //round will be always one! refactor later
HeroesPowers(turns, attackers, defenders);
int i = 1;
while (i <= rounds && defenders.Units.Count + defenders.Heroes.Count > 0 && attackers.Units.Count + attackers.Heroes.Count > 0)
{
Game.Log.Add(string.Format("<h2>Round {0}</h2><p>Atacando: {1} unidades</p><p>Defendendo: {2} unidades</p>", i, attackers.Units.Count, defenders.Units.Count));
Game.StartCombat(turns, attackers, defenders);
#region LOG
Game.Log.Add(attackers.PV());
Game.Log.Add(defenders.PV());
RoundReport(i, attackers, defenders);
#endregion
//#region RESET
//generate.RoundResetUnitLives(attackers.Units);
//generate.RoundResetUnitLives(defenders.Units);
//attackers.ResetHeroes();
//defenders.ResetHeroes();
//#endregion
turns = attackers.Units.Count.BiggerThan(defenders.Units.Count) ? attackers.Units.Count : defenders.Units.Count;
HeroesPowers(turns, attackers, defenders);
i++;
}
Round.IsRunning = false;
CombatLog l = new CombatLog() { Log = string.Join("<br/>", Game.Log.ToArray()), CombatId = 1 };
l.Save();
}
