It is possible to get the damage reduction type that the object haves?

Neverwinter Nights 2 Toolset, Scripting, NWNX
1

As the title says, is there any way to do it?

I’m trying to create a weapon that can ignore any type of damage reduction(or just the highest) of the target, right now i’m manually triggering a script through a bonus feat item property that i added to the weapon and i was thinking on changing the material using “SetItemBaseMaterialType”, the problem with this is that i don’t know how to get the type damage reductions.

I know that exist this effect called “EffectDamageReductionNegated” which should be another possible solution, the problem is that it may be too op since the target will be vulnerable to all the party instead of only the character that haves this particular weapon since i wouldn’t know how to synchronize it to be applied for a moment just before doing a melee attack.

I’m trying to create a shadow striking melee weapon for the curious.

A shadow striking weapon automatically attunes itself to the target. When it strikes a target that has damage reduction, it adjusts itself to overcome the damage reduction of that creature.
Effect: Shadow striking weapons draw on the reflective nature of shadow to alter their nature and overcome damage reduction. A shadow striking weapon can adjust to emulate any alignment or substance required to overcome damage reduction.
A shadow striking weapon’s attunement to a particular sort of damage reduction fades 1d4 minutes after the last time it made contact with the appropriate creature.

2

I don’t see the need to do something that convoluted to achieve what you’re asking for. Especially the duration, it’s going to be permanent either way since you attack more often than once every minute or 4.

Just apply a damage effect that bypasses resistances/immunities.
You might even make it of negative damage type since it’s a “shadow” striking weapon.

Give the weapon the no base damage property and the OnHitCastspell: Unique Power property, then make a script named “i_xxxx_hc” (where xxxx is the TAG of the weapon) and have that apply the proper damage that bypasses the damage reduction/resistance, that should work just the same, no?

The function to create the damage effect is EffectDamage( … )

// Create a Damage effect
// - nDamageAmount: amount of damage to be dealt. This should be applied as an
// instantaneous effect.
// - nDamageType: DAMAGE_TYPE_*
// - nDamagePower: DAMAGE_POWER_*
// - nIgnoreResistances: FALSE will use damage immunity, damage reduction, and damage resistance. TRUE will skip all of these.
effect EffectDamage(int nDamageAmount, int nDamageType=DAMAGE_TYPE_MAGICAL, int nDamagePower=DAMAGE_POWER_NORMAL, int nIgnoreResistances=FALSE);

3

Yeah, that may work better than what i had before or what i had planned, i forgot that DR only soak the damage so technically the onHit item property should still trigger. The challenge with this solution would be the damage calculation since the damage will need to be rolled again unless there is way to get how much damage you rolled before triggering the OnHit event.

Thanks, i’m going to try it out.

4

Work from here, it almost handles every calculation needed, maybe a few things are missing, but it has almost everything.

EDIT: Removed, better script a few posts below

5

One missing thing that comes to mind: your code doesn’t take into account the ranged weapon with the migthy item property.

Besides, all thrown weapons (except the shuriken) are automatically mighty (unimplicitly), with no limit on the strength modifier.

6

Thanks, that will help me a lot.

@Aqvilinus I’m only applying Shadow strike to certain weapons, not all of them. I’m creating this prestige class with some tweaks to make it more viable and fun. That class doesn’t allows you to create ranged weapons with its abilities.

7

Okay.

8

it still might be more complicated than it (might) seem

eg. Ranger’s Favored Enemy/Improved bonus, hand-and-a-half damage, etc.

9

It works perfectly. There still a problem with the default damage of the weapon, the No Combat Damage works well until you apply an Enhancement Bonus of +2 or higher to the weapon, when that happens, the weapon starts to do damage equal to the Enhancement bonus instead of 1 and that is doubled when the weapon crits.

10

I created this function for rolling damage since Random sometimes result in 0:

int RollDMG(int nDiceType = 2, int nAmount = 1, int nBonus = 0)
{
	int nDamage;
	switch(nDiceType)
	{
		case 2:  nDamage = d2(nAmount); break;
		case 3:  nDamage = d3(nAmount); break;
		case 4:  nDamage = d4(nAmount); break;
		case 6:  nDamage = d6(nAmount); break;
		case 8:  nDamage = d8(nAmount); break;
		case 10:  nDamage = d10(nAmount); break;
		case 12:  nDamage = d12(nAmount); break;
		case 20:  nDamage = d20(nAmount); break;
		case 100:  nDamage = d100(nAmount); break;
	}
		 
	return nDamage + nBonus;
}

And changed this:
int nDMG = nDICE_NUM * Random(nDICE_SIZE + 1);

To this:

int nDMG = RollDMG(nDICE_SIZE,nDICE_NUM);

11

It would have been easier to fix, I just had set that +1 in the wrong place:

int nDMG = nDICE_NUM * (1 + Random(nDICE_SIZE));

But yeah, I suppose either work in normal conditions.

12

I took your suggerence and ended with this:

int nDMG = Random(nDICE_SIZE); if(nDMG==0) nDMG = 1;
nDMG *= nDICE_NUM;

I figure out a solution to the glitch between No Combat Damage + Enhancement bonus that i described a few post ago by adding the item property DamagePenalty(5), that negates completely the damage bonus part of the enhancement bonus that is ignoring the No Combat Damage. The damage penalty it seems that only affect to the base damage of the weapon, isn’t affecting the damage from the EffectDamage.

13

Random(x) goes from 0 to x-1. So with that formula it won’t be correct, you will never have the max roll.

By the way, I also checked this a bit further and realized that there are many other things that not covered by the no base damage property.

I’d say pretty much everything that is not the weapon’s dice size itself.
STR modifier is applied
Weapon Spec is applied
Power attack is applied
Favored enemies are applied
I haven’t tested Sneak Attack, but I imagine that will be applied as well at this rate.
And all of it is multiplied by the crit multiplier when there’s a crit.

All of that will be applied despite the “no weapon damage” property, making the weapon hit much harder on enemies that don’t have any DR.

You could try upping the damage penalty from 5 to 20, and maybe pasting it 4-5 times, I’m not sure if it stacks, but it could be worth a shot.

14

Upping the penalty beyond 5 doesn’t apply the penalty and it doesn’t stack if is added more times. Yeah, it seems that is applying every modifier you are describing. That’s disappointing -.-.

Edit: I got another idea, i will let the weapon do the damage normally with the following logic, if you overcome the DR, the target absorbed part of your damage but still recieved some damage so it will receive extra damage with your code to compensate the loss but this extra damage will be halved or whatever but not full damage, on the contrary, if the target absorbed the whole damage, it will receive the full damage calculated by your code.

I will add this at the beginning of the code:

	object oLastDMG = GetLastDamager(oTarget);
	int nFullDMG = 1; //Full Damage
	if(oLastDMG == OBJECT_SELF) nFullDMG = 0; //If i caused damage, then reduce the extra damage

After all the extra damage calculation:

	if(nFullDMG == 0)
	{
		nDMG = nDMG/2;//It can be anything but full damage
		if(nDMG == 0) nDMG = 1;
	}

This may work, the problem with this is that it doesn’t discriminate whether the target have DR or not so, the extra damage will be applied no matter what.

I know you can get if the target haves DR via effects or Item property, and there are some feats that add them too but those can be easily added, that can be done by my part, my problem is that in the toolset, some creatures have damage reduction added through properties>character sheet, how can i get that DR?

15

I do not know of any way to retrieve those forms of DR from a creature, however, I kinda managed to do something that dynamically adjusts the damage you should deal based on the damage you actually dealt (which already includes all forms DRs)

The damage penalty from the weapon would have to be removed as it would no longer be needed and might actually get in the way of calculating the proper damage with this script.
The No Weapon Damage property should stay.

The logic behind this script is to get how much damage you have dealt, and then apply an irresistible negative damage based on the difference between how much you dealt and how much you should have dealt.

Since there appears to be no way to retrieve if the strike we just did was a critical or not, or how much we rolled on a specific random source of damage, I decided to exclude those events from the calculations.
While it would be possible to recalculate them, I feel that it would be kinda “unfair” since it would effectively give the weapon a second roll for crits and random damage results, while allowing to keep the best result.

The random roll of the weapon damage is obviously the exception as the No base damage property removes that roll, so you can roll it separately and apply it only once.

EDIT: Script in next post as it was a nightmare to edit from here.

16 
#include "x2_inc_itemprop"

const string s2DA = "baseitems";

//Condition Handlers

//Possible Results
//0 = Light Weapon (Unarmed and Creature excluded, they count for Power Attack)
//1 = One handed weapon (including unarmed and creature weapon)
//2 = Two handed weapon
int GetWeaponWeight(object oPC, int nWEAPON)
{
	int nSIZE_PC = GetCreatureSize(oPC);
	int nSIZE_WEAPON = StringToInt(Get2DAString(s2DA, "WeaponSize", nWEAPON));
	switch (nWEAPON)
	{
		case BASE_ITEM_KUKRI:
		case BASE_ITEM_DAGGER:
		case BASE_ITEM_SHORTSWORD:
		case BASE_ITEM_HANDAXE:
		case BASE_ITEM_KAMA:
		case BASE_ITEM_MACE:
		case BASE_ITEM_SICKLE:
		case BASE_ITEM_LIGHTHAMMER:
		case BASE_ITEM_RAPIER:
			if (nSIZE_WEAPON < nSIZE_PC) return 0;
			break;
		case BASE_ITEM_INVALID:
		case BASE_ITEM_GLOVES:
		case BASE_ITEM_CREATUREITEM:
			return 1;
	}
	if (GetItemInSlot(INVENTORY_SLOT_LEFTHAND, oPC) != OBJECT_INVALID) return 1;	
	if (nSIZE_WEAPON >= nSIZE_PC) return 2;
	return 1;
}

//Possible Results
//0 = No Feats
//1 = Favored Enemy only
//2 = Improved Favored Enemy only
//x + 10 = Above result + Favored Power Attack
int GetFavoredEnemyFeats(object oPC, object oTARGET)
{
	int nFEAT;
	int nPOWER;
	int nIMPROVED;
	int nRACE = GetRacialType(oTARGET);
	switch (nRACE)
	{
		case RACIAL_TYPE_ABERRATION:
			nFEAT = FEAT_FAVORED_ENEMY_ABERRATION;
			nIMPROVED = FEAT_IMPROVED_FAVORED_ENEMY_ABERRATION;
			nPOWER = FEAT_FAVORED_POWER_ATTACK_ABERRATION;
			break;
		case RACIAL_TYPE_ANIMAL:
			nFEAT = FEAT_FAVORED_ENEMY_ANIMAL;
			nIMPROVED = FEAT_IMPROVED_FAVORED_ENEMY_ANIMAL;
			nPOWER = FEAT_FAVORED_POWER_ATTACK_ANIMAL;
			break;
		case RACIAL_TYPE_BEAST:
			nFEAT = FEAT_FAVORED_ENEMY_BEAST;
			nIMPROVED = FEAT_IMPROVED_FAVORED_ENEMY_BEAST;
			nPOWER = FEAT_FAVORED_POWER_ATTACK_BEAST;
			break;
		case RACIAL_TYPE_CONSTRUCT:
			nFEAT = FEAT_FAVORED_ENEMY_CONSTRUCT;
			nIMPROVED = FEAT_IMPROVED_FAVORED_ENEMY_CONSTRUCT;
			nPOWER = FEAT_FAVORED_POWER_ATTACK_CONSTRUCT;
			break;
		case RACIAL_TYPE_DRAGON:
			nFEAT = FEAT_FAVORED_ENEMY_DRAGON;
			nIMPROVED = FEAT_IMPROVED_FAVORED_ENEMY_DRAGON;
			nPOWER = FEAT_FAVORED_POWER_ATTACK_DRAGON;
			break;
		case RACIAL_TYPE_DWARF:
			nFEAT = FEAT_FAVORED_ENEMY_DWARF;
			nIMPROVED = FEAT_IMPROVED_FAVORED_ENEMY_DWARF;
			nPOWER = FEAT_FAVORED_POWER_ATTACK_DWARF;
			break;
		case RACIAL_TYPE_ELEMENTAL:
			nFEAT = FEAT_FAVORED_ENEMY_ELEMENTAL;
			nIMPROVED = FEAT_IMPROVED_FAVORED_ENEMY_ELEMENTAL;
			nPOWER = FEAT_FAVORED_POWER_ATTACK_ELEMENTAL;
			break;
		case RACIAL_TYPE_ELF:
			nFEAT = FEAT_FAVORED_ENEMY_ELF;
			nIMPROVED = FEAT_IMPROVED_FAVORED_ENEMY_ELF;
			nPOWER = FEAT_FAVORED_POWER_ATTACK_ELF;
			break;
		case RACIAL_TYPE_FEY:
			nFEAT = FEAT_FAVORED_ENEMY_FEY;
			nIMPROVED = FEAT_IMPROVED_FAVORED_ENEMY_FEY;
			nPOWER = FEAT_FAVORED_POWER_ATTACK_FEY;
			break;
		case RACIAL_TYPE_GIANT:
			nFEAT = FEAT_FAVORED_ENEMY_GIANT;
			nIMPROVED = FEAT_IMPROVED_FAVORED_ENEMY_GIANT;
			nPOWER = FEAT_FAVORED_POWER_ATTACK_GIANT;
			break;
		case RACIAL_TYPE_GNOME:
			nFEAT = FEAT_FAVORED_ENEMY_GNOME;
			nIMPROVED = FEAT_IMPROVED_FAVORED_ENEMY_GNOME;
			nPOWER = FEAT_FAVORED_POWER_ATTACK_GNOME;
			break;
		case RACIAL_TYPE_HUMANOID_GOBLINOID:
			nFEAT = FEAT_FAVORED_ENEMY_GOBLINOID;
			nIMPROVED = FEAT_IMPROVED_FAVORED_ENEMY_GOBLINOID;
			nPOWER = FEAT_FAVORED_POWER_ATTACK_GOBLINOID;
			break;
		case RACIAL_TYPE_HALFELF:
			nFEAT = FEAT_FAVORED_ENEMY_HALFELF;
			nIMPROVED = FEAT_IMPROVED_FAVORED_ENEMY_HALFELF;
			nPOWER = FEAT_FAVORED_POWER_ATTACK_HALFELF;
			break;
		case RACIAL_TYPE_HALFLING:
			nFEAT = FEAT_FAVORED_ENEMY_HALFLING;
			nIMPROVED = FEAT_IMPROVED_FAVORED_ENEMY_HALFLING;
			nPOWER = FEAT_FAVORED_POWER_ATTACK_HALFLING;
			break;
		case RACIAL_TYPE_HALFORC:
			nFEAT = FEAT_FAVORED_ENEMY_HALFORC;
			nIMPROVED = FEAT_IMPROVED_FAVORED_ENEMY_HALFORC;
			nPOWER = FEAT_FAVORED_POWER_ATTACK_HALFORC;
			break;
		case RACIAL_TYPE_HUMAN:
			nFEAT = FEAT_FAVORED_ENEMY_HUMAN;
			nIMPROVED = FEAT_IMPROVED_FAVORED_ENEMY_HUMAN;
			nPOWER = FEAT_FAVORED_POWER_ATTACK_HUMAN;
			break;
		case RACIAL_TYPE_MAGICAL_BEAST:
			nFEAT = FEAT_FAVORED_ENEMY_MAGICAL_BEAST;
			nIMPROVED = FEAT_IMPROVED_FAVORED_ENEMY_MAGICAL_BEAST;
			nPOWER = FEAT_FAVORED_POWER_ATTACK_MAGICAL_BEAST;
			break;
		case RACIAL_TYPE_HUMANOID_MONSTROUS:
			nFEAT = FEAT_FAVORED_ENEMY_MONSTROUS;
			nIMPROVED = FEAT_IMPROVED_FAVORED_ENEMY_MONSTROUS;
			nPOWER = FEAT_FAVORED_POWER_ATTACK_MONSTROUS;
			break;
		case RACIAL_TYPE_HUMANOID_ORC:
			nFEAT = FEAT_FAVORED_ENEMY_ORC;
			nIMPROVED = FEAT_IMPROVED_FAVORED_ENEMY_ORC;
			nPOWER = FEAT_FAVORED_POWER_ATTACK_ORC;
			break;
		case RACIAL_TYPE_OUTSIDER:
			nFEAT = FEAT_FAVORED_ENEMY_OUTSIDER;
			nIMPROVED = FEAT_IMPROVED_FAVORED_ENEMY_OUTSIDER;
			nPOWER = FEAT_FAVORED_POWER_ATTACK_OUTSIDER;
			break;
		case RACIAL_TYPE_HUMANOID_REPTILIAN:
			nFEAT = FEAT_FAVORED_ENEMY_REPTILIAN;
			nIMPROVED = FEAT_IMPROVED_FAVORED_ENEMY_REPTILIAN;
			nPOWER = FEAT_FAVORED_POWER_ATTACK_REPTILIAN;
			break;
		case RACIAL_TYPE_SHAPECHANGER:
			nFEAT = FEAT_FAVORED_ENEMY_SHAPECHANGER;
			nIMPROVED = FEAT_IMPROVED_FAVORED_ENEMY_SHAPECHANGER;
			nPOWER = FEAT_FAVORED_POWER_ATTACK_SHAPECHANGER;
			break;
		case RACIAL_TYPE_UNDEAD:
			nFEAT = FEAT_FAVORED_ENEMY_UNDEAD;
			nIMPROVED = FEAT_IMPROVED_FAVORED_ENEMY_UNDEAD;
			nPOWER = FEAT_FAVORED_POWER_ATTACK_UNDEAD;
			break;
		case RACIAL_TYPE_VERMIN:
			nFEAT = FEAT_FAVORED_ENEMY_VERMIN;
			nIMPROVED = FEAT_IMPROVED_FAVORED_ENEMY_VERMIN;
			nPOWER = FEAT_FAVORED_POWER_ATTACK_UNDEAD;
			break;
		
		default: return 0;
	}
	
	int nFAVOR = 0;
	if (GetHasFeat(nIMPROVED, oPC, TRUE) == TRUE) nFAVOR = 2;
	else if (GetHasFeat(nFEAT, oPC, TRUE) == TRUE) nFAVOR = 1;
	if (GetHasFeat(nPOWER, oPC, TRUE) == TRUE) nFAVOR = nFAVOR + 10;
	return nFAVOR;
}



//Damage Calculators

int GetDamage_PowerAttack(object oPC, int nWEAPON, int nWEIGHT, int nFAVOR)
{
	if (nWEIGHT == 0) return 0; //Light weapons don't get any damage bonus from power attack
	int nPOW;
	int nMODE = GetLastAttackMode(oPC);
	if (nMODE == COMBAT_MODE_IMPROVED_POWER_ATTACK)
	{
		if (GetHasFeat(FEAT_SUPREME_POWER_ATTACK, oPC, TRUE) == TRUE) nPOW = 12;
		else if (GetHasFeat(FEAT_ENHANCED_POWER_ATTACK, oPC, TRUE) == TRUE) nPOW = 10;
		else nPOW = 6;
	}
	else if (nMODE == COMBAT_MODE_POWER_ATTACK)
	{
		if (GetHasFeat(FEAT_SUPREME_POWER_ATTACK, oPC, TRUE) == TRUE) nPOW = 6;
		else if (GetHasFeat(FEAT_ENHANCED_POWER_ATTACK, oPC, TRUE) == TRUE) nPOW = 5;
		else nPOW = 3;
	}
	else return 0;
	
	int nMULT = 1;
	if (nWEIGHT == 2) nMULT = nMULT + 1;
	if (nFAVOR >= 10) nMULT = nMULT + 1;
	
	nPOW = nPOW * nMULT;
	return nPOW;
}

int GetDamage_FavoredEnemy(object oPC, int nFAVOR)
{
	if ((nFAVOR == 0) || (nFAVOR == 10)) return 0;
	int nDMG = 1 + GetLevelByClass(CLASS_TYPE_RANGER, oPC) / 5;
	if ((nFAVOR == 2) || (nFAVOR == 12)) nDMG = nDMG + 3;
	return nDMG;
}

int GetDamage_Specialization(object oPC, int nWEAPON)
{
	int nFEAT = StringToInt(Get2DAString(s2DA, "FEATEpicWpnSpec", nWEAPON));
	if (GetHasFeat(nFEAT, oPC, TRUE) == TRUE) return 6;
	else
	{
		nFEAT = StringToInt(Get2DAString(s2DA, "FEATGrtrWpnSpec", nWEAPON));
		if (GetHasFeat(nFEAT, oPC, TRUE) == TRUE) return 4;
		else
		{
			nFEAT = StringToInt(Get2DAString(s2DA, "FEATWpnSpec", nWEAPON));
			if (GetHasFeat(nFEAT, oPC, TRUE) == TRUE) return 2;
		}
	}
	return 0;
}

int GetDamage_AbilityScores(object oPC, int nWEAPON, int nWEIGHT)
{
	int nSTR = GetAbilityModifier(ABILITY_STRENGTH, oPC);
	if (GetHasFeat(1957, oPC, TRUE) == TRUE) //Combat Insight
	{
		int nINT = GetAbilityModifier(ABILITY_INTELLIGENCE, oPC);
		if (nINT > nSTR) nSTR = nINT;
	}
	if (nWEIGHT == 2) nSTR = (nSTR * 3) / 2;
	return nSTR;
}

int GetDamage_Weapon(object oWEAPON, int nWEAPON)
{
	int nDICE_NUM = StringToInt(Get2DAString(s2DA, "NumDice", nWEAPON));
	int nDICE_SIZE = StringToInt(Get2DAString(s2DA, "DieToRoll", nWEAPON));
	int nDMG = nDICE_NUM * (1 + Random(nDICE_SIZE));
	if (nDMG < 1) nDMG = 1;
	nDMG = nDMG + IPGetWeaponEnhancementBonus(oWEAPON);
	return nDMG;
}

// Main Event

void ApplyResistedDamage(object oPC, object oTARGET, int nDEALT)
{
	object oWEAPON = GetLastWeaponUsed(oPC);
	int nFAVOR = GetFavoredEnemyFeats(oPC, oTARGET);
	int nCACHE = GetNum2DARows(s2DA);
	int nWEAPON = GetBaseItemType(oWEAPON);
	int nWEIGHT = GetWeaponWeight(oPC, nWEAPON);
	int nDMG = 	GetDamage_Weapon(oWEAPON, nWEAPON) + 
				GetDamage_AbilityScores(oPC, nWEAPON, nWEIGHT) + 
				GetDamage_Specialization(oPC, nWEAPON) +
				GetDamage_FavoredEnemy(oPC, nFAVOR) +
				GetDamage_PowerAttack(oPC, nWEAPON, nWEIGHT, nFAVOR);
					
	if (nDMG <= nDEALT) return;
	effect eFX = EffectDamage(nDMG - nDEALT, DAMAGE_TYPE_NEGATIVE, DAMAGE_POWER_NORMAL, TRUE);
	ApplyEffectToObject(DURATION_TYPE_INSTANT, eFX, oTARGET);
}

void ObtainDamageDealt(object oPC, object oTARGET, int nHP)
{
	int nDEALT = GetTotalDamageDealt();
	if (nDEALT < 0) nDEALT = 0;
	AssignCommand(oPC, ApplyResistedDamage(oPC, oTARGET, nDEALT));
}

void main()
{
	object oPC = OBJECT_SELF;
	object oTARGET = GetSpellTargetObject();
	int nHP = GetCurrentHitPoints(oTARGET);
	AssignCommand(oTARGET, ObtainDamageDealt(oPC, oTARGET, nHP));
}
1 Like
17

Thanks, all of this helps a lot, knowing how much damage you dealt adds a lot more flexibility to manipulate the calculations. I’m going to test what works better.

18

I tested it and is working fine. There is a problem, GetTotalDamage it seems to be getting the damage roll instead of the true damage that you did to the caller, i was testing it with a 15hp iron golem, the damage dealt said 10 and the chat says 7 blocked and the hp of the golem barely moved.

19

It’s not that, GetTotalDamage has this bug that it doesnt retrieve the damage that is 0… unless the object was never touched. Probably that 10 was either the missing hp and you weren’t damaging it at all or it was the last time that the golem had a damage applied to it.

Try adding a bonus 1 magical damage to the weapon and it should be fixed.
I tested this on an iron golem with 15/adamantine DR from creature properties and it was returning the correct damage

In this screenshot I disabled the shadow damage and just returned what the GetTotalDamage was getting

image
image1920×1080 748 KB

1 Like
20

I noticed that you are using divine damage on your weapon, energy attacks ignore damage reduction according to the wiki. Maybe that’s why it shows correctly for you. I made a +5 dagger, it showed the following in the chat log: “Enemy HP: 5 - Damage Dealt: 11 - nDMG: X” , this repeated with nDMG changing and saying that absorbed the damage until it was higher than Damage Dealt, triggering the damage effect.

Edit: There is something that i noticed, the weapon with the No Combat Damage does constant damage, my +5 dagger +6 strength modifier was doing 11 damage always, except when crit or doing sneak attacks, maybe the unblockable damage effect should always trigger since is the variable part of the weapon. This way, it would be like if we were converting the the physical damage to energy damage, at least the default damage without modifiers.