Human Armor On-Hit Walkthrough

[SigDoesCode]

Since there have been a lot of questions about how the armor proc is handled, this is going to walk through the armor calculations for a human wearing armor being hit by a mob.

The procs that I'm using come from code/modules/mob/living/living_defense.dm.

The proc begins on line 19 with STEP ONE: TOTAL DAMAGE FROM ATTACK:

	if(damage) // If damage is defined, we add it to the list

		if(!dmg_types[damagetype])
			dmg_types += damagetype
		dmg_types[damagetype] += damage
	if(armor_divisor <= 0)
		armor_divisor = 1

		log_debug("[used_weapon] applied damage to [name] with a nonpositive armor divisor")
	var/total_dmg = 0
	var/dealt_damage = 0
	for(var/dmg_type in dmg_types)
		total_dmg += dmg_types[dmg_type]

	if(!total_dmg)
		return FALSE

This first check checks to see if the damage is defined, and is added to a list called dmg_types. It then debugs for armor_divisor, to make sure that we're not dividing by 0 later on. We then assign a pair of tracker variables, total_dmg and dealt_damage. We then run through the damage in dmg_types and add it to total_dmg, and check to see if it's empty with an early return.

This leads us to STEP TWO: THE ARMOR CHECK
The first part of Step Two involves finding the armor.

	if(!(attack_flag in list(ARMOR_MELEE, ARMOR_BULLET, ARMOR_ENERGY))) // Making sure BIO and other armor types are handled correctly
		armor /= 5
	var/ablative_armor = getarmorablative(def_zone, attack_flag) / armor_divisor
	var/remaining_armor = armor
	var/remaining_ablative = ablative_armor

We track this with two tracking variables: remaining_armor (the total amount of armor after applying the attack's armor_divisor) and the remaining_ablative (the total ablative armor after applying the attack's armor divisor.) Armor is armor, and ablative armor is armor that is removed as it absorbs damage. We track these separately so we can properly handle the ablative armor reduction later. 

Once we have our remaining_armor and remaining_ablative, we need to check the armor pen. this is STEP FOUR: ARMOR PEN.

		var/dmg = dmg_types[dmg_type]
		if(dmg)
			var/used_armor = 0 // Used for agony calculation, as well as reduction in armour before follow-up attacks
			if(dmg_type in list(BRUTE, BURN, TOX, BLAST)) // Some damage types do not help penetrate armor
				if(remaining_armor)
					var/dmg_armor_difference = dmg - remaining_armor
					var/is_difference_positive = dmg_armor_difference > 0
					used_armor += is_difference_positive ? dmg - dmg_armor_difference : dmg
					remaining_armor = is_difference_positive ? 0 : -dmg_armor_difference
					dmg = is_difference_positive ? dmg_armor_difference : 0
				if(remaining_ablative && dmg)
					var/ablative_difference
					ablative_difference = dmg - remaining_ablative
					var/is_difference_positive = ablative_difference > 0
					used_armor += is_difference_positive ? dmg - ablative_difference : dmg
					remaining_ablative = is_difference_positive ? 0 : -ablative_difference
					dmg = is_difference_positive ? ablative_difference : 0
			else
				dmg = max(dmg - remaining_armor - remaining_ablative, 0)

For each type of damage, it runs through this part. For example, if the attack did brute and burn, it would run this twice. When it runs this, it checks to see if it's a type that actually pens armor. If it is, it runs the pair of if statements. Let's assume that first hit that ends up dealing 10 brute and 10 burn. Assume that the armor has 5 armor remaining after the armor_divisor check earlier and no ablative armor. This means that we check the first damage type, brute. Remaining_armor is 5, so dmg_armor_difference is going to be 5 (10 dmg - 5 armor). The difference is going to be positive. This increases used_armor by 5, and then remaining_armor will be 0 (5 total - 5 used). Since there is no remaining armor, dmg is going to be 5. The ablative armor check is the same as the above, just using the ablative armor. If there was any armor left, it would take it off of this resulting 5 damage, but there isn't any, so we just move on.

We repeat this process for the burn damage. Again, assuming the armor has 5 BRUTE armor and 5 BURN armor, this leaves us with the following: 5 Brute damage, 5 burn damage, 5 brute armor used, 5 burn armor used. It also gives us a dmg_dealt value of 10, made from 5 BRUTE and 5 BURN. This comes in handy later.

Now we have STEP FIVE - A: MOB HALLOSS

				var/mob_agony_armor = src.getarmor(def_zone, "agony")
				var/guaranteed_damage_red = armor * 0.1 //0.1 is the former GDR value, tweak this to tweak the whole formulae
				var/effective_damage = damage - guaranteed_damage_red
				if(damagetype == HALLOSS)
					effective_damage =  max(0,round(effective_damage - mob_agony_armor))
			if(!(dmg_type == HALLOSS)) // Determine pain from impact
				adjustHalLoss(used_armor * (wounding_multiplier ? wounding_multiplier : 1) * ARMOR_HALLOS_COEFFICIENT * max(0.5, (get_specific_organ_efficiency(OP_NERVE, def_zone) / 100)))

This block, right after the previous block, checks to see if we're a simple mob. If so, we take halloss instead of a bunch of damage types. It checks the armor's agony defense, gives us a guaranteed 10% damage reduction, and then gives us our effective_damage. If the damage type is HALLOSS, it then either uses 0 or the damage - the mob's agony armor, whichever is bigger. If it's not, it adjusts it to halloss depending on the mob's armor, the projectile's wounding multiplier (or 1 if it doesn't have one) and the mob's organ efficiency where it's hit.

Taking that same 5 damage from earlier, it would see that it's BRUTE, not HALLOSS, so we need to use the last block. Then, we would call the following after substituting values : `adjustHalLoss(5 * (1) * ARMOR_HALLOSS_COEFFICIENT * (1)) (The last 1 assumes perfect 100% efficiency in the nerves in the targeted location. Deadened nerves mean less pain! It also means more pain for heightened nerve efficiency.)

We can now move on to STEP FIVE - B: HALLOSS ON HUMANS

			if(dmg)
				dealt_damage += dmg
				if(dmg_type == HALLOSS && ishuman(src)) //We already did this for mobs
					dmg = round(dmg * clamp((get_specific_organ_efficiency(OP_NERVE, def_zone) / 100), 0.5, 1.5))
					var/pain_armor = max(0, (src.getarmor(def_zone, "bullet") +  src.getarmor(def_zone, "melee") / armor_divisor))//All brute over-pen checks bullet rather then melee for simple mobs to keep melee viable
					var/pain_no_matter_what = (dmg * 0.15) //we deal 15% of are pain, this is to stop rubbers being *completely* uses with basic armor - Its not perfect in melee
					dmg = max(pain_no_matter_what, (dmg - pain_armor))
					if(ishuman(src))
						var/mob/living/carbon/human/victim = src
						if(prob(25 + (dmg * 2)))
							if(!victim.stat && !(victim.has_shield()))
								if(victim.headcheck(def_zone))
									//Harder to score a stun but if you do it lasts a bit longer
									if(prob(dmg))
										visible_message(SPAN_DANGER("[src] [victim.form.knockout_message]"))
										apply_effect(5, PARALYZE, getarmor(def_zone, ARMOR_MELEE) )
								else
									//Easier to score a stun but lasts less time
									if(prob(dmg + 10))
										visible_message(SPAN_DANGER("[src] has been knocked down!"))
										apply_effect(1, WEAKEN, getarmor(def_zone, ARMOR_MELEE) )

Now we do that same HALLOSS thing, but for humans. If there is any damage remaining (which there is, we have 5 BRUTE and 5 BURN from earlier) we add it to the dealt_dmg tracker. We then do the HALLOSS calculation from STEP FIVE - A, except we have guaranteed 15% of the attack's damage as pain if it's HALOSS, or the attack's damage - armor's pain armor, whichever is higher. Then, if the hit mob is a human, it has a 25% + (2*dmg) chance for a stun. Here, we don't reach that check because we have BRUTE and BURN damage, but if we did, it would be about a 35% chance assuming the same 5 damage but in HALLOSS form this time.

However, since we don't have HALLOSS, we're going to ignore this for the check from earlier. Just remember that this is how it works.

This brings us to STEP SIX: EMBED CHECK.

					if ( (sharp || edge) && prob ( (1 - dmg / dmg_types[dmg_type]) * 100 ) ) // If enough of the brute damage is blocked, sharpness is lost from all followup attacks, this converts damage into crushing as well
						if(wounding_multiplier)
							wounding_multiplier = step_wounding_double(wounding_multiplier) // Implied piercing damage, degrade by two steps (prevents damage duping from <1 multiplier)
						else
							wounding_multiplier = 1 // Crushing multiplier forced
						sharp = FALSE
						edge = FALSE
						armor_message(SPAN_NOTICE("[src] armor deflected the strike!"), // No cut (strike), only bash
										SPAN_NOTICE("Your armor deflects the strike!"))

If we have a brute damage attack, it might be able to embed or pen. Here's where we check that. Remember, we have a 5 BRUTE damage hit left over that still hasn't been applied. Let's assume it has both the SHARP and EDGED flags, like if it came from a knife. We check a % chance to block based on the amount of damage absorbed. The more damage absorbed, the less likely a pen or embed is. Here, remember that dmg is 5 BRUTE, flags SHARP and EDGE, with a dmg_types[dmg_type] of 10, because the initial hit was 10 damage and 5 has been eaten by armor. Therefore, this means the % check ends up as 50% ((1-(5/10)) * 100). Let's assume we win the coinflip and it doesn't get blocked. We ignore the rest of this proc and move on. However, if we lost... then, if there's a wounding multiplier, we double the wounding. If no multiplier, it's 1. Then, it removes the SHARP and EDGE flags from the attack and says "Their armor deflects the strike!" letting us know that out pen was foiled.

We now move on to STEP SEVEN: ACTUALLY APPLYING THE GODDAMN DAMANGE ALREADY HOLY SHIT-

				if(ishuman(src) && def_zone && dmg >= 20)
					var/mob/living/carbon/human/H = src
					var/obj/item/organ/external/o = H.get_organ(def_zone)
					if (o && o.status & ORGAN_SPLINTED)
						visible_message(SPAN_WARNING("The splints break off [src] after being hit!"),
								SPAN_WARNING("Your splints break off after being hit!"))
						o.status &= ~ORGAN_SPLINTED

In STEP SEVEN, we finally apply the damage of the attack. Here, we take the dmg, the dmg_type, the def_zone, the armor_divisor, the wounding multiplier, SHARP, EDGE, and used_weapon. (As a reminder, our attack would look like this if we passed the coinflip in step 6: apply_damage(5, BRUTE, ?, 2, 2, TRUE, TRUE, knife). I'm assuming a wounding multi of 2 and an armor divisor of 2 for consistency. Also, the location of the damage doesn't matter for understanding this proc, it just takes wherever the attack hit.)

This means we have to step into apply_damage, which comes from here:

	activate_ai()
	switch(damagetype)
		if(BRUTE)
			wounding_multiplier = wound_check(injury_type, wounding_multiplier, edge, sharp)
			adjustBruteLoss(damage * wounding_multiplier)
		if(BURN)
//			if(COLD_RESISTANCE in mutations)
//				damage = 0
			wounding_multiplier = wound_check(injury_type, wounding_multiplier, edge, sharp) // Why not?
			adjustFireLoss(damage * wounding_multiplier)
		if(TOX)
			adjustToxLoss(damage)
		if(OXY)
			adjustOxyLoss(damage)
		if(CLONE)
			adjustCloneLoss(damage)
		if(HALLOSS)
			adjustHalLoss(damage)
	flash_weak_pain()
	updatehealth()
	return TRUE

Here, it means we just apply the damage with the following arguments: (5, BRUTE, ?, 2, 2, TRUE, TRUE, knife). Our attack damage is BRUTE. Therefore, we'd do a wound check with the following: (?, 2, TRUE, TRUE). (The proc for wound checks is here. Regardless, we get a wounding multiplier of 1.5.) We get a Wounding Multiplier of 1.5 from the wound check, and then we call adjustBruteLoss(5*1.5), FINALLY damaging our target for a whopping 7.5 damage.

Once we apply our apply_damage proc, if there's more damage than 20 AND the target is a human AND we have a def_zone (i.e. target of the attack), we hit an external organ in the def_zone and potentially knock its splint off. Neat!

Now we're on to the BUR- NOPE. MORE NUMBERS.

On to STEP NINE: ARMOR COMMUNICATION.

	//Feedback
	//In order to show both target and everyone around that armor is actually working, we are going to send message for both of them
	//Goon/tg chat should take care of spam issue on this one
	switch(effective_armor)
		if(90 to INFINITY)
			armor_message(SPAN_NOTICE("[src] armor absorbs the blow!"),
							SPAN_NOTICE("Your armor absorbed the impact!"))
		if(74 to 90)
			armor_message(SPAN_NOTICE("[src] armor easily absorbs the blow!"),
							SPAN_NOTICE("Your armor reduced the impact greatly!"))
		if(49 to 74)
			armor_message(SPAN_NOTICE("[src] armor absorbs most of the damage!"),
							SPAN_NOTICE("Your armor protects you from the impact!"))
		if(-INFINITY to 24)
			armor_message(SPAN_NOTICE("[src] armor reduces the impact by a little."),
							SPAN_NOTICE("Your armor reduced the impact a little."))

Don't ask me why there's so many spaces there. It's just how Soj does it.
Regardless, we check to see the effectiveness of the armor. Here, we have a value for dealt_damage of 10 and a value for total_dmg of 20. therefore, effective armor is (1-(10/20)*100) or 50. We then see that it'll give us the message "Your armor protects you from the impact! Great, it did something. Can we be done now? I have things to g-

NO. ON TO STEP TEN: MISCELLANEOUS.
The last part of the proc handles subtracting damage from ablative armor, checking to see if a grab has been de-leveled on hit, and projectile penetration. The code is here, but we don't need to go over it.

		damageablative(def_zone, (ablative_armor - remaining_ablative) * armor_divisor)
	//If we have a grab in our hands and get hit with melee damage type, there is a chance we lower our grab's state
	if(attack_flag == ARMOR_MELEE && ishuman(src) && isitem(used_weapon))
		var/mob/living/carbon/human/H = src
		var/obj/item/I = used_weapon
		var/toughness_val = H.stats.getStat(STAT_TGH)
		if(dealt_damage > 10 && prob((dealt_damage - toughness_val * (sharp && edge ? 1 : 0.5) * (I.w_class < ITEM_SIZE_BULKY ? 1 : 0.5))))
			for(var/obj/item/grab/G in get_both_hands(H))
				visible_message(SPAN_NOTICE("[H]'s grab has been weakened!"), SPAN_WARNING("Your grab has been weakened!"))
				G.state--
	// Returns if a projectile should continue travelling
	if(return_continuation)
		var/obj/item/projectile/P = used_weapon
		P.damage_types = dmg_types
		if(sharp)
			var/remaining_dmg = 0
			for(var/dmg_type in dmg_types)
				remaining_dmg += dmg_types[dmg_type]
			return ((total_dmg / 2 < remaining_dmg && remaining_dmg > mob_size) ? PROJECTILE_CONTINUE : PROJECTILE_STOP)
		else return PROJECTILE_STOP
	return dealt_damage

There, a workdown of the damage_through_armor proc!