Fleshed out damage algorithm, should be interesting to test. Handles player and armor damage. Next up is ammo handling

ProgrammerDan · ProgrammerDan · commit 63f0c3b4e80d · 2017-08-11T00:18:29.000-04:00
diff --git a/src/main/java/com/programmerdan/minecraft/addgun/ammo/Bullet.java b/src/main/java/com/programmerdan/minecraft/addgun/ammo/Bullet.java
@@ -30,6 +30,7 @@
 import org.bukkit.util.Vector;
 
 import com.programmerdan.minecraft.addgun.AddGun;
+import com.programmerdan.minecraft.addgun.ArmorType;
 import com.programmerdan.minecraft.addgun.guns.HitPart;
 
 /**
@@ -133,18 +134,31 @@ public class Bullet implements Comparable<Bullet>, Serializable {
 	// bypass stuff is TODO
 	
 	/**
-	 * % to which this bullet bypasses armor reduction, if defense points are at or below defensePointsBypassBegins
+	 * Base armor reduction % across all types
 	 */
-	private double armorBypass = 0.1d;
+	private double baseArmorReduction = 0.0d;
+	
 	/**
-	 * % of bypass occurring, assuming defensePointsBypassBegins is satisfied.
+	 * Configure armor damage reduction % for each type.
+	 * Note this is used to compute increasing reduction via enchantments
+	 * Note also that unlike normal damage, bullet damage is against a single piece of armor.
 	 */
-	private double armorBypassChance = 0.5d;
+	private Map<ArmorType, Double> armorReduction = new ConcurrentHashMap<ArmorType, Double>();
+	
+	/**
+	 * Base armor damage % across all types
+	 */
+	private double baseArmorDamage = 0.0d;
+	
 	/**
-	 * Based on the "defense points" calculus, determines the armor point at which bypass can occur. This is _on a per piece_ basis. See also
-	 * how it's modified by the hitlocation modifiers  
+	 * Configure armor damage for each type.
+	 * Based on the type of armor, indicates what % of damage is passed on to the armor.
+	 * Some enchantments may reduce this in the final accounting.
+	 * But generally, a good metric to follow is the more damage reduction it offers, the
+	 * more damage it takes.
 	 */
-	private double defensePointsBypassBegins = 5.0; 
+	private Map<ArmorType, Double> armorDamage = new ConcurrentHashMap<ArmorType, Double>();
+
 
 	public Bullet(ConfigurationSection config) {
 		this.name = config.getName();
@@ -174,15 +188,30 @@ public Bullet(ConfigurationSection config) {
 		this.knockback = config.getInt("knockback.level", knockback);
 		
 		// TODO: damage bypass.
+		this.baseArmorReduction = config.getDouble("reduction.base", baseArmorReduction);
+		for (ArmorType armor : ArmorType.values()) {
+			if (config.contains("reduction." + armor.toString())) {
+				double armorReduce = config.getDouble("reduction." + armor.toString());
+				this.armorReduction.put(armor, armorReduce);
+			}
+		}
 		
-		this.baseAvgHitDamage = config.getDouble("basedamage.avg", baseAvgHitDamage);
-		this.baseSpreadHitDamage = config.getDouble("basedamage.spread", baseSpreadHitDamage);
+		this.baseArmorDamage = config.getDouble("durability.base", baseArmorDamage);
+		for (ArmorType armor : ArmorType.values()) {
+			if (config.contains("durability." + armor.toString())) {
+				double armorDamage = config.getDouble("durability." + armor.toString());
+				this.armorDamage.put(armor,  armorDamage);
+			}
+		}
+		
+		this.baseAvgHitDamage = config.getDouble("damage.avg", baseAvgHitDamage);
+		this.baseSpreadHitDamage = config.getDouble("damage.spread", baseSpreadHitDamage);
 		
 		for (HitPart hit : HitPart.values()) {
-			ConfigurationSection hitConfig = config.getConfigurationSection(hit.toString());
+			ConfigurationSection hitConfig = config.getConfigurationSection("damage." + hit.toString());
 			if (hitConfig == null) continue;
-			double avgHitDamage = hitConfig.getDouble("damage.avg");
-			double spreadHitDamage = hitConfig.getDouble("damage.spread");
+			double avgHitDamage = hitConfig.getDouble("avg");
+			double spreadHitDamage = hitConfig.getDouble("spread");
 			
 			this.avgHitDamage.put(hit, avgHitDamage);
 			this.spreadHitDamage.put(hit, spreadHitDamage);
@@ -207,6 +236,26 @@ public double getAvgHitDamage(HitPart hit) {
 	public double getSpreadHitDamage(HitPart hit) {
 		return this.baseSpreadHitDamage + this.spreadHitDamage.getOrDefault(hit,  0.0d);
 	}
+	
+	/**
+	 * Gets the % reduction of damage that armor confers as its base impact.
+	 * 
+	 * @param armor the armor type being tested
+	 * @return the % reduction (0 to 1)
+	 */
+	public double getArmorReduction(ArmorType armor) {
+		return this.armorReduction.getOrDefault(armor, this.baseArmorReduction);
+	}
+	
+	/**
+	 * Gets the % of damage to apply to the armor.
+	 * 
+	 * @param armor the armor type absorbing damage
+	 * @return the % damage conferred to the armor (0 to 1)
+	 */
+	public double getArmorDamage(ArmorType armor) {
+		return this.armorReduction.getOrDefault(armor, this.baseArmorDamage);
+	}
 
 	/**
 	 * Gets the configured unique name for this Bullet instance.
diff --git a/src/main/java/com/programmerdan/minecraft/addgun/guns/StandardGun.java b/src/main/java/com/programmerdan/minecraft/addgun/guns/StandardGun.java
@@ -45,8 +45,33 @@
 import com.programmerdan.minecraft.addgun.ammo.Clip;
 
 import static com.programmerdan.minecraft.addgun.guns.Utilities.getArmorType;
+import static com.programmerdan.minecraft.addgun.guns.Utilities.computeTotalXP;
 
 public class StandardGun implements BasicGun {
+
+	private static double[] protectionCurve = new double[] {
+		0.0d,
+		-0.25 * Math.log(1.0 / (1.0 + 1.0)),
+		-0.25 * Math.log(1.0 / (2.0 + 1.0)),
+		-0.25 * Math.log(1.0 / (3.0 + 1.0)),
+		-0.25 * Math.log(1.0 / (4.0 + 1.0)),
+		-0.25 * Math.log(1.0 / (5.0 + 1.0)),
+		-0.25 * Math.log(1.0 / (6.0 + 1.0)),
+		-0.25 * Math.log(1.0 / (7.0 + 1.0)),
+		-0.25 * Math.log(1.0 / (8.0 + 1.0)),
+		-0.25 * Math.log(1.0 / (9.0 + 1.0)),
+		-0.25 * Math.log(1.0 / (10.0 + 1.0)),
+		-0.25 * Math.log(1.0 / (11.0 + 1.0)),
+		-0.25 * Math.log(1.0 / (12.0 + 1.0)),
+		-0.25 * Math.log(1.0 / (13.0 + 1.0)),
+		-0.25 * Math.log(1.0 / (14.0 + 1.0)),
+		-0.25 * Math.log(1.0 / (15.0 + 1.0)),
+	};
+	
+	private static double baseProjectileProtection = 1.0d;
+	private static double baseEnvironmentProtection = 0.25d;
+	private static double baseUnbreakingProtection = 0.33d;
+	
 	/**
 	 * Is this gun enabled?
 	 */
@@ -203,7 +228,9 @@ protected StandardGun(String name) {
 				+ Integer.toHexString(this.getName().hashCode() + this.getName().length());
 	}
 	
-	public abstract ItemStack generateGun();
+	public ItemStack generateGun() {
+		return gunExample.clone();
+	}
 
 	public boolean isEnabled() {
 		return enabled;
@@ -441,7 +468,11 @@ public void manageHit(HitDigest hitData, Entity hit, Projectile bullet, Bullet b
 	}
 
 	/**
-	 * Override this class, you use it to manage what happens when something damageable is hit.
+	 * This is a complex method. It handles the various hitvectors and computations of damage both to
+	 * player/entity and armor. I'll write up a full explanation in the documentation of configuration.
+	 * 
+	 * For now it suffices that depending on _where_ the damage is done, and what is being worn there, depends
+	 * on the nature of the damage inflicted.
 	 * 
 	 * @param hitData the Data matrix showing hit information
 	 * @param hit the damageable entity that was struck
@@ -465,9 +496,14 @@ public void manageDamage(HitDigest hitData, Damageable hit, Projectile bullet, B
 		ItemStack shield = null;
 		double shieldEffectiveness = 0.0d;
 		
+		LivingEntity living = null;
+		EntityEquipment equipment = null;
+		
+		HumanEntity human = null;
+		
 		if (hit instanceof LivingEntity) {
-			LivingEntity living = (LivingEntity) hit;
-			EntityEquipment equipment = living.getEquipment();
+			living = (LivingEntity) hit;
+			equipment = living.getEquipment();
 			// now reductions?	
 			switch(hitData.nearestHitPart) {
 			case BODY:
@@ -498,14 +534,14 @@ public void manageDamage(HitDigest hitData, Damageable hit, Projectile bullet, B
 				break;
 			case MISS: // no hit?
 				nearMiss(hitData, hit, bullet, bulletType);
-				break;
+				return;
 			default:
 				break;
 			}
 			
 			if (shield != null && Material.SHIELD.equals(shield.getType())) {
 				if (hit instanceof HumanEntity) {
-					HumanEntity human = (HumanEntity) hit;
+					human = (HumanEntity) hit;
 					if (human.isBlocking()) {
 						shieldEffectiveness = 1.0d;
 					} else if (human.isHandRaised()) {
@@ -516,28 +552,134 @@ public void manageDamage(HitDigest hitData, Damageable hit, Projectile bullet, B
 				shield = null;
 			}
 		}
+
+		if (shield != null) {
+			// check bypass?
+			double angle = Math.toDegrees(hit.getLocation().getDirection().angle(speed));
+			// TODO?!?! check this
+			if (angle >= -135 && angle < 135) {
+				// no deflection!
+				shieldEffectiveness = 0.0d;
+			}
+			
+			finalDamage *= (1.0 - shieldEffectiveness);
+			
+			AddGun.getPlugin().debug(String.format("Base damage of %.2f, Has shield %s, angle of %.2f, effectiveness %.2f, final Damage %.2f",
+					baseRealDamage, shield, angle, shieldEffectiveness, finalDamage));
+
+			int unbLevel = shield.getEnchantmentLevel(Enchantment.DURABILITY);
+			
+			// Basically, unbreaking reduces the amount of durability damage that the armor will sustain 
+			double unbReduction = (1.0 + StandardGun.baseUnbreakingProtection * StandardGun.protectionCurve[unbLevel]);
+			double finalDuraDamage = baseRealDamage * (1.0 - (1.0 - bulletType.getArmorDamage(ArmorType.SHIELD)) * unbReduction);
+			if (shield.getDurability() < finalDuraDamage) {
+				// broken.
+				double directDamage = finalDuraDamage - shield.getDurability();
+				
+				finalDamage += directDamage; // this is the bit of damage the shield was meant to absorb, but didn't.
+				
+				shield = null;
+				
+				AddGun.getPlugin().debug(String.format("Shield broken by dura damage %.2f, adding the remaining %.2f to the player damage", 
+						finalDuraDamage, directDamage));
+			} else {
+				shield.setDurability((short) (shield.getDurability() - Math.round(finalDuraDamage)));
+				
+				AddGun.getPlugin().debug(String.format("Shield damaged by %.2f", finalDuraDamage));
+			}
+		}
+
+		// reset base damage
+		baseRealDamage = finalDamage;
 		
-		if (armorHit != null) {
+		if (armorHit != null && baseRealDamage > 0.0d) {
 			// check bypass?
 			
 			// check armor type
 			ArmorType grade = getArmorType(armorHit.getType()); 
 			int protLevel = armorHit.getEnchantmentLevel(Enchantment.PROTECTION_ENVIRONMENTAL);
 			int projLevel = armorHit.getEnchantmentLevel(Enchantment.PROTECTION_PROJECTILE);
+			int unbLevel = armorHit.getEnchantmentLevel(Enchantment.DURABILITY);
+			
+			if (projLevel > 15) projLevel = 15;
+			if (protLevel > 15) protLevel = 15;
+			if (unbLevel > 15) unbLevel = 15;
+		
+			// get base modifier from Bullet in terms of how much a type of armor protects you from this type of bullet
+			// then adjust based on prot and proj levels.
+			double reduction = bulletType.getArmorReduction(grade);
+			double protReduction = (1.0 + StandardGun.baseEnvironmentProtection * StandardGun.protectionCurve[protLevel]);
+			double projReduction = (1.0 + StandardGun.baseProjectileProtection * StandardGun.protectionCurve[projLevel]);
 			
-			// TODO: calculate
+			double finalReduce = reduction * protReduction * projReduction;
+			
+			if (finalReduce > 1.0) finalReduce = 1.0;
+			
+			finalDamage *= (1.0 - finalReduce);
+			
+			AddGun.getPlugin().debug(String.format("Has armor %s, baseDamage of %.2f, base reduction %.2f, prot %.2f, proj %.2f, final Damage %.2f",
+					armorHit, baseRealDamage, reduction, protReduction, projReduction, finalDamage));
+			
+			// Basically, unbreaking reduces the amount of durability damage that the armor will sustain 
+			double unbReduction = (1.0 + StandardGun.baseUnbreakingProtection * StandardGun.protectionCurve[unbLevel]);
+			double finalDuraDamage = baseRealDamage * (1.0 - (1.0 - bulletType.getArmorDamage(grade)) * unbReduction);
+			if (armorHit.getDurability() < finalDuraDamage) {
+				// broken.
+				double directDamage = finalDuraDamage - armorHit.getDurability();
+				
+				finalDamage += directDamage; // this is the bit of damage the armor was meant to absorb, but didn't.
+				
+				armorHit = null;
+				
+				AddGun.getPlugin().debug(String.format("Armor broken by dura damage %.2f, adding the remaining %.2f to the player damage", 
+						finalDuraDamage, directDamage));
+			} else {
+				armorHit.setDurability((short) (armorHit.getDurability() - Math.round(finalDuraDamage)));
+				
+				AddGun.getPlugin().debug(String.format("Armor damaged by %.2f", finalDuraDamage));
+			}
 		}
 		
-		if (shield != null) {
-			// check bypass?
-			double angle = Math.toDegrees(hit.getLocation().getDirection().angle(speed));
-			// TODO?!?! check this
-			if (angle >= -135 && angle < 135) {
-				// no deflection!
-				shieldEffectiveness = 0.0d;
+		if (equipment != null) {
+			ItemStack tShield = equipment.getItemInOffHand();
+
+			switch(hitData.nearestHitPart) {
+			case BODY:
+			case CHEST_PLATE:
+			case LEFT_ARM:
+			case LEFT_FOOT:
+			case LEFT_HAND:
+			case RIGHT_ARM:
+			case RIGHT_FOOT:
+			case RIGHT_HAND:// all variants on body atm
+				equipment.setLeggings(armorHit);
+				if (tShield != null && Material.SHIELD.equals(tShield.getType())) {
+					equipment.setItemInOffHand(shield);
+				}
+				break;
+			case BOOTS:
+			case FEET: // just feet
+				equipment.setBoots(armorHit);
+				break;
+			case HEAD:
+			case HELMET: // just head
+				equipment.setHelmet(armorHit);
+				if (tShield != null && Material.SHIELD.equals(tShield.getType())) {
+					equipment.setItemInOffHand(shield);
+				}
+				break;
+			case LEGGINGS:
+			case LEFT_LEG:
+			case RIGHT_LEG: 
+			case LEGS: // just legs
+				equipment.setLeggings(armorHit);
+				break;
+			case MISS: // no hit?
+				nearMiss(hitData, hit, bullet, bulletType);
+				break;
+			default:
+				break;
 			}
-			
-			finalDamage *= (1.0 - shieldEffectiveness);
 		}
 		
 		//TODO: player states? custom shit? event?
@@ -557,7 +699,7 @@ public void manageDamage(HitDigest hitData, Damageable hit, Projectile bullet, B
 	 * @param bullet the "Projectile" bullet doing the hitting
 	 * @param bulletType the "Bullet" type of the projectile.
 	 */
-	abstract void postHit(HitDigest hitData, Entity hit, Projectile bullet, Bullet bulletType);
+	public void postHit(HitDigest hitData, Entity hit, Projectile bullet, Bullet bulletType) {}
 
 	/**
 	 * Any post-miss cleanup can be handled here. Misses will automatically run this function, and
@@ -569,8 +711,8 @@ public void manageDamage(HitDigest hitData, Damageable hit, Projectile bullet, B
 	 * @param continueBullet Since the original projectile is removed, this is a "continue" bullet spawned _after_ the miss entity.
 	 * @param bulletType the "Bullet" type of the projectiles.
 	 */
-	abstract void postMiss(HitDigest hitData, Entity hit, Projectile bullet, Projectile continueBullet,
-			Bullet bulletType);
+	public void postMiss(HitDigest hitData, Entity hit, Projectile bullet, Projectile continueBullet,
+			Bullet bulletType) {}
 	
 	
 	/**
@@ -598,9 +740,6 @@ public Projectile shoot(Location begin, Bullet bulletType, ProjectileSource shoo
 			newBullet.setVelocity(velocity);
 		}
 
-		travelPaths.put(newBullet.getUniqueId(), begin);
-		inFlightBullets.put(newBullet.getUniqueId(), bulletType);
-		
 		return newBullet;
 	}
 
