void Awake()
{
Instance = this;
DontDestroyOnLoad(gameObject);
LoadAbilityData();
}
public static void AddAllHeals(Ability[] spells, Item[] myItems1)
{
HealsToggler = new Dictionary <string, bool>();
foreach (var spell in
from spell in spells
let data = AbilityDatabase.Find(spell.Name)
where data != null && data.IsHeal
select spell)
{
AddHeal(spell);
RangeDrawing.AddRange(spell);
}
foreach (var spell in
from spell in myItems1
let data = AbilityDatabase.Find(spell.Name)
where data != null && data.IsHeal
select spell)
{
if (MyAbilities.DefensiveAbilities.ContainsKey(spell.Name + "heal"))
{
continue;
}
AddHeal(spell);
RangeDrawing.AddRange(spell);
}
if (HealsTogglerCreated)
{
MainMenu.Menu.AddItem(new MenuItem("healsToggler", "Heals:").SetValue(new AbilityToggler(HealsToggler)));
}
}
public static void AddAllNukes(Ability[] spells, Item[] myItems1)
{
NukesToggler = new Dictionary <string, bool>();
foreach (var spell in
from spell in spells
let data = AbilityDatabase.Find(spell.Name)
where data != null && data.IsNuke
select spell)
{
AddNuke(spell);
RangeDrawing.AddRange(spell);
}
foreach (var spell in
from spell in myItems1
let data = AbilityDatabase.Find(spell.Name)
where data != null && (data.IsNuke || spell.StoredName() == "item_urn_of_shadows")
select spell)
{
AddNuke(spell);
RangeDrawing.AddRange(spell);
}
if (NukesTogglerCreated)
{
MainMenu.Menu.AddItem(new MenuItem("nukesToggler", "Nukes:").SetValue(new AbilityToggler(NukesToggler)));
}
}
/// <summary>
/// Checks all aspects and returns full delay before target gets hit by given ability
/// </summary>
/// <param name="ability"></param>
/// <param name="target"></param>
/// <param name="abilityName"></param>
/// <returns></returns>
public static double GetHitDelay(this Ability ability, Unit target, string abilityName = null)
{
var name = abilityName ?? ability.Name;
AbilityInfo data;
if (!AbilityDamage.DataDictionary.TryGetValue(ability, out data))
{
data = AbilityDatabase.Find(name);
AbilityDamage.DataDictionary.Add(ability, data);
}
var owner = ability.Owner as Unit;
var delay = ability.GetCastDelay(owner as Hero, target, true, abilityName: name);
if (data != null)
{
delay += data.AdditionalDelay;
}
var speed = ability.GetProjectileSpeed(name);
var radius = ability.GetRadius(name);
if (!ability.IsAbilityBehavior(AbilityBehavior.NoTarget, name) && speed < 6000 && speed > 0)
{
var xyz = ability.GetPrediction(target, abilityName: name);
delay += (Math.Max((owner.Distance2D(xyz) - radius / 2), 100) / speed);
}
if (name == "tinker_heat_seeking_missile")
{
var xyz = ability.GetPrediction(target, abilityName: name);
delay += (Math.Max((owner.Distance2D(xyz)), 100) / speed);
}
return(delay);
}
public static Menu Create(string name, Ability ability)
{
var menu = new Menu(name, name, textureName: name);
if (name == "rubick_spell_steal")
{
return(menu);
}
menu.AddItem(Togglers.OnSight(name));
var data = AbilityDatabase.Find(name);
var defaultValue = ability.AbilityType != AbilityType.Ultimate;
if (data != null)
{
if (data.TrueSight)
{
menu.AddItem(Togglers.OnInvisible(name, defaultValue));
}
if (data.IsPurge)
{
menu.AddItem(Togglers.OnPurgable(name, defaultValue));
}
if (data.WeakensEnemy)
{
menu.AddItem(Togglers.OnAttack(name, defaultValue));
}
}
menu.AddItem(Sliders.MinManaCheck(name));
menu.AddItem(Sliders.MinManaCheck(name, true));
return(menu);
}
private static void InGameObject_OnCreate(InGameObject inGameObject)
{
var baseTypes = inGameObject.GetBaseTypes().ToArray();
if (baseTypes.Contains("CurveProjectile") || baseTypes.Contains("CurveProjectile2"))
{
var data = AbilityDatabase.Get(inGameObject.ObjectName);
if (data == null)
{
return;
}
var pos = LocalPlayer.Instance.Pos();
var projectile = inGameObject.Get <CurveProjectileObject>();
var closest = GeometryLib.NearestPointOnFiniteLine(projectile.Position,
projectile.TargetPosition, pos);
if (pos.Distance(closest) > 6)
{
return;
}
var tp = new TrackedCurveProjectile(projectile, data);
AddAfterFrame.Add(tp);
}
}
private static void Update(EventArgs args)
{
if (!MenuHandler.Enabled || !_shouldUse || !_isCasting || Game.CurrentMatchState != MatchState.InRound)
{
return;
}
var skill = ActiveSkills.Get(_castingId);
if (skill == null)
{
return;
}
if (MenuHandler.Get(skill.Slot))
{
if (OrbLogic(skill, true))
{
return;
}
var pred = TargetSelection.GetTargetPrediction(skill, AbilityDatabase.Get(_castingId));
if (!pred.CanHit && !OrbLogic(skill))
{
if (MenuHandler.Interrupt)
{
LocalPlayer.PressAbility(AbilitySlot.Interrupt, true);
}
LocalPlayer.EditAimPosition = false;
return;
}
LocalPlayer.EditAimPosition = true;
LocalPlayer.Aim(pred.CastPosition);
}
}
/// <summary>
/// Returns projectile speed of the ability
/// </summary>
/// <param name="ability"></param>
/// <returns></returns>
public static float GetProjectileSpeed(this Ability ability)
{
float speed;
if (!SpeedDictionary.TryGetValue(ability.Name + " " + ability.Level, out speed))
{
AbilityInfo data;
if (!AbilityDamage.DataDictionary.TryGetValue(ability, out data))
{
data = AbilityDatabase.Find(ability.Name);
AbilityDamage.DataDictionary.Add(ability, data);
}
if (data == null)
{
speed = float.MaxValue;
SpeedDictionary.Add(ability.Name + " " + ability.Level, speed);
return(speed);
}
if (data.Speed != null)
{
speed = ability.GetAbilityData(data.Speed);
SpeedDictionary.Add(ability.Name + " " + ability.Level, speed);
}
}
return(speed);
}
public static void AddAllShields(Ability[] spells, Item[] myItems1)
{
ShieldsToggler = new Dictionary <string, bool>();
foreach (var spell in
from spell in spells
let data = AbilityDatabase.Find(spell.Name)
where data != null && data.IsShield
select spell)
{
AddShield(spell);
RangeDrawing.AddRange(spell);
}
foreach (var spell in
from spell in myItems1
let data = AbilityDatabase.Find(spell.Name)
where data != null && data.IsShield
select spell)
{
AddShield(spell);
RangeDrawing.AddRange(spell);
}
if (ShieldsTogglerCreated)
{
MainMenu.Menu.AddItem(
new MenuItem("shieldsToggler", "Shields:").SetValue(new AbilityToggler(ShieldsToggler)));
}
}
/// <summary>
/// Checks all aspects and returns full delay before target gets hit by given ability
/// </summary>
/// <param name="ability"></param>
/// <param name="target"></param>
/// <returns></returns>
public static double GetHitDelay(this Ability ability, Unit target)
{
AbilityInfo data;
if (!AbilityDamage.DataDictionary.TryGetValue(ability, out data))
{
data = AbilityDatabase.Find(ability.Name);
AbilityDamage.DataDictionary.Add(ability, data);
}
var owner = ability.Owner as Unit;
var delay = ability.GetCastDelay(owner as Hero, target, true);
if (data != null)
{
delay += data.AdditionalDelay;
}
var speed = ability.GetProjectileSpeed();
var radius = ability.GetRadius();
if (!ability.AbilityBehavior.HasFlag(AbilityBehavior.NoTarget) && speed < 6000 && speed > 0)
{
var xyz = ability.GetPrediction(target);
delay += (Math.Max((owner.Distance2D(xyz) - radius / 2), 100) / speed);
}
return(delay);
}
private static void DodgeWithAbilities(TrackedDash dash)
{
var timeToImpact = dash.EstimatedImpact - Time.time;
if (PlayerIsSafe(timeToImpact))
{
return;
}
foreach (var ability in AbilityDatabase.GetDodge(LocalPlayer.Instance.CharName).OrderBy(a => a.Priority))
{
if (!ability.UseInEvade || timeToImpact > ability.CastTime + 0.25f || timeToImpact < ability.CastTime + 0.05f)
{
continue;
}
if (ability.ShouldUse() && ability.IsReady() && ability.GetDanger() <= dash.Data.GetDanger() &&
(dash.Data.CanCounter || ability.AbilityType != DodgeAbilityType.Counter) &&
(dash.Data.CanCounter || ability.AbilityType != DodgeAbilityType.Shield) &&
(ability.AbilityType != DodgeAbilityType.KnockAway || dash.DashObject.GameObject.ObjectName == "Rush"))
{
if (ability.NeedsSelfCast)
{
LocalPlayer.PressAbility(ability.AbilitySlot, true);
}
else
{
LocalPlayer.PressAbility(ability.AbilitySlot, true);
}
return;
}
}
}
private static void DodgeWithAbilities(TrackedProjectile projectile)
{
var timeToImpact = projectile.EstimatedImpact - Time.time;
if (PlayerIsSafe(timeToImpact))
{
return;
}
foreach (var ability in AbilityDatabase.GetDodge(LocalPlayer.Instance.CharName).OrderBy(a => a.Priority))
{
if (!ability.UseInEvade || timeToImpact > ability.CastTime + 0.25f || timeToImpact < ability.CastTime + 0.05f)
{
continue;
}
if (ability.ShouldUse() && ability.IsReady() && ability.GetDanger() <= projectile.Data.GetDanger())
{
if (ability.NeedsSelfCast)
{
LocalPlayer.PressAbility(ability.AbilitySlot, true);
}
else
{
LocalPlayer.PressAbility(ability.AbilitySlot, true);
}
return;
}
}
}
public Torrent(Ability ability)
{
Ability = ability;
CastPoint = (float)ability.FindCastPoint();
AdditionalDelay = AbilityDatabase.Find(ability.Name).AdditionalDelay;
Radius = ability.GetRadius() + 25;
}
public static AbilityDatabase InitSetting()
{
string path = Application.persistentDataPath + "/Xml/Ability.Xml";
if (!System.IO.File.Exists(path))
{
string folderPath;
folderPath = Application.persistentDataPath + "/Xml";
DirectoryInfo di = new DirectoryInfo(folderPath);
if (di.Exists == false)
{
di.Create();
}
TextAsset _xml = Resources.Load <TextAsset>("XmlData/Ability");
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.LoadXml(_xml.text);
if (_xml != null)
{
XmlSerializer serializer = new XmlSerializer(typeof(AbilityDatabase));
var reader = new StringReader(_xml.text);
AbilityDatabase abilityDB = serializer.Deserialize(reader) as AbilityDatabase;
reader.Close();
CreateXml(path);
Debugging.Log("AbilityDatabase 최초 생성 성공");
return(abilityDB);
}
}
Debugging.Log("AbilityDatabase 최초 생성 실패");
return(null);
}
public static AbilityDatabase LoadUser()
{
string path = Application.persistentDataPath + "/Xml/Ability.Xml";
if (System.IO.File.Exists(path))
{
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.LoadXml(System.IO.File.ReadAllText(path));
//복호화////
XmlElement elmRoot = xmlDoc.DocumentElement;
var decrpytData = DataSecurityManager.DecryptData(elmRoot.InnerText);
elmRoot.InnerXml = decrpytData;
//////////
string _xml;
using (var stringWriter = new StringWriter())
using (var xmlTextWriter = XmlWriter.Create(stringWriter))
{
xmlDoc.WriteTo(xmlTextWriter);
xmlTextWriter.Flush();
_xml = stringWriter.GetStringBuilder().ToString();
}
if (_xml != null)
{
XmlSerializer serializer = new XmlSerializer(typeof(AbilityDatabase));
var reader = new StringReader(_xml);
AbilityDatabase abilityDB = serializer.Deserialize(reader) as AbilityDatabase;
reader.Close();
Debugging.Log("AbilityDatabase 기존 파일 로드");
return(abilityDB);
}
}
Debugging.LogSystemWarning("AbilityDatabase wasn't loaded. >> " + path + " is null. >>");
return(null);
}
/// <summary>
/// Returns cast range of ability, if ability is NonTargeted it will return its radius!
/// </summary>
/// <param name="ability"></param>
/// <returns></returns>
public static float GetCastRange(this Ability ability)
{
if (ability.Name == "templar_assassin_meld")
{
return((ability.Owner as Hero).GetAttackRange() + 50);
}
if (!ability.AbilityBehavior.HasFlag(AbilityBehavior.NoTarget))
{
var castRange = ability.CastRange;
var bonusRange = 0;
if (castRange <= 0)
{
castRange = 999999;
}
if (ability.Name == "dragon_knight_dragon_tail" &&
(ability.Owner as Hero).Modifiers.Any(x => x.Name == "modifier_dragon_knight_dragon_form"))
{
bonusRange = 250;
}
else if (ability.Name == "beastmaster_primal_roar" && (ability.Owner as Hero).AghanimState())
{
bonusRange = 350;
}
return(castRange + bonusRange + 100);
}
var radius = 0f;
AbilityInfo data;
if (!AbilityDamage.DataDictionary.TryGetValue(ability, out data))
{
data = AbilityDatabase.Find(ability.Name);
AbilityDamage.DataDictionary.Add(ability, data);
}
if (data == null)
{
return(ability.CastRange);
}
if (!data.FakeCastRange)
{
if (data.Width != null)
{
radius = ability.GetAbilityData(data.Width);
}
if (data.StringRadius != null)
{
radius = ability.GetAbilityData(data.StringRadius);
}
if (data.Radius > 0)
{
radius = data.Radius;
}
}
else
{
radius = ability.GetAbilityData(data.RealCastRange);
}
return(radius + 50);
}
private void SpellInit()
{
if (LocalPlayer.Instance.CharName == "Shen Rao" || string.IsNullOrEmpty(LocalPlayer.Instance.CharName))
{
ActiveSkills.AddFromDatabase();
AM1Info = AbilityDatabase.Get("LightningBolt");
AscendedM1 = new SkillBase(AbilitySlot.Ability1, SkillType.Circle, AM1Info.Range, AM1Info.Speed, AM1Info.Radius, AM1Info.FixedDelay);
}
}
/// <summary>
/// Returns cast range of ability, if ability is NonTargeted it will return its radius!
/// </summary>
/// <param name="ability"></param>
/// <param name="abilityName"></param>
/// <returns></returns>
public static float GetCastRange(this Ability ability, string abilityName = null)
{
var name = abilityName ?? ability.Name;
if (name == "templar_assassin_meld")
{
return((ability.Owner as Hero).GetAttackRange() + 50);
}
if (!ability.IsAbilityBehavior(AbilityBehavior.NoTarget, name))
{
var castRange = ability.CastRange;
var bonusRange = 0f;
if (castRange <= 0)
{
castRange = 999999;
}
var owner = ability.Owner as Hero;
if (name == "dragon_knight_dragon_tail" &&
owner.Modifiers.Any(x => x.Name == "modifier_dragon_knight_dragon_form"))
{
bonusRange = 250;
}
else if (name == "beastmaster_primal_roar" && owner.AghanimState())
{
bonusRange = 350;
}
var aetherLens = owner.FindItem("item_aether_lens");
if (aetherLens != null)
{
bonusRange += aetherLens.GetAbilityData("cast_range_bonus");
}
return(castRange + bonusRange);
}
var radius = 0f;
AbilityInfo data;
if (!AbilityDamage.DataDictionary.TryGetValue(ability, out data))
{
data = AbilityDatabase.Find(name);
AbilityDamage.DataDictionary.Add(ability, data);
}
if (data == null)
{
return(ability.CastRange);
}
if (!data.FakeCastRange)
{
radius = ability.GetRadius(name);
}
else
{
radius = ability.GetAbilityData(data.RealCastRange, abilityName: name);
}
return(radius);
}
/// <summary>
/// The load.
/// </summary>
private static void Load()
{
AbilityDatabase.Init();
AbilityDamage.Init();
AbilityExtensions.Init();
HeroExtensions.Init();
UnitExtensions.Init();
Names.Init();
Abilities.Init();
}
private static void OnMatchStart(EventArgs args)
{
AbilityStates.Clear();
foreach (var character in EntitiesManager.EnemyTeam)
{
var abilities = AbilityDatabase.GetDodge(character.CharName);
var dict = abilities.ToDictionary(abilityInfo => abilityInfo.AbilityId, abilityInfo => true);
AbilityStates.Add(character.CharName, dict);
}
}
private static void InGameObject_OnCreate(InGameObject inGameObject)
{
var data = AbilityDatabase.GetObstacle(inGameObject.ObjectName);
if (data == null)
{
return;
}
AddAfterFrame.Add(new TrackedObstacleObject(inGameObject.Get <MapGameObject>(), data));
}
private void Awake()
{
instance = this;
CollisionManager.InitializeCollisionManager();
ItemDatabase.InitializeDatabase();
AbilityDatabase.InitializeDatabase();
EnemyDatabase.LoadDatabase();
MapDatabase.InitializeDatabase();
RoomDatabase.InitializeDatabase();
}
public static void AddFromDatabase(AbilitySlot slot)
{
var data = AbilityDatabase.Get(LocalPlayer.Instance.CharName, slot)[0];
if (data != null)
{
Active.Add(new SkillBase(slot, data.AbilityType.ToSkillType(), data.Range == 0 ? data.MaxRange : data.Range, data.Speed, data.Radius, data.FixedDelay));
ActiveInfos.Add(data);
}
}
private static void InitUserData(string localId, string name)
{
SaveSystem.InitPlayer(localId, name);
ItemDatabase.InitSetting();
HeroDatabase.InitSetting();
AbilityDatabase.InitSetting();
SkillDatabase.InitSetting();
MissionDatabase.InitSetting();
MapDatabase.InitSetting();
SaveData();
}
public void SetDataToCloud(string socialUserId, string socialName, string saveTime)
{
localId = socialUserId;
name = socialName;
lastSavedTime = saveTime;
UserData = SaveSystem.GetUserDataToCloud();
ItemData = ItemDatabase.GetItemDataToCloud();
HeroData = HeroDatabase.GetHeroDataToCloud();
AbilityData = AbilityDatabase.GetAbilityDataToCloud();
SkillData = SkillDatabase.GetSkillDataToCloud();
MissionData = MissionDatabase.GetMissionDataToCloud();
MapData = MapDatabase.GetMapDataToCloud();
}
/// <summary>
/// The load.
/// </summary>
private static void Load()
{
AbilityDatabase.Init();
AbilityDamage.Init();
AbilityExtensions.Init();
HeroExtensions.Init();
UnitExtensions.Init();
Names.Init();
Abilities.Init();
Calculations.Init();
EntityExtensions.Init();
Orbwalking.Events_OnLoad(null, null);
Utils.Sleeps = new Dictionary <string, double>();
}
private static void SpellDetector_OnSpellCast(SpellCastArgs args)
{
if (args.Caster.Team == BattleRight.Core.Enumeration.Team.Enemy)
{
return;
}
var data = AbilityDatabase.Get(args.Caster.AbilitySystem.CastingAbilityId);
if (data == null)
{
return;
}
TrackedCasts.Add(new TrackedCast(args.AbilityIndex, args.Caster, data));
}
// Use this for initialization
private void Awake()
{
GameController.GetInstance().SetPlayerScript(this);
mMainCamera = Camera.main;
mAbilities = new GameObject[6];
AbilityDatabase.GetInstance().GetAbility(0).GetComponent <Projectile>().mSpawnPosition = transform;
AbilityDatabase.GetInstance().GetAbility(0).GetComponent <Projectile>().mSpawnDirection = mCrosshair.transform;
mAbilities[0] = Instantiate(AbilityDatabase.GetInstance().GetAbility(0), gameObject.transform);
mAbilities[1] = Instantiate(AbilityDatabase.GetInstance().GetAbility(1), gameObject.transform);
mAbilities[2] = Instantiate(AbilityDatabase.GetInstance().GetAbility(2), gameObject.transform);
mAbilities[3] = Instantiate(AbilityDatabase.GetInstance().GetAbility(3), gameObject.transform);
mAbilities[4] = Instantiate(AbilityDatabase.GetInstance().GetAbility(4), gameObject.transform);
mAbilities[5] = Instantiate(AbilityDatabase.GetInstance().GetAbility(5), gameObject.transform);
}
/// <summary>
/// The load.
/// </summary>
private static void Init()
{
AbilityDatabase.Init();
AbilityDamage.Init();
AbilityExtensions.Init();
HeroExtensions.Init();
UnitExtensions.Init();
Names.Init();
Abilities.Init();
Calculations.Init();
EntityExtensions.Init();
Utils.Sleeps = new Dictionary <string, double>();
NotifiedSubscribers.Clear();
}
/// <summary>
/// Returns prediction for given target after given ability hit delay
/// </summary>
/// <param name="ability"></param>
/// <param name="target"></param>
/// <param name="customDelay">enter your custom delay</param>
/// <param name="abilityName"></param>
/// <returns></returns>
public static Vector3 GetPrediction(
this Ability ability,
Unit target,
double customDelay = 0,
string abilityName = null)
{
var name = abilityName ?? ability.Name;
AbilityInfo data;
if (!AbilityDamage.DataDictionary.TryGetValue(ability, out data))
{
data = AbilityDatabase.Find(name);
AbilityDamage.DataDictionary.Add(ability, data);
}
var owner = ability.Owner as Unit;
var delay = ability.GetCastDelay(owner as Hero, target, true, abilityName: name, useChannel: true);
if (data != null)
{
delay += data.AdditionalDelay;
}
var speed = ability.GetProjectileSpeed(name);
var radius = ability.GetRadius(name);
Vector3 xyz;
if (speed > 0 && speed < 6000)
{
xyz = Prediction.SkillShotXYZ(
owner,
target,
(float)((delay + owner.GetTurnTime(target.Position)) * 1000),
speed,
radius);
if (!ability.IsAbilityBehavior(AbilityBehavior.NoTarget, name))
{
xyz = Prediction.SkillShotXYZ(
owner,
target,
(float)((delay + (float)owner.GetTurnTime(xyz)) * 1000),
speed,
radius);
}
}
else
{
xyz = Prediction.PredictedXYZ(target, (float)(delay * 1000));
}
return(xyz);
}
public void Initialize(MyCharacterController controller)
{
characterStats.setChar(this);
this.topDownController = controller;
skillMenu = GameObject.Find("Food Skills").GetComponent<SkillMenu>();
skillMenu.SetCharacter(this);
abDB = GameObject.Find("Databases").GetComponent<AbilityDatabase>();
SkillMenu characterSkills = GameObject.Find("Character Skills").GetComponent<SkillMenu>();
characterSkills.SetCharacter(this);
for (int i = 0; i < charAbilitiesIndex.Count; i++)
addCharAbilities(abDB.getAbilityById(charAbilitiesIndex[i]));
tasteTranslater = new SimpleTasteTranslation();
skillMenu.updateSkillList();
characterSkills.updateSkillList();
//to refresh their setter
characterStats.MovementSpeed = characterStats.MovementSpeed;
characterStats.AttackSpeed = characterStats.AttackSpeed;
DamageOverTime dot = new DamageOverTime();
dot.duration = 6;
dot.damage = 20;
dot.hitsPerSecond = 1;
dot.ChanceOfApplying = 25;
dot.typeOfDamage = TypeOfEffects.fire;
onHitStatusEffects.Add(dot);
}
