public HeroesData()
{
//all heroes
int allCount = AllHeros.heroes.Length;
allMaxHp = new float[allCount];
allAttackDamage = new float[allCount];
allCritChance = new float[allCount];
for (int i = 0; i < allCount; i++)
{
allMaxHp[i] = AllHeros.heroes[i].maxHP;
allAttackDamage[i] = AllHeros.heroes[i].attackDamage;
allCritChance[i] = AllHeros.heroes[i].critChance;
}
//heroes
count = Heroes.count;
id = new int[count];
currentHP = new float[count];
for (int i = 0; i < count; i++)
{
id[i] = Heroes.getHero(i).ID;
currentHP[i] = Heroes.getHero(i).currentHP;
}
}
public RegisterHeroCommandResult Save(Heroes hero)
{
_connection._collection.InsertOne(hero);
return(new RegisterHeroCommandResult {
Message = "Register Sucessuful", Sucess = true
});
}
internal void FinishConstruction()
{
this.IsConstructing = false;
if (Builder_Village)
{
this.Level.BuilderVillageWorkerManager.DeallocateWorker(this);
}
else
{
this.Level.VillageWorkerManager.DeallocateWorker(this);
}
SetUpgradeLevel(GetUpgradeLevel() + 1);
if (GetResourceProductionComponent() != null)
{
GetResourceProductionComponent().Reset();
}
int constructionTime = GetConstructionItemData().GetConstructionTime(GetUpgradeLevel());
this.Level.Avatar.AddExperience((int)Math.Pow(constructionTime, 0.5f));
if (GetHeroBaseComponent(true) != null)
{
Buildings data = (Buildings)GetData();
Heroes hd = CSV.Tables.Get(Gamefile.Heroes).GetData(data.HeroType) as Heroes;
Level.Avatar.SetUnitUpgradeLevel(hd, 0);
Level.Avatar.SetHeroHealth(hd, 0);
Level.Avatar.SetHeroState(hd, 3);
}
}
public override string ToString()
{
string pl = $"InGameName = {InGameName}, Username = {Username}, Password = {Password}, Money = {Money}, Played Time = {PlayedTime}, Heroes:";
Heroes.ForEach(h => pl += $"\n\t {h}");
return(pl);
}
/// <summary>Handles the message.</summary>
/// <param name="message">The message.</param>
public void Handle(GameStarted message)
{
EnsureInitialized();
GameMode = message.GameMode;
Hero = Heroes.FirstOrDefault(x => x.Key == message.Hero);
OpponentHero = Heroes.FirstOrDefault(x => x.Key == message.OpponentHero);
GoFirst = message.GoFirst;
StartTime = message.StartTime;
IsRunning = true;
Deck = deckManager.GetOrCreateDeckBySlot(BindableServerCollection.Instance.DefaultName, message.Deck);
events.PublishOnBackgroundThread(new ToggleFlyoutCommand(Flyouts.CurrentGame)
{
Show = true
});
events.PublishOnBackgroundThread(new ToggleFlyoutCommand(Flyouts.EditGame)
{
Show = false
});
var vm = IoC.Get <GameStartedBalloonViewModel>();
vm.SetGameResult(message);
events.PublishOnBackgroundThread(new TrayNotification("A new game has started", vm, 10000)
{
BalloonType = BalloonTypes.GameStartEnd
});
RefreshStats();
}
protected HeroCharacter AddHeroFor(Player player)
{
if (player == null)
{
throw new ArgumentNullException("player", "Player should not be null");
}
if (player.Hero != null && !player.Hero.Dying)
{
player.Hero.RemoveFromParent();
}
CGPoint spawnPos = DefaultSpawnCGPoint;
HeroCharacter hero = CreateHeroBy(player.HeroType, spawnPos, player);
if (hero != null)
{
var emitter = (SKEmitterNode)SharedSpawnEmitter.Copy();
emitter.Position = spawnPos;
AddNode(emitter, WorldLayer.AboveCharacter);
GraphicsUtilities.RunOneShotEmitter(emitter, 0.15f);
hero.FadeIn(2f);
hero.AddToScene(this);
Heroes.Add(hero);
}
player.Hero = hero;
return(hero);
}
private static void AutoTeaser(EventArgs args)
{
if (!IsEnableautoTether)
{
return;
}
if (TetherInCombo)
{
return;
}
var tether = Abilities.FindAbility("wisp_tether");
if (tether == null || tether.Level == 0 || !tether.CanBeCasted() || tether.IsHidden)
{
return;
}
var anyPossibleAlly =
Heroes.GetByTeam(Members.MyTeam)
.FirstOrDefault(
x =>
x != null && Helper.IsHeroEnableForTether(x.StoredName()) &&
x.Distance2D(Members.MyHero) <= tether.GetCastRange());
if (anyPossibleAlly == null)
{
return;
}
if (!_multiSleeper.Sleeping(tether))
{
tether.UseAbility(anyPossibleAlly);
_multiSleeper.Sleep(500, tether);
}
}
public void OnTriggerEnter(Collider other)
{
if (other.tag == "Ally")
{
enemy = other.GetComponent <Heroes>();
}
}
protected Base()
{
ObjConstants = new Constants();
ObjHeroes = new Heroes();
ObjMinions = new Minions();
ObjTurrets = new Turrets();
Menu = new Menu("AIM", "AIM", true);
//AIM Settings
Menu.AddItem(new MenuItem("Enabled", "Enabled").SetValue(new KeyBind(32, KeyBindType.Toggle)));
Menu.AddItem(new MenuItem("LowHealth", "Self Low Health %").SetValue(new Slider(20, 10, 50)));
//Humanizer
var move = Menu.AddSubMenu(new Menu("Humanizer", "humanizer"));
move.AddItem(new MenuItem("MovementEnabled", "Enabled").SetValue(true));
move.AddItem(new MenuItem("MovementDelay", "Movement Delay")).SetValue(new Slider(400, 0, 1000));
Menu.AddToMainMenu();
Console.WriteLine("Menu Init Success!");
ObjHQ = new HQ();
Orbwalker = Menu.AddSubMenu(new Menu("Orbwalker", "Orbwalker"));
OrbW = new Orbwalking.Orbwalker(Orbwalker);
Obj_AI_Base.OnIssueOrder += Obj_AI_Base_OnIssueOrder;
}
/// <summary>
/// The get remote mine damage.
/// </summary>
/// <param name="level">
/// The level.
/// </param>
/// <param name="classId">
/// The class id.
/// </param>
/// <param name="creep">
/// The creep.
/// </param>
/// <returns>
/// The <see cref="float" />.
/// </returns>
public float GetRemoteMineDamage(uint level, ClassID classId, Unit creep = null)
{
Dictionary <ClassID, float> dictionary;
if (!this.remoteMineDamageDictionary.TryGetValue(level, out dictionary))
{
var damage = Variables.Techies.AghanimState()
? Variables.RemoteMinesAbility.GetAbilityData("damage_scepter", level)
: Variables.RemoteMinesAbility.GetAbilityData("damage", level);
dictionary = Heroes.GetByTeam(Variables.EnemyTeam)
.ToDictionary(
hero => hero.ClassID,
hero => hero.DamageTaken(damage, DamageType.Magical, Variables.Techies));
}
if (!dictionary.ContainsKey(classId) &&
(classId == ClassID.CDOTA_BaseNPC_Creep || classId == ClassID.CDOTA_BaseNPC_Creep_Lane ||
classId == ClassID.CDOTA_BaseNPC_Creep_Siege))
{
dictionary.Add(
classId,
creep.DamageTaken(this.currentRemoteMineDamage, DamageType.Magical, Variables.Techies));
}
return(!dictionary.ContainsKey(classId) ? 0 : dictionary[classId]);
}
public void Swap()
{
Console.WriteLine($"Turns - Swap {Heroes.Count()}");
if (Active is Hero hero)
{
if (Heroes.Count < 2)
{
throw new Exception("cant swap if there is nothing swapable");
}
int index = Heroes.IndexOf(hero);
if (index == 0)
{
Active = Heroes.Last();
}
else
{
Active = Heroes[index - 1];
}
OnSwapped?.Invoke(this, new EventArgs());
}
else
{
throw new Exception("can't swap if there isnt a hero");
}
}
public override bool ShouldSpendGold()
{
if (!Utils.SleepCheck("GoldSpender.NearDeath.AllBought"))
{
return(false);
}
var disableTime = Menu.NearDeathAutoDisableTime;
if (!Menu.NearDeathEnabled || disableTime > 0 && Game.GameTime / 60 > disableTime || UnreliableGold < 20)
{
if (boughtItems.Any())
{
boughtItems.Clear();
}
return(false);
}
var distance = Menu.NearDeathEnemyDistance;
return((float)Hero.Health / Hero.MaximumHealth <= (float)Menu.NearDeathHpThreshold / 100 &&
(distance <= 0 ||
Heroes.GetByTeam(EnemyTeam)
.Any(x => !x.IsIllusion && x.IsAlive && x.Distance2D(Hero) <= distance)));
}
public async Task <ActionResult <Heroes> > PostHeroes(Heroes heroes)
{
_context.Heroes.Add(heroes);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetHeroes", new { id = heroes.HeroId }, heroes));
}
internal static void AddToMainMenu()
{
Menu = TargetSelector.Menu.AddSubMenu(new Menu("Weights", TargetSelector.Menu.Name + ".weights"));
Heroes.AddToWeightMenu();
Menu.AddItem(
new MenuItem(Menu.Name + ".caching", "Caching %").SetShared()
.SetValue(new Slider(ItemCache.MaxAge, MinCaching, MaxCaching)))
.SetTooltip("0 = Real Time Calculations | Milliseconds")
.ValueChanged += (sender, args) => ItemCache.MaxAge = args.GetNewValue <Slider>().Value;
foreach (var item in Items)
{
var localItem = item;
var weightItem =
new MenuItem(Menu.Name + "." + item.UniqueName, GetDisplayNamePrefix(item) + item.DisplayName)
.SetShared().SetValue(new Slider(localItem.Weight, MinWeight, MaxWeight));
if (!string.IsNullOrWhiteSpace(item.Tooltip))
{
weightItem.SetTooltip(item.Tooltip);
}
Menu.AddItem(weightItem);
Menu.Item(Menu.Name + "." + item.UniqueName).ValueChanged +=
delegate(object sender, OnValueChangeEventArgs args)
{
localItem.OnWeightChange(args.GetNewValue <Slider>().Value);
};
item.Weight = TargetSelector.Menu.Item(Menu.Name + "." + item.UniqueName).GetValue <Slider>().Value;
}
ItemCache.MaxAge = Utils.GetMenuItemValue <int>(Menu, ".caching");
Game.OnInput += OnGameInput;
}
public static IEnumerable <Targets.Item> OrderChampions(IEnumerable <Targets.Item> targets)
{
if (targets == null)
{
return(new List <Targets.Item>());
}
var targetList = targets.ToList();
foreach (var item in Items.Where(w => w.Weight > 0))
{
UpdateMaxMinValue(item, targetList);
}
foreach (var target in targetList)
{
target.Weight = Items.Where(w => w.Weight > 0).Sum(w => CalculatedWeight(w, target)) / 100 *
Heroes.GetPercentage(target.Hero);
}
return(Selected.Focus.Enabled && Selected.Focus.Force && targetList.Count > 1
? new List <Targets.Item> {
targetList.OrderByDescending(t => t.Weight).First()
}
: targetList.OrderByDescending(t => t.Weight).ToList());
}
private bool RemoteCreateGame(out Heroes.Core.Player player)
{
player = null;
Heroes.Core.Remoting.RegisterServer register = new Heroes.Core.Remoting.RegisterServer();
register._hostName = this.txtServerIp.Text;
Heroes.Core.Remoting.Game adp = null;
adp = (Heroes.Core.Remoting.Game)register.GetObject(
typeof(Heroes.Core.Remoting.Game),
Heroes.Core.Remoting.Game.CLASSNAME);
if (adp == null)
{
MessageBox.Show("Error");
return false;
}
try
{
adp.CreateGame(out player);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
return false;
}
return true;
}
/// <summary>
/// The highest health points target.
/// </summary>
/// <param name="source">
/// The source hero (LocalHero).
/// </param>
/// <param name="range">
/// The range.
/// </param>
/// <returns>
/// The <see cref="Hero" />.
/// </returns>
public static Hero HighestHealthPointsTarget(Unit source, float range)
{
return
(Heroes.GetByTeam(source.GetEnemyTeam())
.Where(hero => hero.IsValid && hero.IsAlive && hero.IsVisible && hero.Distance2D(source) <= range)
.MaxOrDefault(hero => hero.Health));
}
public void End()
{
Completed.Add(Active);
var oldActive1 = Active;
Console.WriteLine($"Turns - {oldActive1} ends turn - Start");
bool containsEveryone = Enemies.All(enemy => enemy.EnemyType == EnemyType.Enviroment || Completed.Contains(enemy) || enemy.IsDead);
bool containsHeroes = Heroes.Where(hero => hero is Hero && hero.Actions.Count() > 0)
.All((hero) => Completed.Contains(hero));
if (Heroes.Where(hero => hero is Hero && hero.Actions.Count() > 0).All((hero) => Completed.Contains(hero)) && !containsEveryone)
{
Active = Enemies.First(enemy => enemy.EnemyType != EnemyType.Enviroment && !Completed.Contains(enemy) && enemy.IsAlive());
}
else
{
var oldActive = Active;
foreach (Hero hero in Heroes)
{
Console.WriteLine($"------ {hero}");
}
if (containsEveryone && containsHeroes)
{
Completed.Clear();
Console.WriteLine($"-------- yoyo");
oldActive = null;
}
var nextTurn = Heroes.First((hero) => hero != oldActive && hero.Actions.Length > 0);
Console.WriteLine($"-------- next Turn = {nextTurn}");
Active = nextTurn;
}
Console.WriteLine($"--------- {oldActive1} ends turn, new active is now {Active} - END");
}
public void Execute()
{
if (!hasArmlet())
{
return;
}
this.armletToggler = new ArmletToggler(me.FindItem("item_armlet"));
if (me.IsAttacking() && Heroes.GetByTeam(Variables.EnemyTeam)
.Any(x => x.IsValid && x.IsAlive && x.IsVisible &&
x.Distance2D(Variables.Hero) < x.GetAttackRange() + 200))
{
if (Utils.SleepCheck("TurnOn"))
{
armletToggler.TurnOn();
Utils.Sleep(1000, "TurnOn");
}
}
if (me.Health > thresholdHP)
{
return;
}
if (armletToggler.CanToggle)
{
if (Utils.SleepCheck("toggle"))
{
armletToggler.Toggle();
Utils.Sleep(1000, "toggle");
}
}
}
public void AddHero(HeroEntity entity)
{
if (entity != null)
{
Heroes.Add(entity);
}
}
public async Task <HeroesManagementDto> GetHeroesToModify(int heroId)
{
HeroesManagementDto heroToReturn = new HeroesManagementDto();
Heroes hero = await _context.Heroes.FirstOrDefaultAsync(x => x.Id == heroId);
HeroeStats heroStats = await _context.HeroeStats.FirstOrDefaultAsync(x => x.HeroId == hero.Id);
heroToReturn.AbilityPower = heroStats.AbilityPower;
heroToReturn.ApLifeSteal = heroStats.ApLifeSteal;
heroToReturn.Armour = heroStats.Armour;
heroToReturn.ArmourPenetration = heroStats.ArmourPenetration;
heroToReturn.ArmourPenetrationProc = heroStats.ArmourPenetrationProc;
heroToReturn.AttackDamage = heroStats.AttackDamage;
heroToReturn.AttackSpeed = heroStats.AttackSpeed;
heroToReturn.CooldownReduction = heroStats.CooldownReduction;
heroToReturn.CriticalChance = heroStats.CriticalChance;
heroToReturn.HeroName = hero.HeroName;
heroToReturn.HitPoints = heroStats.HitPoints;
heroToReturn.HitPointsRegen = heroStats.HitPointsRegen;
heroToReturn.LifeSteal = heroStats.LifeSteal;
heroToReturn.MagicPenetration = heroStats.MagicPenetration;
heroToReturn.MagicPenetrationProc = heroStats.MagicPenetrationProc;
heroToReturn.MagicResistance = heroStats.MagicResistance;
heroToReturn.Mana = heroStats.Mana;
heroToReturn.ManaRegen = heroStats.ManaRegen;
heroToReturn.MovementSpeed = heroStats.MovementSpeed;
heroToReturn.Range = heroStats.Range;
heroToReturn.Tenacity = heroStats.Tenacity;
return(heroToReturn);
}
public Heroes GetHeroInformation(int id)
{
Heroes hero = new Heroes();
hero.heroId = id;
var heroInformation = (from r in context.Heroes
where r.heroId == id
select r.heroName).FirstOrDefault();
hero.heroName = heroInformation.ToString();
heroInformation = (from r in context.Heroes
where r.heroId == id
select r.alterEgoName).FirstOrDefault();
hero.alterEgoName = heroInformation.ToString();
heroInformation = (from r in context.Heroes
where r.heroId == id
select r.primaryAbility).FirstOrDefault();
hero.primaryAbility = heroInformation.ToString();
heroInformation = (from r in context.Heroes
where r.heroId == id
select r.secondaryAbility).FirstOrDefault();
hero.secondaryAbility = heroInformation.ToString();
heroInformation = (from r in context.Heroes
where r.heroId == id
select r.catchphrase).FirstOrDefault();
hero.catchphrase = heroInformation.ToString();
return(hero);
}
public void InitializeBuilding(Dictionary <string, UpgradePurchases> purchases)
{
Heroes.Clear();
EventHeroes.Clear();
GraveIndexes.Clear();
Reset();
for (int i = RosterSlotUpgrades.Count - 1; i >= 0; i--)
{
if (purchases[RosterSlotUpgrades[i].TreeId].PurchasedUpgrades.Contains(RosterSlotUpgrades[i].UpgradeCode))
{
RosterSlots = RosterSlotUpgrades[i].NumberOfSlots;
break;
}
}
for (int i = RecruitSlotUpgrades.Count - 1; i >= 0; i--)
{
if (purchases[RecruitSlotUpgrades[i].TreeId].PurchasedUpgrades.Contains(RecruitSlotUpgrades[i].UpgradeCode))
{
RecruitSlots = RecruitSlotUpgrades[i].NumberOfSlots;
break;
}
}
for (int i = RecruitExperienceUpgrades.Count - 1; i >= 0; i--)
{
if (purchases[RecruitExperienceUpgrades[i].TreeId].PurchasedUpgrades.Contains(RecruitExperienceUpgrades[i].UpgradeCode))
{
CurrentRecruitMaxLevel = RecruitExperienceUpgrades[i].Level;
break;
}
}
}
private static void Game_OnIngameUpdate(EventArgs args)
{
if (sleeper.Sleeping)
{
return;
}
sleeper.Sleep(1000);
var dcedAlly = Heroes.GetByTeam(heroTeam).Any(x => x.Player == null);
if (Game.IsPaused)
{
if (Menu.Item("enabledUnpause").GetValue <bool>() &&
(Menu.Item("ignoreAlly").GetValue <bool>() || !dcedAlly))
{
Game.ExecuteCommand("dota_pause");
//prevent const interval console spam, just in case...
sleeper.Sleep(Random.Next(1111, 1222));
}
}
else if (dcedAlly && Menu.Item("enabledPause").GetValue <bool>() && !Menu.Item("ignoreAlly").GetValue <bool>())
{
Game.ExecuteCommand("dota_pause");
//prevent const interval console spam, just in case...
sleeper.Sleep(Random.Next(3333, 4444));
}
}
public static async void OnUpdate(EventArgs args)
{
if (!IsEnable)
{
return;
}
if (!Members.MyHero.IsAlive)
{
return;
}
if (_attacker == null)
{
_attacker = new Sleeper();
}
if (_spellSleeper == null)
{
_spellSleeper = new MultiSleeper();
}
if (_ethereal == null)
{
_ethereal = new Sleeper();
}
if (_laser == null)
{
_laser = Abilities.FindAbility("tinker_laser");
}
if (_rockets == null)
{
_rockets = Abilities.FindAbility("tinker_heat_seeking_missile");
}
if (_spellSleeper.Sleeping(Abilities.FindAbility("tinker_rearm")))
{
return;
}
if (_testCombo != null && !_testCombo.IsCompleted)
{
return;
}
_tks = new CancellationTokenSource();
_testCombo = Action(_tks.Token);
try
{
await _testCombo;
_testCombo = null;
}
catch (OperationCanceledException)
{
_testCombo = null;
}
if (IsEnableKillSteal && !IsComboHero)
{
foreach (var x in Heroes.GetByTeam(Members.MyHero.GetEnemyTeam())
.Where(x => x.IsAlive && x.IsVisible && !x.IsIllusion() && !x.IsMagicImmune())
.Where(x => Helper.CalculateMyCurrentDamage(x, true) < 0))
{
await DoTrash(x, CancellationToken.None, true);
}
}
}
public void ChooseHeroes()
{
logger.Print($"{Name} is choosing heroes!");
for (int i = 0; i < 4; i++)
{
logger.Print($"Choose {i + 1} hero");
logger.Print("1.Swordsman\n2.Knight\n3.Defender\n4.Wizzard");
int hero = logger.Parse(1, 4);
switch (hero)
{
case 1:
Heroes.Add(new Swordsman(this));
break;
case 2:
Heroes.Add(new Knight(this));
break;
case 3:
Heroes.Add(new Defender(this));
break;
case 4:
Heroes.Add(new Wizzard(this));
break;
}
}
}
IEnumerator AbilityTwoEnum()
{
Fighter f = BattleSystem.friendlyCurrentFighter;
float critChanceRoll = Random.value * 100;
float damage = BattleSystem.friendlyCurrentFighter.attackDamage;
int lowestHpFriendly = getLowestHpFriendlyIndex();
if (critChanceRoll <= BattleSystem.friendlyCurrentFighter.critChance)
{
damage *= 1.5f;
}
bool isDead = BattleSystem.enemyCurrentFighter.TakeDamage((int)damage);
setBattleText("<color=blue>Lifestealer</color> hits for <color=red>" + (int)damage + "</color> damage", 1);
BattleSystem.friendlyCurrentPrefab.GetComponent <Animator>().SetTrigger("Attack");
FindObjectOfType <AudioManager>().Play("Attack1");
yield return(new WaitForSeconds(1));
int amount = (int)(0.03 * Heroes.getHero(lowestHpFriendly).maxHP);
Heroes.getHero(lowestHpFriendly).Heal(amount);
setBattleText("<color=blue>Lifestealer</color> restores <color=green>" + amount + "</color> HP", 1);
FindObjectOfType <AudioManager>().Play("Heal1");
yield return(new WaitForSeconds(1));
}
/// <summary>
/// The get remote mine damage.
/// </summary>
/// <param name="level">
/// The level.
/// </param>
/// <param name="handle">
/// The handle.
/// </param>
/// <param name="creep">
/// The creep.
/// </param>
/// <returns>
/// The <see cref="float" />.
/// </returns>
public float GetRemoteMineDamage(uint level, uint handle, Unit creep = null)
{
Dictionary <uint, float> dictionary;
if (!this.remoteMineDamageDictionary.TryGetValue(level, out dictionary))
{
var damage = Variables.Techies.AghanimState()
? Variables.RemoteMinesAbility.GetAbilityData("damage_scepter", level)
: Variables.RemoteMinesAbility.GetAbilityData("damage", level);
dictionary =
Heroes.GetByTeam(Variables.EnemyTeam)
.Where(x => x.IsValid && !x.IsIllusion)
.ToDictionary(
hero => hero.Handle,
hero => hero.DamageTaken(damage, DamageType.Magical, Variables.Techies));
}
if (!dictionary.ContainsKey(1) && creep != null)
{
handle = 1;
dictionary.Add(
1,
creep.DamageTaken(this.CurrentRemoteMineDamage, DamageType.Magical, Variables.Techies));
}
return(!dictionary.ContainsKey(handle) ? 0 : dictionary[handle]);
}
public JsonResult Post(Heroes heroe)
{
string query = @"insert into dbo.Heroe values
(
'" + heroe.id + @"',
'" + heroe.name + @"'
)";
DataTable table = new DataTable();
string sqlDataSource = _configuration.GetConnectionString("HeroTourAppCon");
SqlDataReader myReader;
using (SqlConnection myCon = new SqlConnection(sqlDataSource))
{
myCon.Open();;
using (SqlCommand myComand = new SqlCommand(query, myCon))
{
myReader = myComand.ExecuteReader();
table.Load(myReader);
myReader.Close();
myCon.Close();
}
}
return(new JsonResult("BIEN"));
}
IEnumerator AbilityFourEnum()
{
Fighter f = BattleSystem.friendlyCurrentFighter;
float critChanceRoll = Random.value * 100;
Fighter[] eArray = FindObjectOfType <BattleSystem>().getAllFightersArray();
float damage = BattleSystem.friendlyCurrentFighter.attackDamage * f.maxHP / f.currentHP / 2;
if (critChanceRoll <= BattleSystem.friendlyCurrentFighter.critChance)
{
damage *= 1.5f;
}
for (int i = 0; i < eArray.Length; i++)
{
bool isDead = eArray[i].TakeDamage((int)damage);
setBattleText("<color=blue>Lifestealer</color> hits for <color=red>" + (int)damage + "</color> damage", 1);
BattleSystem.friendlyCurrentPrefab.GetComponent <Animator>().SetTrigger("Attack");
}
FindObjectOfType <AudioManager>().Play("Attack2");
yield return(new WaitForSeconds(1));
for (int i = 0; i < Heroes.count; i++)
{
int amount = (int)(0.02 * Heroes.getHero(i).maxHP);
Heroes.getHero(i).Heal(amount);
setBattleText("<color=blue>All alies</color> restores <color=green>" + amount + "</color> HP", 1);
}
FindObjectOfType <AudioManager>().Play("Heal1");
yield return(new WaitForSeconds(1));
}
public static HeroEntity GetHero(Heroes hero)
{
HeroEntity entity = new HeroEntity(hero);
entity.Load();
return(entity);
}
public void GetBattleSettings(out Heroes.Core.Player attackPlayer, out Heroes.Core.Hero attackHero, out Hashtable attackArmies,
out Heroes.Core.Player defendPlayer, out Heroes.Core.Hero defendHero, out Heroes.Core.Town defendCastle, out Hashtable defendArmies)
{
GameSetting.ConvertBattleToNetwork(GameSetting._attackPlayer, GameSetting._attackHero, GameSetting._attackArmies,
GameSetting._defendPlayer, GameSetting._defendHero, GameSetting._defendCastle, GameSetting._defendArmies,
out attackPlayer, out attackHero, out attackArmies,
out defendPlayer, out defendHero, out defendCastle, out defendArmies);
}
private void PplArmies(Heroes.Core.Hero hero)
{
foreach (Heroes.Core.Army army in hero._armyKSlots.Values)
{
this._lblArmyNames[army._slotNo].Text = army._name;
this._lblArmyQtys[army._slotNo].Text = army.GetArmySize();
}
}
public static Army CreateArmy(Heroes.Core.Army army, Controller controller, ArmySideEnum armySide)
{
Heroes.Core.Battle.Characters.Armies.Army army2
= new Army(armySide, controller, army._id);
army2.CopyFrom(army);
return army2;
}
public void Show(IWin32Window owner, Heroes.Core.Battle.Characters.Armies.Army army)
{
this.picPortrait.Image = army._portrait;
this.lblName.Text = army._name;
// attack
{
System.Text.StringBuilder sbAttack = new StringBuilder();
sbAttack.AppendFormat("{0}", army._basicAttack);
if (army._basicAttack != army._attack)
sbAttack.AppendFormat("({0})", army._attack);
this.lblAttack.Text = sbAttack.ToString();
}
// defense
{
System.Text.StringBuilder sbDefense = new StringBuilder();
sbDefense.AppendFormat("{0}", army._basicDefense);
if (army._basicDefense != army._defense)
sbDefense.AppendFormat("({0})", army._defense);
this.lblDefense.Text = sbDefense.ToString();
}
// speed
{
System.Text.StringBuilder sb = new StringBuilder();
sb.AppendFormat("{0}", army._basicSpeed);
if (army._basicSpeed != army._speed)
sb.AppendFormat("({0})", army._speed);
this.lblSpeed.Text = sb.ToString();
}
this.lblDamage.Text = string.Format("{0}-{1}", army._minDamage, army._maxDamage);
if (army._hasRangeAttack)
this.lblShot.Text = army._shotRemain.ToString();
else
this.lblShot.Text = "";
// health
{
System.Text.StringBuilder sb = new StringBuilder();
sb.AppendFormat("{0}", army._basicHealth);
if (army._basicHealth != army._health)
sb.AppendFormat("({0})", army._health);
this.lblHealth.Text = sb.ToString();
}
if (army._isDead)
this.lblHealthRemain.Text = "Dead";
else
this.lblHealthRemain.Text = army._healthRemain.ToString();
this.Show(owner);
}
public DialogResult ShowDialog(Heroes.Core.Hero hero)
{
this.lblHeroName.Text = hero._name;
this.lblHeroLevel.Text = string.Format("Level {0} {1}", hero._level, hero.GetHeroTypeName());
Clear();
PplArmies(hero);
return this.ShowDialog();
}
public void Show(IWin32Window owner, Heroes.Core.Battle.Characters.Hero hero)
{
this.lblLevel.Text = string.Format("Level {0} {1}", hero._level, hero.GetHeroTypeName());
this.lblAttack.Text = hero._attack.ToString();
this.lblDefense.Text = hero._defense.ToString();
this.lblPower.Text = hero._power.ToString();
this.lblKnowledge.Text = hero._knowledge.ToString();
this.lblSpellPoint.Text = string.Format("{0}/{1}", hero._spellPointLeft, hero._maxSpellPoint);
Show(owner);
}
public BattleEngine(Controller controller, Heroes.Core.Hero attacker,
Heroes.Core.Hero defender, Heroes.Core.Monster monster, Heroes.Core.Town castle)
: base()
{
_isFirstRun = true;
_disableControl = false;
_controller = controller;
_inputCommand = new InputCommand();
_battleTerrain = new Heroes.Core.Battle.Terrains.BattleTerrain(controller);
_spells = new Hashtable();
_spellActions = new ArrayList();
// init hero and armies
{
_activeCharacters = new ArrayList();
InitHero(attacker, ArmySideEnum.Attacker, controller, out _attacker);
if (defender != null)
{
InitHero(defender, ArmySideEnum.Defender, controller, out _defender);
}
if (monster != null)
{
InitMonster(monster, ArmySideEnum.Defender, controller, out _monster);
}
// sort armies by speed
SortBySpeed(_activeCharacters);
}
// initialize graphics
{
foreach (StandardCharacter c in _activeCharacters)
{
c.Initalize();
c.Command = _inputCommand;
c.Command.InitalizeGraphics(c);
}
_attacker.Initalize();
if (_defender != null) _defender.Initalize();
}
_turn = new Turn(_activeCharacters, _attacker, _defender);
_turn.NextTurned += new Turn.NextTurnedEventHandler(_turn_NextTurned);
_actions = new ArrayList();
}
public DialogResult ShowDialog(Heroes.Core.Town town, Building buildingPurArmy)
{
_town = town;
_building = buildingPurArmy;
this.lblCost.Text = _building._gold.ToString();
this.txtQty.Text = _building._armyQty.ToString();
this.lblAv.Text = this.txtQty.Text;
int amt = Heroes.Core.Army.CalculateAmt(_building._armyQty, _building._gold);
lblAmt.Text = amt.ToString();
return this.ShowDialog();
}
/// <summary>
/// Gathers all the data from the Dotabuff Hero-Page and combines it into an Hero object.
/// </summary>
/// <param name="heroEnum">The Hero of your choice</param>
/// <returns>Will return the Hero of your choice</returns>
public IHero GetHeroPageData(Heroes heroEnum)
{
if (heroEnum == Heroes.Undefined)
{
throw new Exception("You can't select an undefined Hero!");
}
try
{
return mainController.HeroController.GetExtendedHero(heroEnum);
}
catch (Exception exception)
{
throw new Dota2StatParserException("Something went wrong while parsing the hero. See the innerexception for details!", exception);
}
}
public void revive(Heroes.Hero hero)
{
if (level >= Revive.levelRequired)
{
mana -= Revive.mana;
}
else
{
mana -= 1000;
}
if(hero != null)
{
hero.health = hero.maxHealth / 2;
hero.mana = hero.maxMana / 4;
}
}
public DialogResult ShowDialog(Heroes.Core.Battle.Characters.Hero hero)
{
_hero = hero;
foreach (Heroes.Core.Spell spell in hero._spells.Values)
{
_spells.Add(spell);
}
this.lblSpellPoint.Text = _hero._spellPointLeft.ToString();
Clear();
PplSpells();
return this.ShowDialog();
}
public DialogResult ShowDialog(Heroes.Core.Hero hero)
{
_hero = hero;
lblTitle.Text = string.Format("{0} has gain a level.", hero._name);
lblLevel.Text = string.Format("{0} is now a level {1} {2}.", hero._name, hero._level + 1, hero.GetHeroTypeName());
if (System.IO.File.Exists(hero._infoImgFileName))
this.picHero.Image = Image.FromFile(hero._infoImgFileName);
else
this.picHero.Image = null;
GetSkillAv();
PplSkills();
return this.ShowDialog();
}
public Turn(ArrayList characters,
Heroes.Core.Battle.Characters.Hero attackHero, Heroes.Core.Battle.Characters.Hero defendHero)
{
_characters = characters;
if (_characters.Count > 0)
{
_currentCharacter = (StandardCharacter)_characters[0];
_currentCharacter._isBeginTurn = true;
//_currentCharacter._action = _currentCharacter.CreateStandingAction(_currentCharacter, _currentCharacter.CurrentFacingDirection, _currentCharacter._isBeginTurn);
//_currentCharacter.SetAnimation(_currentCharacter._action._currentAnimationSeq);
}
else
_currentCharacter = null;
_attackHero = attackHero;
_defendHero = defendHero;
}
public void CreateGame(out Heroes.Core.Player player)
{
player = null;
lock (GameSetting._lockMe)
{
GameSetting._players.Clear();
GameSetting._currentPlayerId = 0;
GameSetting._isWaitToJoinGame = true;
GameSetting._playerStartingGames.Clear();
GameSetting._playerGameStarteds.Clear();
GameSetting._isGameStarted = false;
int playerId = 1;
CreatePlayer(playerId);
player = (Heroes.Core.Player)GameSetting._playerKIds[playerId];
}
}
public DialogResult ShowDialog(Heroes.Core.Hero hero)
{
_hero = hero;
if (System.IO.File.Exists(_hero._infoImgFileName))
picHero.Image = Image.FromFile(_hero._infoImgFileName);
else
picHero.Image = null;
this.lblHeroName.Text = _hero._name;
this.lblHeroLevel.Text = string.Format("Level {0} {1}", _hero._level, _hero.GetHeroTypeName());
this.lblExp.Text = _hero._experience.ToString();
PplAtts();
PplSkills();
PplArtifacts();
return this.ShowDialog();
}
public Turn(ArrayList characters,
Heroes.Core.Battle.Heros.Hero attackHero, Hashtable attackArmies,
Heroes.Core.Battle.Heros.Hero defendHero, Heroes.Core.Battle.Quick.Monster monster, Hashtable defendArmies)
{
_characters = characters;
_attackArmies = attackArmies;
_defendArmies = defendArmies;
if (_characters.Count > 0)
{
_currentCharacter = (Heroes.Core.Battle.Armies.Army)_characters[0];
_currentCharacter._isBeginTurn = true;
}
else
_currentCharacter = null;
_attackHero = attackHero;
_defendHero = defendHero;
_monster = monster;
FindHero();
}
private bool ExecuteBattleCommand(Heroes.Core.Remoting.BattleCommand cmd)
{
lock (_lockMe)
{
_frmBattle.ExecuteCommand(cmd);
}
return true;
}
public void AddArtifacts(Heroes.Core.Heros.Artifact a)
{
this._artifacts.Add(a._id, a);
Heroes.Core.Heros.Artifact[] artifacts = (Heroes.Core.Heros.Artifact[])this._artifactKEquips[a._equipPart];
for (int i = 0; i < artifacts.Length; i++)
{
if (artifacts[i] == null)
{
artifacts[i] = a;
return;
}
}
this._artifactUnequips.Add(a);
}
private bool RemoteGetArtifact(Heroes.Core.Heros.ArtifactLevelEnum level, out int id)
{
id = 0;
Heroes.Core.Remoting.RegisterServer register = new Heroes.Core.Remoting.RegisterServer();
register._hostName = Setting._remoteHostName;
Heroes.Core.Remoting.Game adp = null;
adp = (Heroes.Core.Remoting.Game)register.GetObject(
typeof(Heroes.Core.Remoting.Game),
Heroes.Core.Remoting.Game.CLASSNAME);
if (adp == null)
{
MessageBox.Show("Error");
return false;
}
try
{
id = adp.GetRndArtifactId((int)level);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
return false;
}
return true;
}
public HellIfIKnowController(Heroes heroes)
{
_heroes = heroes;
}
public static Action CreateCastSpellAction(Heroes.Core.Battle.Characters.Hero hero,
Heroes.Core.Battle.Characters.Spells.Spell spell,
CellPartEnum attackDirection,
ArrayList targets, Cell targetCell)
{
Action action = new Action(ActionTypeEnum.Spell);
SubAction subAction = new SubAction();
action._subActions.Add(subAction);
subAction._character = hero;
// hero casting animation
AnimationSequence startCastSpellSeq = subAction.AddStartCasting(attackDirection);
AnimationSequence stopCastSpellSeq = subAction.AddStopCasting(attackDirection);
stopCastSpellSeq._waitToTrigger = true;
// add casting
AnimationSequence spellSeq = null;
AnimationSequence spellHitSeq = null;
AnimationSequence hitSeq = null;
foreach (Heroes.Core.Battle.Characters.ICharacter target in targets)
{
// spell animate
{
SubAction subAction2 = new SubAction();
action._subActions.Add(subAction2);
subAction2._character = spell;
PointF destPoint = spell._destCell.GetStandingPoint();
if (spell._isMissile)
{
// move missile
PointF srcPoint = hero._castingPointRight;
spell._currentAnimationPt = srcPoint;
destPoint.Y -= hero._castingHeight;
Character.CalculateFlySpeed(srcPoint, destPoint,
spell._defaultMoveSpeed,
out spell._moveSpeedX, out spell._moveSpeedY);
spellSeq = subAction2.AddMissileSpell(destPoint, attackDirection, AnimationPurposeEnum.Moving);
subAction2._currentAnimationSeq = spellSeq;
}
else
{
spell._currentAnimationPt = destPoint;
spellSeq = subAction2.AddOnArmySpell(destPoint, attackDirection, AnimationPurposeEnum.CastSpell);
subAction2._currentAnimationSeq = spellSeq;
}
// hit
if (spell._isHit)
{
spellHitSeq = subAction2.AddSpellHit(destPoint, attackDirection);
subAction2._currentAnimationSeq = spellSeq;
}
}
// target
if (spell._isDamage)
{
Heroes.Core.Battle.Characters.Armies.Army army
= (Heroes.Core.Battle.Characters.Armies.Army)target;
SubAction subAction2 = new SubAction();
action._subActions.Add(subAction2);
subAction2._character = target;
if (army._isDead)
hitSeq = subAction2.AddDeath(attackDirection);
else if (army._isDefend)
hitSeq = subAction2.AddDefend(attackDirection);
else
hitSeq = subAction2.AddGettingHit(attackDirection);
hitSeq._waitToTrigger = true;
subAction2._currentAnimationSeq = hitSeq;
}
}
startCastSpellSeq._waitToTrigger = false;
startCastSpellSeq._triggerWhenEnd = true;
startCastSpellSeq._triggerAnimationSeqs.Add(spellSeq);
spellSeq._waitToTrigger = true;
spellSeq._triggerWhenEnd = true;
if (spell._isHit)
{
spellHitSeq._waitToTrigger = true;
spellSeq._triggerAnimationSeqs.Add(spellHitSeq);
}
if (spell._isDamage)
{
hitSeq._waitToTrigger = true;
spellSeq._triggerAnimationSeqs.Add(hitSeq);
}
stopCastSpellSeq._waitToTrigger = true;
spellSeq._triggerAnimationSeqs.Add(stopCastSpellSeq);
subAction._currentAnimationSeq = (AnimationSequence)subAction._animationSeqs[0];
return action;
}
private void InitPlayer(Heroes.Core.Player player)
{
Random rnd = new Random();
int heroId = 0;
do
{
heroId = rnd.Next(1, 16);
}
while (GameSetting._heroKIds.ContainsKey(heroId));
GameSetting._heroKIds.Add(heroId, heroId);
GameSetting._startingHeroKPlayerId.Add(player._id, heroId);
}
public void SetStartingBattle(Heroes.Core.Hero attackHero, Heroes.Core.Hero defendHero)
{
lock (GameSetting._lockMe)
{
GameSetting._attackHero = attackHero;
GameSetting._defendHero = defendHero;
GameSetting._playerNeedToStartBattles.Clear();
GameSetting._playerNeedToStartBattles.Add(attackHero._playerId, true);
GameSetting._playerNeedToStartBattles.Add(defendHero._playerId, true);
}
}
public void SetPlayer(Heroes.Core.Player player)
{
if (!GameSetting._playerKIds.ContainsKey(player._id)) return;
GameSetting._playerKIds[player._id] = player;
int index = Heroes.Core.Player.FindPlayerIndex(GameSetting._players, player._id);
if (index < 0) return;
GameSetting._players[index] = player;
}
public void JoinGame(out Heroes.Core.Player player)
{
player = null;
if (!GameSetting._isWaitToJoinGame) return;
lock (GameSetting._lockMe)
{
int playerId = GameSetting._players.Count + 1;
CreatePlayer(playerId);
player = (Heroes.Core.Player)GameSetting._playerKIds[playerId];
}
}
private bool RemoteGetPlayer(int playerId, out Heroes.Core.Player player)
{
player = null;
Heroes.Core.Remoting.RegisterServer register = new Heroes.Core.Remoting.RegisterServer();
register._hostName = Setting._remoteHostName;
Heroes.Core.Remoting.Game adp = null;
adp = (Heroes.Core.Remoting.Game)register.GetObject(
typeof(Heroes.Core.Remoting.Game),
Heroes.Core.Remoting.Game.CLASSNAME);
if (adp == null)
{
MessageBox.Show("Error");
return false;
}
try
{
player = adp.GetPlayer(playerId);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
return false;
}
return true;
}
private bool RemoteSetStartingBattle(Heroes.Core.Hero attackHero, Heroes.Core.Hero defendHero)
{
Heroes.Core.Remoting.RegisterServer register = new Heroes.Core.Remoting.RegisterServer();
register._hostName = Setting._remoteHostName;
Heroes.Core.Remoting.Game adp = null;
adp = (Heroes.Core.Remoting.Game)register.GetObject(
typeof(Heroes.Core.Remoting.Game),
Heroes.Core.Remoting.Game.CLASSNAME);
if (adp == null)
{
MessageBox.Show("Error");
return false;
}
try
{
adp.SetStartingBattle(attackHero, defendHero);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
return false;
}
return true;
}
public void JoinGame(string playerName, out Heroes.Core.Player player)
{
player = null;
if (IsPlayerExist(playerName))
{
}
else
{
}
}
public void GetBattle(out Heroes.Core.Hero attackHero, out Heroes.Core.Hero defendHero)
{
attackHero = GameSetting._attackHero;
defendHero = GameSetting._defendHero;
}
