protected override void OnUsing()
{
Releaseing = 0;
var to = GameManager.Instance.ActiveWorld.Value.CreateEntity(PreIceSpear);
to.transform.position = role.transform.position;
to.Camp = role.Camp;
var angle = to.transform.eulerAngles;
angle.z = Direction;
to.transform.eulerAngles = angle;
Projectile pro = to.GetComponent <Projectile>();
pro.Velocity = 3;
pro.Direction = Direction;
var _dam = new DamageClass();
_dam.Damage = 60f;
_dam.Element.Ice = true;
pro.damage = _dam;
}
public Type(Pokedex pokedex, int id, LocalizedString name, DamageClass damage_class)
: base(pokedex)
{
ID = id;
Name = name;
DamageClass = damage_class;
}
/// <summary>
/// Update damage class
/// </summary>
/// <param name="damageClass">Damage class to update</param>
public void UpdateDamageClass(DamageClass damageClass)
{
AutoRentEntities context = new AutoRentEntities();
DbTransaction transaction = null;
try
{
context.Connection.Open();
transaction = context.Connection.BeginTransaction();
context.DamageClass.Attach(context.DamageClass.Single(o => o.Class == damageClass.Class));
context.DamageClass.ApplyCurrentValues(damageClass);
context.SaveChanges();
transaction.Commit();
}
catch
{
transaction.Rollback();
}
finally
{
context.Connection.Close();
}
}
public Type(Pokedex pokedex, int id, LocalizedString name, DamageClass damage_class)
: base(pokedex)
{
ID = id;
Name = name;
DamageClass = damage_class;
}
//Add the multiplied damage to the base.
public DamageClass ApplyDamageMod(DamageClass damage)
{
damage.damageMultiplyer += damageMultiplyer;
damageShift += damageShift;
return(damage);
}
public Type(Pokedex pokedex, int id, LocalizedString name, DamageClass damage_class)
{
m_pokedex = pokedex;
ID = id;
Name = name;
DamageClass = damage_class;
}
public Damage(DamageType type_, DamageClass damclass_, Actor source_, int totaldamage)
{
dice = 0;
num = totaldamage;
type = type_;
damclass = damclass_;
source = source_;
}
public void Init(string targetTag, DamageClass damage)
{
Destroy(this.gameObject, 10);
this.targetTag = targetTag;
this.damage = damage;
playerProjectile = (targetTag == "Enemy");
}
public Damage(int dice_, DamageType type_, DamageClass damclass_, Actor source_)
{
dice = dice_;
num = null;
type = type_;
damclass = damclass_;
source = source_;
}
public AttackInfo(int cost_, int dice_, DamageType type_, DamageClass damclass_, string desc_)
{
cost = cost_;
damage = new Damage(dice_, type_, damclass_, null);
/* damage.dice=dice_;
damage.type=type_;
damage.damclass=damclass_;*/
desc = desc_;
}
public override void Initialise(Actor actor)
{
actor.equippedAbilties.Add(this);
owner = actor;
cam = Camera.main;
aDamage = new DamageClass(aBaseDamage, aDamageType);
}
public override void TakeDamage(DamageClass damage)
{
health -= damageResistance.CalculateDamagetoTake(damage.TotalDamage, damage.damageType);
if (health <= 0)
{
Die();
}
}
public Damage(int dice_,DamageType type_,DamageClass damclass_,bool major,Actor source_)
{
dice=dice_;
num = null;
type=type_;
damclass=damclass_;
major_damage = major;
source=source_;
weapon_used = WeaponType.NO_WEAPON;
}
public Damage(DamageType type_,DamageClass damclass_,bool major,Actor source_,int totaldamage)
{
dice=0;
num=totaldamage;
type=type_;
damclass=damclass_;
major_damage = major;
source=source_;
weapon_used = WeaponType.NO_WEAPON;
}
public void CreateDamageClassTest()
{
DamageClassAccessor accessor = new DamageClassAccessor();
DamageClass DamageClass = new DamageClass
{
Class = 2,
Name = "Motor"
};
accessor.CreateDamageClass(DamageClass);
}
public void InsertDamageClass(DamageClass damageClass)
{
if ((damageClass.EntityState != EntityState.Detached))
{
this.ObjectContext.ObjectStateManager.ChangeObjectState(damageClass, EntityState.Added);
}
else
{
this.ObjectContext.DamageClass.AddObject(damageClass);
}
}
public void UpdateDamageClassTest()
{
DamageClassAccessor accessor = new DamageClassAccessor();
DamageClass DamageClass = new DamageClass
{
Class = 2,
Name = "Bumper"
};
accessor.UpdateDamageClass(DamageClass);
}
/// <summary>
/// Grabs the sum of damage values for the given <see cref="DamageClasses"/>.
/// </summary>
public int GetDamageClassSum(DamageClass damageClass)
{
var sum = 0;
foreach (var type in damageClass.ToTypes())
{
sum += GetDamageValue(type);
}
return(sum);
}
public void DeleteDamageClass(DamageClass damageClass)
{
if ((damageClass.EntityState != EntityState.Detached))
{
this.ObjectContext.ObjectStateManager.ChangeObjectState(damageClass, EntityState.Deleted);
}
else
{
this.ObjectContext.DamageClass.Attach(damageClass);
this.ObjectContext.DamageClass.DeleteObject(damageClass);
}
}
protected override float GetBenefitFrom(DamageClass damageClass)
{
// Make this damage class not benefit from any otherclass stat bonuses by default, but still benefit from universal/all-class bonuses.
if (damageClass == DamageClass.Generic)
{
return(1f);
}
// Now, I know you're just dyin' to get into the fun side of things, so let's have ourselves some demonstrations.
// Feel free to uncomment one of the below! Experiment, play with the variables a bit. See what works best for you!
// PROMPT: You want your damage class to benefit at a standard rate from a vanilla class' stat boosts.
// The below makes your class benefit at a standard rate (100%) from all melee stat bonuses.
/*
* if (damageClass == DamageClass.Melee)
* return 1f;
*/
// PROMPT: You want your damage class to benefit at a much higher rate from a vanilla class' stat boosts.
// The below makes your class benefit at 500% effectiveness from all magic stat bonuses.
/*
* if (damageClass == DamageClass.Magic)
* return 5f;
*/
// PROMPT: You want your damage class to benefit at a equal rate from two vanilla classes' stat boosts.
// The below makes your class benefit at a standard rate from all melee and ranged stat bonuses equally.
// This functionality can be useful for hybrid weapons, such as Calamity's Prismatic Breaker.
/*
* if (damageClass == DamageClass.Melee)
* return 1f;
* if (damageClass == DamageClass.Ranged)
* return 1f;
*/
// PROMPT: You want your damage class to benefit at a equal rate from a vanilla class' stat boosts and another modded class' stat boosts.
// The below makes your class benefit at a standard rate from melee stat bonuses and at a 200% rate from another modded class' stat bonuses.
// This functionality can be useful for hybrid weapons, particularly those involving cross-mod content (see the guide on that for more detail!).
/*
* if (damageClass == DamageClass.Melee)
* return 1f;
* if (damageClass == ModContent.GetInstance<CoolDamageClass>())
* return 2f;
*/
// Note that the other modded damage class isn't provided here --- that'd ruin the point, now wouldn't it?
return(0);
}
public void WeaponAttack(Vector3 firePostion, Vector3 TargetPostion, string targetTag)
{
if (!WeaponWaitingForCooldown)
{
Vector3 shootDir;
float angle = 0;
//Mouse has hit a valid location to shoot at
//TODO: We dont need a ray cast for this, get mouse position when we click!!
shootDir = TargetPostion - firePostion;
shootDir.y = 0;
shootDir.Normalize();
angle = Mathf.Acos(Vector3.Dot(Vector3.forward, shootDir)) * Mathf.Rad2Deg;
if (TargetPostion.x < transform.position.x)
{
angle = 360 - angle;
}
//We need, Prefab (Local), Position, Rotation / Direction, and then set the damage;
//We Need, Who is shooting and where in the world we are shooting
for (int i = 0; i < numberOfShots; i++)
{
int offset = (numberOfShots / 2) - i;
Transform clone = Instantiate(projectile, firePostion + (shootDir) + new Vector3(offset * shootDir.z, 0.5f, offset * -shootDir.x), Quaternion.Euler(0, angle + (offset * spreadAngle), 0)) as Transform;
clone.GetComponent <BowProjectileScript>().Init(targetTag, new DamageClass(damage, damageType));
if (WeaponOwner.GetComponent <Actor>().equippedDamageModifiers.Count > 0)
{
foreach (DamageModifier abi in WeaponOwner.GetComponent <Actor>().equippedDamageModifiers)
{
if (abi.isActive)
{
DamageClass cloneDam = clone.GetComponent <BowProjectileScript>().damage;
cloneDam = abi.ApplyDamageMod(cloneDam);
clone.GetComponent <BowProjectileScript>().damage = cloneDam;
}
}
}
}
WeaponWaitingForCooldown = true;
StartCoroutine(AttackTimer());
}
}
public Move(Pokedex pokedex, int id, int type_id, LocalizedString name,
DamageClass damage_class, int damage, int pp, int accuracy, int priority,
BattleTargets target)
{
m_pokedex = pokedex;
ID = id;
TypeID = type_id;
Name = name;
DamageClass = damage_class;
Damage = damage;
PP = pp;
Accuracy = accuracy;
Priority = priority;
Target = target;
}
/// <summary>
/// Attempts to grab the sum of damage values for the given
/// <see cref="DamageClasses"/>.
/// </summary>
/// <param name="class">The class to get the sum for.</param>
/// <param name="damage">The resulting amount of damage, if any.</param>
/// <returns>
/// True if the class is supported in this container, false otherwise.
/// </returns>
public bool TryGetDamageClassSum(DamageClass @class, [NotNullWhen(true)] out int damage)
{
damage = 0;
if (SupportsDamageClass(@class))
{
foreach (var type in @class.ToTypes())
{
damage += GetDamageValue(type);
}
return(true);
}
return(false);
}
protected override float GetBenefitFrom(DamageClass damageClass)
{
// Make this damage class not benefit from any otherclass stat bonuses by default, but still benefit from universal/all-class bonuses.
if (damageClass == Generic)
{
return(1f);
}
if (damageClass == Melee)
{
return(0.25f);
}
return(0f);
}
public Move(Pokedex pokedex, int id, int type_id, LocalizedString name,
DamageClass damage_class, int damage, int pp, int accuracy, int priority,
BattleTargets target)
: base(pokedex)
{
m_type_pair = Type.CreatePair(m_pokedex);
m_lazy_pairs.Add(m_type_pair);
ID = id;
m_type_pair.Key = type_id;
Name = name;
DamageClass = damage_class;
Damage = damage;
PP = pp;
Accuracy = accuracy;
Priority = priority;
Target = target;
// todo: Nice description text
}
public Move(Pokedex pokedex, int id, int type_id, LocalizedString name,
DamageClass damage_class, int damage, int pp, int accuracy, int priority,
BattleTargets target)
: base(pokedex)
{
m_type_pair = Type.CreatePair(m_pokedex);
m_lazy_pairs.Add(m_type_pair);
ID = id;
m_type_pair.Key = type_id;
Name = name;
DamageClass = damage_class;
Damage = damage;
PP = pp;
Accuracy = accuracy;
Priority = priority;
Target = target;
// todo: Nice description text
}
public DamageClass RetrieveSpecificDamageClass(IDbConnection connection, int damage_class_id)
{
DamageClass damageClass = null;
using (IDbCommand command = database.CreateCommand()) {
command.Connection = connection;
command.CommandText = Query.GetSpecificDamageClass;
command.Prepare();
command.AddWithValue("@damage_class_id", damage_class_id);
using (IDataReader reader = command.ExecuteReader()) {
if (reader.Read())
{
damageClass = new DamageClass {
Id = reader.CheckValue <int>("id"),
Identifier = reader.CheckObject <string>("identifier")
};
}
}
} // Command
return(damageClass);
}
/// <summary>
/// Create new damage class
/// </summary>
/// <param name="damageClass">Damage class to add</param>
public void CreateDamageClass(DamageClass damageClass)
{
AutoRentEntities context = new AutoRentEntities();
DbTransaction transaction = null;
try
{
context.Connection.Open();
transaction = context.Connection.BeginTransaction();
context.AddToDamageClass(damageClass);
context.SaveChanges();
transaction.Commit();
}
catch
{
transaction.Rollback();
}
finally
{
context.Connection.Close();
}
}
public bool TakeDamage(DamageType dmgtype,DamageClass damclass,bool major_damage,int dmg,Actor source)
{
return TakeDamage(new Damage(dmgtype,damclass,major_damage,source,dmg),"");
}
public static List <DamageType> ToTypes(this DamageClass @class)
{
return(ClassToType[@class]);
}
public bool TakeDamage(DamageType dmgtype,DamageClass damclass,bool major_damage,int dmg,Actor source,string cause_of_death)
{
return TakeDamage(new Damage(dmgtype,damclass,major_damage,source,dmg),cause_of_death);
}
public static ImmutableList <DamageType> ToTypes(this DamageClass @class)
{
return(DamageSystem.ClassToType[@class]);
}
public async Task<bool> TakeDamage(DamageType dmgtype, DamageClass damclass, int dmg, Actor source)
{
return await TakeDamage(new Damage(dmgtype, damclass, source, dmg), "");
}
public async Task<bool> TakeDamage(DamageType dmgtype, DamageClass damclass, int dmg, Actor source, string cause_of_death)
{
return await TakeDamage(new Damage(dmgtype, damclass, source, dmg), cause_of_death);
}
public abstract void TakeDamage(DamageClass damage);
public static void DealDamage(LivingEntity from, LivingEntity to, DamageClass damage)
{
to.UnderAttack(from, damage);
}
public override bool CountsAs(DamageClass damageClass)
{
// Make this damage class not benefit from any otherclass effects (e.g. Spectre bolts, Magma Stone) by default.
// Note that unlike GetBenefitFrom, you do not need to account for universal bonuses in this method.
return(false);
}
private void OnFollowAttacked(LivingEntity from, DamageClass dmg)
{
_uiIns.AddInfo(dmg.Type.ToString(), dmg.Damage, dmg.Element.ToString());
}
public void UpdateDamageClass(DamageClass currentDamageClass)
{
this.ObjectContext.DamageClass.AttachAsModified(currentDamageClass, this.ChangeSet.GetOriginal(currentDamageClass));
}
public override void TakeDamage(DamageClass damage)
{
ApplyDamageToParentBoss(damageResistance.CalculateDamagetoTake(damage.baseDamage, damage.damageType));
base.TakeDamage(damage);
}
public bool SupportsDamageClass(DamageClass @class)
{
return(SupportedClasses.Contains(@class));
}
