public void HeroDamageRandomization(AttackKind attackKind)
{
var game = CreateGame();
game.Hero.Stats.GetStat(EntityStatKind.Health).Value.Nominal = 500;
game.Hero.Stats.GetStat(EntityStatKind.Mana).Value.Nominal = 500;
var enemy = game.GameManager.EnemiesManager.GetEnemies().Where(i => i.PowerKind == EnemyPowerKind.Champion).First();
List <float> healthChanges = null;
PlaceCloseToHero(enemy);
if (attackKind == AttackKind.Unset)
{
healthChanges = DoDamage(game.Hero, enemy, (LivingEntity attacker, LivingEntity en) => { en.OnMeleeHitBy(attacker); });
}
else if (attackKind == AttackKind.Melee)
{
healthChanges = DoDamage(game.Hero, enemy, (LivingEntity attacker, LivingEntity en) => CallDoDamageMelee(attacker, en));
}
else if (attackKind == AttackKind.PhysicalProjectile)
{
healthChanges = DoDamage(game.Hero, enemy, (LivingEntity attacker, LivingEntity en) => CallDoDamagePhysicalProjectile(attacker, en));
}
else if (attackKind == AttackKind.WeaponElementalProjectile)
{
healthChanges = DoDamage(game.Hero, enemy, (LivingEntity attacker, LivingEntity en) => CallDoDamageWeaponElementalProjectile(attacker, en));
}
else if (attackKind == AttackKind.SpellElementalProjectile)
{
healthChanges = DoDamage(game.Hero, enemy, (LivingEntity attacker, LivingEntity en) => CallDoDamageSpellElementalProjectile(attacker, en));
}
}
public void DamageFromEnemiesVaries(AttackKind attackKind)
{
var game = CreateGame();
var hero = game.Hero;
Assert.Greater(ActivePlainEnemies.Count, 0);
var enemy = ActivePlainEnemies.First();
var emp = game.Level.GetEmptyTiles().Where(i => i.DistanceFrom(hero) < 6 && i.DistanceFrom(hero) > 1).First();
game.Level.SetTile(enemy, emp.point);
//PlaceCloseToHero(enemy);
if (attackKind == AttackKind.Unset)
{
DoDamage(enemy, game.Hero, (LivingEntity attacker, LivingEntity victim) => { victim.OnMeleeHitBy(attacker); });
}
else if (attackKind == AttackKind.PhysicalProjectile)
{
var en = enemy as Enemy;
var fi = en.AddFightItem(FightItemKind.ThrowingKnife);
fi.Count = 10;
en.ActiveFightItem = fi as ProjectileFightItem;
DoDamage(enemy, game.Hero, (LivingEntity attacker, LivingEntity victim) => CallDoDamagePhysicalProjectile(attacker, victim));
}
//else if (attackKind == AttackKind.WeaponElementalProjectile)
//{
// healthChanges = DoDamage(game.Hero, enemy, (LivingEntity attacker, LivingEntity en) => CallDoDamageWeaponElementalProjectile(attacker, en));
//}
else if (attackKind == AttackKind.SpellElementalProjectile)
{
enemy.ActiveManaPoweredSpellSource = new Scroll(SpellKind.FireBall);
enemy.Stats.SetNominal(EntityStatKind.Mana, 1000);
DoDamage(enemy, game.Hero, (LivingEntity attacker, LivingEntity victim) => CallDoDamageSpellElementalProjectile(attacker, victim));
}
}
public AttackDescription(LivingEntity ent,
bool withVariation = true,
AttackKind attackKind = AttackKind.Unset,//if uset it will be based on current weapon/active fi
OffensiveSpell spell = null)
{
fightItem = null;
Calc(ent, withVariation, ref attackKind, spell);
}
public override object Evaluate(List <string> args, ExpressionEvaluator evaluator, Creature player, Target target, CastedSpell spell, DiceStoppedRollingData dice = null)
{
ExpectingArguments(args, 2);
DamageType damageType = (DamageType)Expressions.Get(args[0], player, target, spell);
AttackKind attackKind = (AttackKind)Expressions.Get(args[1], player, target, spell);
player.AddDamageResistance(damageType, attackKind);
return(null);
}
public Projectile(NWCreature creature, NWField field, AttackKind attackKind, int range, Item weapon, Item projectile)
{
Kind = attackKind;
Range = range;
Steps = 0;
Creature = creature;
Map = field;
Weapon = weapon;
ProjectileItem = projectile;
}
/// <summary>
/// プロパティを設定する
/// </summary>
/// <param name="attack">攻撃力</param>
/// <param name="damageRate">ダメージの振れ幅</param>
/// <param name="kind">攻撃の種類</param>
/// <param name="parentPlayer">攻撃を出した親オブジェクト</param>
public void SetProperties(int attack, float damageRate, AttackKind kind, PlayerChar parentPlayer, int sp = 0)
{
// 攻撃力を設定する
this.attack = attack;
// 攻撃力の振れ幅を設定する
this.damageRate = damageRate;
// 攻撃の種類を設定する
this.attackKind = kind;
// 攻撃の親オブジェクトを設定する
this.parentPlayer = parentPlayer;
// 加算されるSPの値を入れる
this.sp = sp;
}
/// <summary>
/// Attack the enemy using chosen weapon. </summary>
/// <param name="attackKind"> Kind of attack, internal. </param>
/// <param name="enemy"> </param>
/// <param name="weapon"> </param>
/// <param name="projectile"> </param>
/// <returns> Result of attack: true - for successful attack, false - for miss. </returns>
public override bool AttackTo(AttackKind attackKind, NWCreature enemy, Item weapon, Item projectile)
{
try {
bool result = base.AttackTo(attackKind, enemy, weapon, projectile);
/*if (result) {
* }*/
return(result);
} catch (Exception ex) {
Logger.Write("Player.attackTo(): " + ex.Message);
return(false);
}
}
// TODO: add filtering - includeFilter, excludeFilter
// for body sizes
public Damage(DamageType damageType, AttackKind attackKind, string damageRoll, TimePoint damageHits = TimePoint.Immediately, TimePoint saveOpportunity = TimePoint.None, Conditions conditions = Conditions.None, int savingThrowSuccess = int.MaxValue, Ability savingThrowAbility = Ability.None)
{
SavingThrowAbility = savingThrowAbility;
SavingThrowSuccess = savingThrowSuccess;
SaveOpportunity = saveOpportunity;
AttackKind = attackKind;
DamageType = damageType;
DamageRoll = damageRoll;
DamageHits = damageHits;
Conditions = conditions;
IncludeTargetSenses = Senses.None;
IncludeCreatureSizes = CreatureSizes.All;
IncludeCreatures = CreatureKinds.None;
}
//=======================================その他===========================================
//次の攻撃を乱数で選ぶ
private AttackKind Select_Next_Attack(AttackKind pre_Attack)
{
AttackKind next_Attack = pre_Attack;
List <AttackKind> kinds = new List <AttackKind> {
AttackKind.close_Slash, AttackKind.long_Slash, AttackKind.barrier
};
kinds.Remove(pre_Attack);
next_Attack = kinds[Random.Range(0, 2)];
return(next_Attack);
}
public void TakeDamage(DamageType damageType, AttackKind attackKind, int damage)
{
PercentDamageJustInflicted = 0;
double beforeTotalHp = TotalHp;
Creature.TakeDamage(damageType, attackKind, damage);
double totalDamageTaken = beforeTotalHp - TotalHp;
if (totalDamageTaken != 0)
{
PercentDamageJustInflicted = MathUtils.Clamp(totalDamageTaken / Creature.maxHitPoints, 0, 1);
}
UpdateHitPointsStr();
}
static public IAttackLauncher Create(AttackKind kind, IPlayerAudioManager playerAudioManager, Player player)
{
switch (kind)
{
case AttackKind.BirdPoop:
return(new BirdProjectileLauncher(playerAudioManager));
case AttackKind.CatProjectile:
default:
return(new CatProjectileLauncher(playerAudioManager, player));
}
return(null);
}
public Attack(AttackKind kind, Verb verb, int hitValue, int damageValue, int staminaPenalty, int range)
: this()
{
if (verb == null)
{
throw new ArgumentNullException("verb");
}
this.Kind = kind;
this.Verb = verb;
this.HitValue = hitValue;
this.DamageValue = damageValue;
this.StaminaPenalty = staminaPenalty;
this.Range = range;
}
public Attack(AttackKind kind, Verb verb, int hitValue, int damageValue, int staminaPenalty = 0, short range = 0, int rapid1 = 0, int rapid2 = 0)
{
Kind = kind;
Verb = verb
#if DEBUG
?? throw new ArgumentNullException(nameof(verb))
#endif
;
HitValue = hitValue;
Hit2Value = rapid1;
Hit3Value = rapid2;
DamageValue = damageValue;
StaminaPenalty = staminaPenalty;
Range = range;
DisarmChance = 0; // mockup.
}
virtual public void Hurt(float delta, AttackKind kind)
{
switch (kind)
{
case AttackKind.Physics:
delta = Mathf.Min(0, -delta + m_defend);
break;
case AttackKind.Magic:
delta = Mathf.Min(0, -delta + m_magicDefend);
break;
case AttackKind.Real:
delta = Mathf.Min(0, -delta);
break;
}
Health = Mathf.Max(0, delta + Health);
}
public void TakeSomeDamage(DndGame game, DamageType damageType, AttackKind attackKind, int amount)
{
if (amount <= 0)
{
return;
}
double previousHP = TotalHp;
Creature.TakeDamage(damageType, attackKind, amount);
if (game == null)
{
return;
}
double hpLost = previousHP - TotalHp;
if (hpLost == 0)
{
return;
}
string tempHpDetails = string.Empty;
if (Creature.tempHitPoints > 0)
{
tempHpDetails = $" (tempHp: {Creature.tempHitPoints})";
}
string message;
if (hpLost == 1)
{
message = $"{Name} just took 1 point of {damageType} damage. HP is now: {Creature.HitPoints}/{Creature.maxHitPoints}{tempHpDetails}";
}
else
{
message = $"{Name} just took {hpLost} points of {damageType} damage. HP is now: {Creature.HitPoints}/{Creature.maxHitPoints}{tempHpDetails}";
}
game.TellDungeonMaster(message);
}
private void Phase1_Melody_A(int bullet_Num)
{
//次の攻撃を選択する
AttackKind next_Attack = Select_Next_Attack(pre_Attack);
pre_Attack = next_Attack;
//選択した攻撃を開始する
switch (next_Attack)
{
case AttackKind.close_Slash: _attack_Func.StartCoroutine("Close_Slash_Cor"); break;
case AttackKind.long_Slash: _attack_Func.StartCoroutine("Long_Slash_Cor", bullet_Num); break;
case AttackKind.barrier: _attack_Func.StartCoroutine("Barrier_Walk_Cor", 200f); break;
}
//攻撃無効化(有効化は攻撃のコルーチン内で行う)
can_Attack = false;
}
public static AttackKind DiscoverAttackKind(AttackKind attackKind, Weapon wpn)
{
if (attackKind == AttackKind.Unset)
{
attackKind = AttackKind.Melee;
if (wpn != null)
{
if (wpn.IsBowLike)
{
attackKind = AttackKind.PhysicalProjectile;
}
else if (wpn.IsMagician)
{
attackKind = AttackKind.WeaponElementalProjectile;
}
}
}
return(attackKind);
}
void SetAttackSequence(int index)
{
Debug.Assert(0 <= index && index < AtkSequences.Length);
// for(int i = 0;i < ShotParams.Length;i++)
foreach (var param in ShotParams)
{
param.Clear();
}
var seq = AtkSequences[index];
AtkKind = seq.Kind;
AtkInterval = seq.IntervalTime;
int next = index + 1;
NextHPRate = (next < AtkSequences.Length) ? AtkSequences[next].StartPercent / 100.0f : 0;
State = (AtkInterval > 0)? StateStatus.Interval : StateStatus.Attack;
}
public static Attack RangedAttack(AttackKind kind, Verb verb, int normalHitValue, int rapidFire1HitValue, int rapidFire2HitValue, int damageValue, int range)
{
return(new Attack(kind, verb, normalHitValue, rapidFire1HitValue, rapidFire2HitValue, damageValue, 0, 0, range));
}
public void TakeHalfDamage(Character player, Dictionary <DamageType, int> latestDamage, AttackKind attackKind)
{
StartTakingDamage();
foreach (DamageType damageType in latestDamage.Keys)
{
int damageTaken = DndUtils.HalveValue(latestDamage[damageType]);
TakeSomeDamage(player, damageType, attackKind, damageTaken);
}
FinishTakingDamage();
}
public void TakeDamage(Character player, Dictionary <DamageType, int> latestDamage, AttackKind attackKind)
{
StartTakingDamage();
foreach (DamageType damageType in latestDamage.Keys)
{
TakeSomeDamage(player, damageType, attackKind, latestDamage[damageType]);
}
FinishTakingDamage();
}
public bool IsTotallyImmuneToDamage(System.Collections.Generic.Dictionary <DamageType, int> latestDamage, AttackKind attackKind)
{
foreach (DamageType damageType in latestDamage.Keys)
{
if (!Creature.IsImmuneTo(damageType, attackKind))
{
return(false);
}
}
return(true);
}
public bool Matches(DamageType damageType, AttackKind attackKind)
{
return(MatchesDamage(damageType) && MatchesAttackKind(attackKind));
}
bool MatchesAttackKind(AttackKind attackKind)
{
return((attackKind & AttackKind) == attackKind);
}
/// <summary>
/// プロパティを設定する
/// </summary>
/// <param name="attack">攻撃力</param>
/// <param name="damageRate">ダメージの振れ幅</param>
/// <param name="kind">攻撃の種類</param>
/// <param name="parentPlayer">攻撃を出した親オブジェクト</param>
public void SetProperties(int attack, float damageRate, AttackKind kind, PlayerChar parentPlayer, int sp = 0)
{
// 攻撃力を設定する
this.attack = attack;
// 攻撃力の振れ幅を設定する
this.damageRate = damageRate;
// 攻撃の種類を設定する
this.attackKind = kind;
// 攻撃の親オブジェクトを設定する
this.parentPlayer = parentPlayer;
// 加算されるSPの値を入れる
this.sp = sp;
}
public Attack AddDamage(DamageType damageType, string damageRoll, AttackKind attackKind, TimePoint damageHits = TimePoint.Immediately, TimePoint saveOpportunity = TimePoint.None, Conditions conditions = Conditions.None, int savingThrowSuccess = int.MaxValue, Ability savingThrowAbility = Ability.none)
{
damages.Add(new Damage(damageType, attackKind, damageRoll, damageHits, saveOpportunity, conditions, savingThrowSuccess, savingThrowAbility));
return(this);
}
public DamageFilter(DamageType damageType, AttackKind attackKind)
{
AttackKind = attackKind;
DamageType = damageType;
}
private void CalcMembers
(
LivingEntity ent,
Weapon wpn,
Dictionary <Weapon.WeaponKind, EntityStatKind> weapons2Esk,
EntityStatKind attackStat,
AttackKind attackKind
)
{
if (attackStat != EntityStatKind.Unset)
{
Current = ent.GetCurrentValue(attackStat);
}
else
{
Current = 0;
}
OffensiveSpell offensiveSpell = spell;
if (wpn != null)
{
if (wpn.IsBowLike && attackKind == AttackKind.PhysicalProjectile)
{
if (fightItem.IsBowLikeAmmo)
{
Current += fightItem.Damage;
}
else
{
Current -= wpn.Damage;//ammo not matching
}
}
else if (wpn.IsMagician && attackKind == AttackKind.WeaponElementalProjectile)
{
offensiveSpell = wpn.SpellSource.CreateSpell(ent) as OffensiveSpell;
}
}
if (attackKind == AttackKind.PhysicalProjectile && fightItem != null)
{
if (fightItem.FightItemKind == Tiles.Looting.FightItemKind.Stone ||
fightItem.FightItemKind == Tiles.Looting.FightItemKind.ThrowingKnife
)
{
Current += fightItem.Damage;
Current += ent.Stats.Strength / 2;
}
}
CurrentPhysical = Current;
CurrentPhysicalVariated = CurrentPhysical;
if (withVariation)//GUI is not meant to have it changed on character panel
{
CurrentPhysicalVariated += CalcVariation(attackKind, true, CurrentPhysical);
}
if (CurrentPhysicalVariated < 0)
{
CurrentPhysicalVariated = 0;
}
if (CurrentPhysical < 0)
{
CurrentPhysical = 0;
}
var val = CurrentPhysicalVariated;
//add melee damage
AddExtraDamage(ent, wpn, weapons2Esk, ref val);
CurrentPhysicalVariated += val - CurrentPhysicalVariated;
CurrentTotal = CurrentPhysicalVariated;
if (offensiveSpell != null &&
(attackKind == AttackKind.SpellElementalProjectile || attackKind == AttackKind.WeaponElementalProjectile))
{
var dmg = offensiveSpell.GetDamage();
if (withVariation)
{
dmg += CalcVariation(attackKind, true, dmg);
}
if (wpn != null && attackKind == AttackKind.WeaponElementalProjectile)
{
//add extra magic projectile damage
AddExtraDamage(ent, wpn, weapons2Esk, ref dmg);
}
NonPhysical[offensiveSpell.Kind.ToEntityStatKind()] = dmg;
CurrentTotal += dmg;
}
if (attackKind != AttackKind.SpellElementalProjectile)
{
var nonPhysical = ent.GetNonPhysicalDamages();
foreach (var npd in nonPhysical)
{
bool add = true;
if (wpn != null)
{
if (attackKind == AttackKind.WeaponElementalProjectile)
{
if (wpn.IsMagician)
{
add = offensiveSpell.Kind.ToEntityStatKind() == npd.Key;
}
}
else if (attackKind == AttackKind.Melee)
{
add = !wpn.IsBowLike;
}
if (add)
{
var addition = npd.Value;
AddExtraDamage(ent, wpn, weapons2Esk, ref addition);
CurrentTotal += addition;
if (!NonPhysical.ContainsKey(npd.Key))
{
NonPhysical[npd.Key] = 0;
}
NonPhysical[npd.Key] += addition;
}
}
}
}
Nominal = ent.Stats.GetStat(attackStat).Value.Nominal;
Display = Nominal + "/" + CurrentTotal;
}
public float CalcVariation(AttackKind attackKind, bool signed, float currentDamage)
{
return(ent.GetAttackVariation(attackKind, currentDamage, signed));
}
private void Calc(LivingEntity ent, bool withVariation, ref AttackKind attackKind, OffensiveSpell spell)
{
try
{
this.withVariation = withVariation;
this.spell = spell;
NonPhysical = new Dictionary <EntityStatKind, float>();
this.ent = ent;
Weapon wpn = null;
//if (ent != null)//can be if using WeaponElementalProjectile
{
wpn = ent.GetActiveWeapon();
attackKind = DiscoverAttackKind(attackKind, wpn);
AttackKind = attackKind;
}
if (AttackKind == AttackKind.SpellElementalProjectile && spell == null)
{
return;
}
if (attackKind == AttackKind.PhysicalProjectile)
{
fightItem = GetActiveFightItem(ent);
if (fightItem == null)
{
return;
}
}
if (attackKind == AttackKind.WeaponElementalProjectile)
{
if (wpn != null)
{
if (wpn.SpellSource == null || wpn.SpellSource.Count == 0)
{
return;
}
}
else
{
return;
}
}
Dictionary <Weapon.WeaponKind, EntityStatKind> weapons2Esk = null;
EntityStatKind attackStat = EntityStatKind.Unset;
if (attackKind == AttackKind.Melee)
{
attackStat = EntityStatKind.MeleeAttack;
weapons2Esk = AdvancedLivingEntity.MalleeWeapons2Esk;
if (wpn != null && wpn.IsMagician)
{
weapons2Esk = AdvancedLivingEntity.ProjectileWeapons2Esk;
}
}
else if (attackKind == AttackKind.PhysicalProjectile ||
attackKind == AttackKind.WeaponElementalProjectile)
{
attackStat = EntityStatKind.Unset;
if (attackKind == AttackKind.PhysicalProjectile)
{
attackStat = EntityStatKind.PhysicalProjectilesAttack;
}
else
{
attackStat = EntityStatKind.ElementalWeaponProjectilesAttack;
}
weapons2Esk = AdvancedLivingEntity.ProjectileWeapons2Esk;
}
CalcMembers(ent, wpn, weapons2Esk, attackStat, attackKind);
}
catch (System.Exception ex)
{
throw ex;
}
}
/// <summary>
/// Constructor for actor base melee attacks.
/// </summary>
/// <param name="kind"></param>
/// <param name="verb"></param>
/// <param name="hitValue"></param>
/// <param name="damageValue"></param>
public Attack(AttackKind kind, Verb verb, int hitValue, int damageValue)
: this(kind, verb, hitValue, hitValue, hitValue, damageValue, 0, 0, 0)
{
}
