public void OnConcentrationTick(NWCreature creature, NWObject target, int spellTier, int tick)
{
int amount;
switch (spellTier)
{
case 1:
amount = 5;
break;
case 2:
amount = 6;
break;
case 3:
amount = 7;
break;
case 4:
amount = 8;
break;
case 5:
amount = 10;
break;
default:
throw new ArgumentOutOfRangeException(nameof(spellTier));
}
var result = CombatService.CalculateAbilityResistance(creature, target.Object, SkillType.ForceAlter, ForceBalanceType.Dark);
// +/- percent change based on resistance
float delta = 0.01f * result.Delta;
amount = amount + (int)(amount * delta);
if (target.GetLocalInt("FORCE_DRAIN_IMMUNITY") == 1)
{
amount = 0;
}
creature.AssignCommand(() =>
{
_.ApplyEffectToObject(DurationType.Instant, _.EffectDamage(amount, DamageType.Negative), target);
});
// Only apply a heal if caster is not at max HP. Otherwise they'll get unnecessary spam.
if (creature.CurrentHP < creature.MaxHP)
{
_.ApplyEffectToObject(DurationType.Instant, _.EffectHeal(amount), creature);
}
if (creature.IsPlayer)
{
SkillService.RegisterPCToNPCForSkill(creature.Object, target, SkillType.ForceAlter);
}
_.ApplyEffectToObject(DurationType.Instant, _.EffectVisualEffect(VisualEffect.Vfx_Com_Hit_Negative), target);
}
public override void Update(SimulationEntity entity, Simulation simulation)
{
if (_useGravity)
{
entity.Velocity.Y += Gravity;
entity.Velocity.X *= Friction;
//Caps your speed in specific axis
if (System.Math.Abs(entity.Velocity.X) > MaxSpeed.X)
{
entity.Velocity.X = entity.Velocity.X > 0 ? MaxSpeed.X : -MaxSpeed.X;
}
if (System.Math.Abs(entity.Velocity.Y) > MaxSpeed.Y)
{
entity.Velocity.Y = entity.Velocity.Y > 0 ? MaxSpeed.Y : -MaxSpeed.Y;
}
entity.Rotation = (float)System.Math.Atan2(entity.Velocity.Y, entity.Velocity.X) + (float)(System.Math.PI / 2);
}
entity.Position.Add(entity.Velocity);
//Collision Test
Collision.DetectCollision(simulation, entity);
if (!_hitTarget)
{
return;
}
CombatService.FightPeople(entity, _targetsHit, simulation);
simulation.RemoveEntity(entity.EntityId);
}
public void Test_FirstAttacker()
{
Player p = new Player("", "", 0, 18, 0, 0, 0);
Monster m = new Monster(0, "", "", 0, 12, null, 0, 0);
CombatService.Combatant result = CombatService.FirstAttacker(p, m);
}
private CombatService CreateCombatService()
{
var userID = Guid.Parse(User.Identity.GetUserId());
var service = new CombatService(userID);
return(service);
}
public void Execute(LivingEntity actor, LivingEntity target)
{
string actorName = (actor is Player) ? "You" : $"The {actor.Name.ToLower()}";
string targetName = (target is Player) ? "you" : $"the {target.Name.ToLower()}";
if (CombatService.AttackSucceeded(actor, target))
{
int manaLost = _manaCost;
actor.LoseMana(manaLost);
if (CombatService.CriticalHit(actor, target))
{
int damage = 2 * RandomNumberGenerator.NumberBetween(_minimumDamage, _maximumDamage);
target.TakeDamage(damage);
ReportResult($"{actorName} hit {targetName} with a critial hit, dealing {damage} point{(damage > 1 ? "s" : "")}.");
}
else
{
int damage = RandomNumberGenerator.NumberBetween(_minimumDamage, _maximumDamage);
ReportResult($"{actorName} hit {targetName} for {damage} point{(damage > 1 ? "s" : "")}.");
target.TakeDamage(damage);
}
}
else
{
int manaLost = _manaCost;
actor.LoseMana(manaLost);
ReportResult($"{actorName} missed {targetName}.");
}
}
public void Test_FirstAttacker()
{
Player player = new Player("", "", 0, 0, 0, 18, 0);
Enemy enemy = new Enemy(0, "", "", 0, 12, null, 0, 0);
CombatService.FirstAttacker(player, enemy);
}
private SelectList CombatSelect(int selectedID)
{
var userID = Guid.Parse(User.Identity.GetUserId());
var characters = new CombatService(userID).GetCombats().ToList();
return(new SelectList(characters, "CombatID", "Name", selectedID));
}
void _view_Winners(object sender, EventArgs e)
{
var service = new CombatService();
var combats = service.Winners();
_view.CombatsGrid = combats;
}
public void OnImpact(NWCreature creature, NWObject target, int perkLevel, int spellTier)
{
int damage;
int intMod = creature.IntelligenceModifier;
switch (spellTier)
{
case 1:
damage = 10 + intMod;
break;
case 2:
damage = 15 + intMod;
break;
case 3:
damage = 20 + ((intMod * 15) / 10);
break;
case 4:
damage = 25 + ((intMod * 17) / 10);
break;
case 5:
damage = 30 + (intMod * 2);
break;
default:
throw new ArgumentOutOfRangeException(nameof(spellTier));
}
var result = CombatService.CalculateAbilityResistance(creature, target.Object, SkillType.ForceAlter, ForceBalanceType.Universal, true);
// +/- percent change based on resistance
float delta = 0.01f * result.Delta;
damage = damage + (int)(damage * delta);
var targetLocation = _.GetLocation(creature);
var delay = _.GetDistanceBetweenLocations(creature.Location, targetLocation) / 18.0f + 0.35f;
creature.AssignCommand(() =>
{
_.PlaySound("plr_force_blast");
DoFireball(target);
});
creature.DelayAssignCommand(() =>
{
_.ApplyEffectToObject(DurationType.Instant, _.EffectDamage(damage), target);
_.ApplyEffectToObject(DurationType.Instant, _.EffectVisualEffect(VisualEffect.Vfx_Imp_Silence), target);
_.ApplyEffectToObject(DurationType.Instant, _.EffectVisualEffect(VisualEffect.VFX_IMP_KIN_L), target);
}, delay);
if (creature.IsPlayer)
{
SkillService.RegisterPCToNPCForSkill(creature.Object, target, SkillType.ForceAlter);
}
}
public void Test_FirstAttacker()
{
// Player and monster with dexterity 12
var player = new Player("", "", 0, 12, 0, 18, 0);
var monster = new Monster(0, "", "", 12, 0, null, 0, 0);
var result = CombatService.FirstAttacker(player, monster);
}
public void Test_FirstAttacker()
{
//Built for debugging purposes
Player player = new Player("", "", 0, 0, 0, 18, 4);
Monster monster = new Monster(0, "", "", 0, 12, 0, 0);
CombatService.Combatant result = CombatService.FirstAttacker(player, monster);
}
public void OnImpact(NWCreature creature, NWObject target, int perkLevel, int spellTier)
{
int damage;
int mod = creature.WisdomModifier;
switch (spellTier)
{
case 1:
damage = 5 + mod;
break;
case 2:
damage = 10 + ((mod * 125) / 100);
break;
case 3:
damage = 10 + ((mod * 15) / 10);
break;
case 4:
damage = 15 + ((mod * 175) / 100);
break;
case 5:
damage = 15 + (mod * 2);
break;
default:
throw new ArgumentOutOfRangeException(nameof(spellTier));
}
var result = CombatService.CalculateAbilityResistance(creature, target.Object, SkillType.ForceAlter, ForceBalanceType.Universal, true);
// +/- percent change based on resistance
var delta = 0.01f * result.Delta;
damage = damage + (int)(damage * delta);
var targetLocation = _.GetLocation(creature);
var delay = _.GetDistanceBetweenLocations(creature.Location, targetLocation) / 18.0f + 0.35f;
creature.AssignCommand(() =>
{
DoRock(target);
_.PlaySound("plr_force_throw");
});
creature.DelayAssignCommand(() =>
{
_.ApplyEffectToObject(DurationType.Instant, _.EffectDamage(damage, DamageType.Bludgeoning), target);
_.ApplyEffectToObject(DurationType.Instant, _.EffectVisualEffect(VisualEffect.Vfx_Imp_Dust_Explosion), target);
}, delay);
if (creature.IsPlayer)
{
SkillService.RegisterPCToNPCForSkill(creature.Object, target, SkillType.ForceAlter);
}
}
// Start is called before the first frame update
private void Start()
{
_combatService = new CombatService();
CurrentCharacter = new CharacterDto() // Devrait être choppé dans un autre service, ou dans un autre controller
{
Attack = 20,
Defense = 20,
Hp = 100
};
}
public void Setup()
{
_slack.Setup(slack => slack.GetUsersInChannel("coco-channel")).Returns(Task.FromResult(new List <string> {
"robert"
}));
_userService.Setup(service => service.IsUserActive(It.IsAny <string>())).Returns(Task.FromResult(true));
_channelRepository.Setup(repo => repo.GetChannelType("coco-channel")).Returns(ChannelType.Common);
_itemEventDispatcher.Setup(disp => disp.OnStealingAmount(It.IsAny <User>(), It.IsAny <int>())).Returns(1);
_combatService = new CombatService(_itemEventDispatcher.Object, _userRepository.Object, _slack.Object, _statsRepository.Object, _randomService.Object, _userService.Object, _channelRepository.Object, _monsterRepository.Object, _monsterService.Object);
}
public void OnImpact(NWCreature creature, NWObject target, int perkLevel, int spellTier)
{
float duration = 0.0f;
switch (spellTier)
{
case 1:
duration = 6f;
break;
case 2:
duration = 12f;
break;
case 3:
duration = 18f;
break;
case 4:
duration = 24f;
break;
}
var result = CombatService.CalculateAbilityResistance(creature, target.Object, SkillType.ForceAlter, ForceBalanceType.Universal);
// Resisted - Only apply slow for six seconds
if (result.IsResisted)
{
_.ApplyEffectToObject(DurationType.Temporary, _.EffectSlow(), target, 6.0f);
}
// Not resisted - Apply knockdown for the specified duration
else
{
// Check lucky chance.
int luck = PerkService.GetCreaturePerkLevel(creature, PerkType.Lucky);
if (RandomService.D100(1) <= luck)
{
duration *= 2;
creature.SendMessage("Lucky Force Push!");
}
_.ApplyEffectToObject(DurationType.Temporary, AbilityService.EffectKnockdown(target, 3.0f), target, 3.0f);
_.ApplyEffectToObject(DurationType.Temporary, _.EffectSlow(), target, duration);
}
if (creature.IsPlayer)
{
SkillService.RegisterPCToAllCombatTargetsForSkill(creature.Object, SkillType.ForceAlter, target.Object);
}
_.ApplyEffectToObject(DurationType.Instant, _.EffectVisualEffect(VisualEffect.Vfx_Com_Blood_Spark_Small), target);
}
public void OnConcentrationTick(NWCreature creature, NWObject target, int spellTier, int tick)
{
int amount;
int mod = ((creature.WisdomModifier + creature.IntelligenceModifier) / 2);
switch (spellTier)
{
case 1:
amount = 2 + mod;
break;
case 2:
amount = 3 + mod;
break;
case 3:
amount = 4 + mod;
break;
case 4:
amount = 5 + mod;
break;
case 5:
amount = 6 + mod;
break;
default:
throw new ArgumentOutOfRangeException(nameof(spellTier));
}
var result = CombatService.CalculateAbilityResistance(creature, target.Object, SkillType.ForceAlter, ForceBalanceType.Dark);
// +/- percent change based on resistance
float delta = 0.01f * result.Delta;
amount = amount + (int)(amount * delta);
creature.AssignCommand(() =>
{
_.ApplyEffectToObject(DurationType.Instant, _.EffectDamage(amount, DamageType.Bludgeoning), target);
});
if (creature.IsPlayer)
{
SkillService.RegisterPCToNPCForSkill(creature.Object, target, SkillType.ForceAlter);
}
_.PlaySound("plr_force_choke");
_.ApplyEffectToObject(DurationType.Temporary, _.EffectVisualEffect(VisualEffect.Vfx_Fnf_Demon_Hand), target, 6.1f);
_.ApplyEffectToObject(DurationType.Temporary, _.EffectVisualEffect(VisualEffect.Vfx_Imp_Starburst_Red), target, 6.1f);
}
public void OnImpact(NWPlayer player, NWObject target, int level, int spellFeatID)
{
int ticks;
var spread = CustomEffectService.GetForceSpreadDetails(player);
switch (level)
{
default:
ticks = 300;
break;
case 5:
case 6:
ticks = 600;
break;
}
int itemPotency = CombatService.CalculateItemPotencyBonus(player.Object, ForceAbilityType.Light);
int basePotency = (int)(player.Wisdom + player.Intelligence * 0.5f + player.Charisma * 0.25f);
int finalPotency = itemPotency + basePotency;
ticks += finalPotency * 10; // +10 seconds per potency
// Force Spread isn't active. This is a single target cast.
if (spread.Level <= 0)
{
CustomEffectService.ApplyCustomEffect(player, target.Object, CustomEffectType.ForceAura, ticks, level, null);
_.ApplyEffectToObject(DURATION_TYPE_INSTANT, _.EffectVisualEffect(VFX_IMP_AC_BONUS), target);
}
// Force Spread is active. Target nearby party members.
else
{
spread.Uses--;
var members = player.PartyMembers.Where(x => _.GetDistanceBetween(x, target) <= spread.Range ||
Equals(x, target));
foreach (var member in members)
{
CustomEffectService.ApplyCustomEffect(member, target.Object, CustomEffectType.ForceAura, ticks, level, null);
_.ApplyEffectToObject(DURATION_TYPE_INSTANT, _.EffectVisualEffect(VFX_IMP_AC_BONUS), member);
}
_.PlaySound("v_pro_frcaura");
CustomEffectService.SetForceSpreadUses(player, spread.Uses);
SkillService.RegisterPCToAllCombatTargetsForSkill(player, SkillType.ForceUtility, null);
}
SkillService.RegisterPCToAllCombatTargetsForSkill(player, SkillType.ForceSupport, null);
}
public void OnImpact(NWCreature creature, NWObject target, int perkLevel, int spellTier)
{
float duration = 0.0f;
switch (spellTier)
{
case 1:
duration = 6f;
break;
case 2:
duration = 12f;
break;
case 3:
duration = 18f;
break;
case 4:
duration = 24f;
break;
}
var result = CombatService.CalculateAbilityResistance(creature, target.Object, SkillType.ForceAlter, ForceBalanceType.Universal);
// Resisted - Only apply slow for six seconds
if (result.IsResisted)
{
_.ApplyEffectToObject(_.DURATION_TYPE_TEMPORARY, _.EffectSlow(), target, 6.0f);
}
// Not resisted - Apply knockdown for the specified duration
else
{
// Check lucky chance.
int luck = PerkService.GetCreaturePerkLevel(creature, PerkType.Lucky);
if (RandomService.D100(1) <= luck)
{
duration *= 2;
creature.SendMessage("Lucky Force Push!");
}
_.ApplyEffectToObject(_.DURATION_TYPE_TEMPORARY, _.EffectKnockdown(), target, duration);
}
if (creature.IsPlayer)
{
SkillService.RegisterPCToAllCombatTargetsForSkill(creature.Object, SkillType.ForceAlter, target.Object);
}
_.ApplyEffectToObject(_.DURATION_TYPE_INSTANT, _.EffectVisualEffect(_.VFX_COM_BLOOD_SPARK_SMALL), target);
}
public void OnImpact(NWCreature creature, NWObject target, int perkLevel, int spellTier)
{
int damage;
int intMod = creature.IntelligenceModifier;
switch (spellTier)
{
case 1:
damage = 10 + intMod;
break;
case 2:
damage = 15 + intMod;
break;
case 3:
damage = 20 + ((intMod * 15) / 10);
break;
case 4:
damage = 25 + ((intMod * 17) / 10);
break;
case 5:
damage = 30 + (intMod * 2);
break;
default:
throw new ArgumentOutOfRangeException(nameof(spellTier));
}
var result = CombatService.CalculateAbilityResistance(creature, target.Object, SkillType.ForceAlter, ForceBalanceType.Dark, true);
// +/- percent change based on resistance
float delta = 0.01f * result.Delta;
damage = damage + (int)(damage * delta);
creature.AssignCommand(() =>
{
_.ApplyEffectToObject(DurationType.Instant, _.EffectDamage(damage), target);
});
if (creature.IsPlayer)
{
SkillService.RegisterPCToNPCForSkill(creature.Object, target, SkillType.ForceAlter);
}
_.ApplyEffectToObject(DurationType.Instant, _.EffectVisualEffect(VisualEffect.Vfx_Imp_Silence), target);
}
private static void Main(string[] args)
{
var player = ClassService.GetBase("Human Barbarian", BaseClass.Barbarian, true, new Stat(), WeaponClass.Club);
var enemy = ClassService.GetBase("Kobold Cleric", BaseClass.Cleric, true, new Stat(), WeaponClass.Unarmed);
var playerWeapon = WeaponService.GetWeapon("Club", WeaponClass.Club);
var enemyWeapon = WeaponService.GetWeapon("Dagger", WeaponClass.Dagger);
Helper.Program.DisplayCharacters.DisplayCharacter(player);
Helper.Program.DisplayCharacters.DisplayCharacter(enemy);
var combatService = new CombatService(player, enemy, playerWeapon, enemyWeapon);
Console.ReadLine();
}
public void OnImpact(NWCreature creature, NWObject target, int perkLevel, int spellTier)
{
int damage;
switch (spellTier)
{
case 1:
damage = 100;
break;
case 2:
damage = 125;
break;
case 3:
damage = 160;
break;
case 4:
damage = 200;
break;
case 5:
damage = 250;
break;
default:
throw new ArgumentOutOfRangeException(nameof(spellTier));
}
var result = CombatService.CalculateAbilityResistance(creature, target.Object, SkillType.ForceAlter, ForceBalanceType.Dark, true);
// +/- percent change based on resistance
float delta = 0.01f * result.Delta;
damage = damage + (int)(damage * delta);
creature.AssignCommand(() =>
{
_.ApplyEffectToObject(_.DURATION_TYPE_INSTANT, _.EffectDamage(damage), target);
});
if (creature.IsPlayer)
{
SkillService.RegisterPCToNPCForSkill(creature.Object, target, SkillType.ForceAlter);
}
_.ApplyEffectToObject(_.DURATION_TYPE_INSTANT, _.EffectVisualEffect(_.VFX_IMP_SILENCE), target);
}
public void OnConcentrationTick(NWCreature creature, NWObject target, int spellTier, int tick)
{
int amount;
switch (spellTier)
{
case 1:
amount = 10;
break;
case 2:
amount = 12;
break;
case 3:
amount = 14;
break;
case 4:
amount = 16;
break;
case 5:
amount = 20;
break;
default:
throw new ArgumentOutOfRangeException(nameof(spellTier));
}
var result = CombatService.CalculateAbilityResistance(creature, target.Object, SkillType.ForceAlter, ForceBalanceType.Dark);
// +/- percent change based on resistance
float delta = 0.01f * result.Delta;
amount = amount + (int)(amount * delta);
creature.AssignCommand(() =>
{
_.ApplyEffectToObject(DurationType.Instant, _.EffectDamage(amount, DamageType.Electrical), target);
});
if (creature.IsPlayer)
{
SkillService.RegisterPCToNPCForSkill(creature.Object, target, SkillType.ForceAlter);
}
_.ApplyEffectToObject(DurationType.Instant, _.EffectVisualEffect(VisualEffect.Vfx_Imp_Lightning_S), target);
}
public void OnConcentrationTick(NWCreature creature, NWObject target, int spellTier, int tick)
{
int amount;
switch (spellTier)
{
case 1:
amount = 2 + (int)(creature.IntelligenceModifier);
break;
case 2:
amount = 4 + (int)(creature.IntelligenceModifier * 1.15);
break;
case 3:
amount = 6 + (int)(creature.IntelligenceModifier * 1.25);
break;
case 4:
amount = 8 + (int)(creature.IntelligenceModifier * 1.5);
break;
case 5:
amount = 10 + (int)(creature.IntelligenceModifier * 2);
break;
default:
throw new ArgumentOutOfRangeException(nameof(spellTier));
}
var result = CombatService.CalculateAbilityResistance(creature, target.Object, SkillType.ForceAlter, ForceBalanceType.Dark);
// +/- percent change based on resistance
float delta = 0.01f * result.Delta;
amount = amount + (int)(amount * delta);
creature.AssignCommand(() =>
{
_.PlaySound("plr_force_lightn");
_.ApplyEffectToObject(DurationType.Instant, _.EffectDamage(amount, DamageType.Electrical), target);
_.ApplyEffectToObject(DurationType.Temporary, _.EffectBeam(VisualEffect.Vfx_Beam_Silent_Lightning, creature, BodyNode.Hand), target, 1.0F);
});
if (creature.IsPlayer)
{
SkillService.RegisterPCToNPCForSkill(creature.Object, target, SkillType.ForceAlter);
}
}
public void StartNewCombat(GameData gameData)
{
Debug.Log("Starting new combat, enemy encountered!");
// open websocket for combat
combatSocket = new CombatSocket();
combatSocket.StartConnection(this, gameData.playerId);
combatData = CombatService.startNewCombat(gameData.playerId, gameData.gameId, gameData.combatEncounterId);
this.gameData = gameData;
playerId = gameData.playerId;
gameId = gameData.gameId;
encounterId = gameData.combatEncounterId;
combatEnd = false;
initGrid();
}
public Battle(Player player, Monster opponent)
{
_player = player;
_opponent = opponent;
_player.OnActionPerformed += OnCombatantActionPerformed;
_opponent.OnActionPerformed += OnCombatantActionPerformed;
_opponent.OnKilled += OnOpponentKilled;
_messageBroker.RaiseMessage("");
_messageBroker.RaiseMessage($"You see a {_opponent.Name} here!");
if (CombatService.FirstAttacker(_player, _opponent) == CombatService.Combatant.Opponent)
{
AttackPlayer();
}
}
public Battle(Player player, Enemy enemy)
{
_player = player;
_enemy = enemy;
_player.OnActionPerformed += OnCombatActionPerformed;
_enemy.OnActionPerformed += OnCombatActionPerformed;
_enemy.OnKilled += OnEnemyKilled;
_messageBroker.RaiseMessage($"\nYou see a {_enemy.Name}!");
if (CombatService.FirstAttacker(_player, _enemy) == CombatService.Combatant.Enemy)
{
AttackPlayer();
}
}
public void Execute(LivingEntity actor, LivingEntity target)
{
string actorString = (actor is Player) ? "You" : actor.Name;
string targetString = (target is Player) ? "you" : target.Name.ToLower();
if (CombatService.DoesAttackSucceeded(actor, target))
{
int damage = RandomNumberGenerator.GetRandNumberBetween(_minDamage, _maxDamage);
ReportResult($"\n{actorString} deal to {targetString} {damage} hp damage");
target.TakeDamage(damage);
}
else
{
ReportResult($"{actorString} missed {targetString}");
}
}
public void Execute(LivingEntity actor, LivingEntity target)
{
var actorName = actor is Player ? "You" : $"The {actor.Name.ToLower()}";
var targetName = target is Player ? "you" : $"the {target.Name.ToLower()}";
if (CombatService.AttackSucceeded(actor, target))
{
var damage = RandomNumberGenerator.NumberBetween(_minimumDamage, _maximumDamage);
ReportResult($"{actorName} hit {targetName} for {damage} point{(damage > 1 ? "s" : "")}");
target.TakeDamage(damage);
}
else
{
ReportResult($"{actorName} missed {targetName}");
}
}
private void RunEffect(NWCreature creature, NWObject target)
{
var concentrationEffect = AbilityService.GetActiveConcentrationEffect(target.Object);
if (concentrationEffect.Type == PerkType.MindShield)
{
creature.SendMessage("Your target is immune to tranquilization effects.");
return;
}
AbilityResistanceResult result = CombatService.CalculateAbilityResistance(creature, target.Object, SkillType.ForceAlter, ForceBalanceType.Dark);
// Tranquilization effect - Daze target(s). Occurs on succeeding the DC check.
Effect successEffect = EffectDazed();
successEffect = EffectLinkEffects(successEffect, EffectVisualEffect(VisualEffect.Vfx_Dur_Iounstone_Blue));
successEffect = TagEffect(successEffect, "TRANQUILIZER_EFFECT");
// AC & AB decrease effect - Occurs on failing the DC check.
Effect failureEffect = EffectLinkEffects(EffectAttackDecrease(5), EffectACDecrease(5));
if (!result.IsResisted)
{
creature.AssignCommand(() =>
{
ApplyEffectToObject(DurationType.Temporary, successEffect, target, 6.1f);
});
}
else
{
creature.AssignCommand(() =>
{
ApplyEffectToObject(DurationType.Temporary, failureEffect, target, 6.1f);
});
}
if (creature.IsPlayer)
{
SkillService.RegisterPCToNPCForSkill(creature.Object, target, SkillType.ForceAlter);
}
EnmityService.AdjustEnmity(target.Object, creature, 1);
}
public void Execute(LivingEntity actor, LivingEntity target)
{
string actorName = (actor is Player) ? "You" : $"The {actor.Name.ToLower()}";
string targetName = (target is Player) ? "you" : $"the {target.Name.ToLower()}";
if (CombatService.AttackSucceeded(actor, target))
{
int damage = DiceService.Instance.Roll(_damageDice).Value;
ReportResult($"{actorName} hit {targetName} for {damage} point{(damage > 1 ? "s" : "")}.");
target.TakeDamage(damage);
}
else
{
ReportResult($"{actorName} missed {targetName}.");
}
}
