Big changes to how aiming is done, although more complex should be more intuitive, worst case gives me more knobs to tune until it is. Will add writeup to readme later.

Author: ProgrammerDan

src/main/java/com/programmerdan/minecraft/addgun/ammo/Bullet.java

@@ -163,63 +163,34 @@ public double getFireChance() {
 	/**
 	 * Knockback on hit
 	 */
-	private int knockback = 0;
+	private double knockbackAvg = 0;
 	/**
-	 * Chance of knockback.
-	 */
-	private double knockbackChance = 0.0d;
-
-	/**
-	 * The point at which, after so many seconds of "stillness" -- head motion only -- that any aim impacts are halved.
-	 * Additive to gun base. Some bullets are harder to fire.
-	 */
-	private double stillInflection = 0.0d;
-	/**
-	 * The point at which, after so many seconds of sneaking, any aim impacts are halved.
+	 * Wiggle on avg
 	 */
-	private double sneakInflection = 0.0d;
+	private double knockbackSpread = 0;
 	/**
-	 * A relative "spread" of speed of motion over inflection, values close to 0 lead to a sharp inflection, values larger make a smoother
-	 * transition. This is for stillness. Adds to gun spread, so keep this reasonable.
+	 * Chance of knockback.
 	 */
-	private double stillSpread = 0.0d;
+	private double knockbackChance = 0.0d;
 	/**
-	 * A relative "spread" of speed of motion over inflection, values close to 0 lead to a sharp inflection, values larger make a smoother
-	 * transition. This is for sneaking.
+	 * Is knockback attenuated by armor reduction?
 	 */
-	private double sneakSpread = 0.0d;
-
-	
-	public double getStillInflection() {
-		return stillInflection;
-	}
+	private boolean knockbackIgnoreReduction = false;
 
-	public void setStillInflection(double stillInflection) {
-		this.stillInflection = stillInflection;
+	public double getKnockbackChance() {
+		return knockbackChance;
 	}
-
-	public double getSneakInflection() {
-		return sneakInflection;
-	}
-
-	public void setSneakInflection(double sneakInflection) {
-		this.sneakInflection = sneakInflection;
-	}
-
-	public double getStillSpread() {
-		return stillSpread;
-	}
-
-	public void setStillSpread(double stillSpread) {
-		this.stillSpread = stillSpread;
+	
+	public double getKnockbackAvg() {
+		return knockbackAvg;
 	}
-
-	public double getSneakSpread() {
-		return sneakSpread;
+	
+	public double getKnockbackSpread() {
+		return knockbackSpread;
 	}
-
-	public void setSneakSpread(double sneakSpread) {
-		this.sneakSpread = sneakSpread;
+	
+	public boolean getKnockbackIgnoreReduction() {
+		return knockbackIgnoreReduction;
 	}
 
 	// bypass stuff is TODO
@@ -287,11 +258,11 @@ public Bullet(ConfigurationSection config) {
 		this.xpDraw = config.getInt("xpPerShot", xpDraw);
 		this.maxMissRadius = config.getDouble("missRadius.max", maxMissRadius);
 		this.minMissRadius = config.getDouble("missRadius.min", minMissRadius);
-		
-		this.sneakInflection = config.getDouble("sneak.inflection", sneakInflection);
-		this.sneakSpread = config.getDouble("sneak.spread", sneakSpread);
-		this.stillInflection = config.getDouble("still.inflection", stillInflection);
-		this.stillSpread = config.getDouble("still.spread", stillSpread);
+
+		this.knockbackChance = config.getDouble("knockback.chance", knockbackChance);
+		this.knockbackAvg = config.getDouble("knockback.avg", knockbackAvg);
+		this.knockbackSpread = config.getDouble("knockback.spread", knockbackSpread);
+		this.knockbackIgnoreReduction = config.getBoolean("knockback.ignore-reduction", knockbackIgnoreReduction);
 
 		this.avgScatter = config.getInt("scatter.avg", avgScatter);
 		this.spreadScatter = config.getInt("scatter.spread", spreadScatter);
@@ -303,9 +274,6 @@ public Bullet(ConfigurationSection config) {
 		this.fireChance = config.getDouble("incendiary.chance", fireChance);
 		this.fireTicks = config.getInt("incendiary.ticks", fireTicks);
 
-		this.knockbackChance = config.getDouble("knockback.chance", knockbackChance);
-		this.knockback = config.getInt("knockback.level", knockback);
-		
 		// TODO: damage bypass.
 		this.baseArmorReduction = config.getDouble("reduction.base", baseArmorReduction);
 		for (ArmorType armor : ArmorType.values()) {

src/main/java/com/programmerdan/minecraft/addgun/guns/Guns.java

@@ -308,6 +308,8 @@ public void gunPlayerInteractEvent(PlayerInteractEvent event) {
 					} else {
 						player.sendMessage(ChatColor.AQUA + gun.getName() + ChatColor.RED + " misfired! Try again.");
 					}
+
+					AddGun.getPlugin().getPlayerListener().recordShotImpact(player.getUniqueId(), gun.getInnateAim(), gun.getInnateAim() / ((gun.getCooldown()*2l) / 50), (int) (gun.getCooldown()*2l) / 50);
 				} else {
 					// based on their stillness and settledness.
 					double accuracy = computeAccuracyFor(gun, bulletType, player);
@@ -323,6 +325,9 @@ public void gunPlayerInteractEvent(PlayerInteractEvent event) {
 					Location origin = player.getLocation().clone().add(bbOff.getX(), offset, bbOff.getZ());
 
 					Location baseLocation = player.getEyeLocation().clone();
+					Location kick = baseLocation.clone();
+					
+					double kickback = gun.getKickback();
 
 					double minJitter = gun.getMinMissRadius() + bulletType.getMinMissRadius();
 					double maxJitter = gun.getMaxMissRadius() + bulletType.getMaxMissRadius();
@@ -344,8 +349,14 @@ public void gunPlayerInteractEvent(PlayerInteractEvent event) {
 					float pitchJitter = (float) (((rand2 * (maxJitter - minJitter)) + Math.signum(rand2) * minJitter) * accuracy);
 					baseLocation.setYaw(baseLocation.getYaw() + yawJitter);
 					baseLocation.setPitch(baseLocation.getPitch() + pitchJitter);
+
+					float kickYaw = yawJitter + (float) (Math.signum(rand1) * kickback);
+					float kickPitch = pitchJitter + (float) (Math.signum(rand2) * kickback);
+					kick.setYaw(kick.getYaw() + kickYaw);
+					kick.setPitch(kick.getPitch() + kickPitch);
+
 					if (accuracy > 0.25) {
-						player.sendMessage(ChatColor.AQUA + gun.getName() + ChatColor.RED + " isn't easy to aim. Crouch and hold still to improve accuracy.");
+						player.sendMessage(ChatColor.AQUA + gun.getName() + ChatColor.RED + " isn't always easy to aim. Try running less, or crouch and hold still to improve accuracy.");
 					} else if (accuracy < 0.01) {
 						// TODO: remove
 						player.sendMessage(ChatColor.AQUA + gun.getName() + ChatColor.GREEN + " is shooting straight, good work.");
@@ -414,9 +425,11 @@ public void run() {
 					player.setCooldown(gun.getMinimalGun().getType(), (int) (gun.getCooldown() / 50));
 
 					// jerk player's view back and reset still
-					gun.knockback(player, baseLocation.getDirection());
+					gun.knockback(player, kick.getDirection());
 
 					AddGun.getPlugin().getPlayerListener().resetStillSince(player.getUniqueId());
+					// TODO: figure this stuff out like wtf
+					AddGun.getPlugin().getPlayerListener().recordShotImpact(player.getUniqueId(), gun.getInnateAim(), gun.getInnateAim() / ((gun.getCooldown()*2l) / 50), (int) (gun.getCooldown()*2l) / 50);
 				}
 			}
 		} else {
@@ -764,42 +777,92 @@ public double computeAccuracyFor(StandardGun gun, Bullet bullet, LivingEntity en
 
 
 	/**
-	 * Internally computes jitter based only on stillness and sneakness.
+	 * Internally computes jitter based on many factors.
 	 * 
 	 * @param entity the entity's UUID to check
 	 * @return value from 0 to 1 where 1 is worse and 0 is best
 	 */
 	private double computeAccuracyFor(UUID entity, StandardGun gun, Bullet bullet) {
 		long now = System.currentTimeMillis();
 		PlayerListener listener = AddGun.getPlugin().getPlayerListener();
+		
+		double gunroot = gun.getInnateMiss();
+		double root = gun.getInnateBase();
+		
 		Long sneak = listener.getSneakingSince(entity);
 		Long still = listener.getStillSince(entity);
+		Long notsneak = listener.getSneakingEnd(entity);
+		Long notstill = listener.getStillEnd(entity);
 
+		// TODO: per-player adjustments.
 		double base = 1.0d;
-		if (sneak == null && still == null) { // not sneaking, not still.
-			return 1.0d;
+		if (sneak != null) {
+			// Sneaking reduces baseline impact
+			base -= 0.025d * (double) ((now - sneak) / 50l);
+		}
+		if (still != null) {
+			// Still reduces baseline impact
+			base -= 0.05d * (double) ((now - still) / 50l);
+		}
+		if (notsneak != null) {
+			// Not sneaking increases baseline impact
+			base += 0.025d * (double) ((now - notsneak) / 50l);
+		}
+		if (notstill != null) {
+			// Not still increases baseline impact.
+			base += 0.05d * (double) ((now - notstill) / 50l);
+		}
+		if (base < 0d) base = 0d;
+		if (base > 1d) base = 1d;
+		
+		root *= base; // so this is root.
+		
+		double pbase = 0.0d;
+		if (still != null) {
+			// If we are still, reduce "walk" impact.
+			pbase += 0.1d - 0.00005d * (double) (now - still);
+		} else if (notstill != null) {
+			// if we are moving, increase "walk" impact.
+			pbase += Math.min(0.1d, (0.0001d * (double) (now - notstill)));
+		}
+		
+		Long notrun = listener.getSprintingEnd(entity);
+		Long run = listener.getSprintingSince(entity);
+		// if we were running, but stopped, linearly impact aim
+		if (notrun != null) {
+			pbase += 0.4d - (0.0001d * (double) (now - notrun));
+		} else if (run != null) {
+			// if we are running, aim is worsened, up to a max.
+			pbase += Math.min(0.4d, (0.001d * (double) (now - run)));
+		}
+		Long notglide = listener.getGlidingEnd(entity);
+		Long glide = listener.getGlidingSince(entity);
+		// Do the same for gliding
+		if (notglide != null) {
+			pbase += 0.7d - (0.0001d * (double) (now - notglide));
+		} else if (glide != null) {
+			pbase += Math.min(0.7d, (0.001d * (double) (now - glide)));
 		}
 
-		double combineSneakInflection = gun.getSneakInflection() + bullet.getSneakInflection();
-		if (combineSneakInflection < 0.0d) combineSneakInflection = 0.0d;
+		// now pull in any impact of prior shots.
+		pbase += listener.getShotImpact(entity);
 
-		double combineStillInflection = gun.getStillInflection() + bullet.getStillInflection();
-		if (combineStillInflection < 0.0d) combineStillInflection = 0.0d;
+		if (sneak != null) { // we are sneaking!
+			// so cut the impacts in half.
+			pbase /= 2d;
+		}
 
-		double combineSneakSpread = gun.getSneakSpread() + bullet.getSneakSpread();
-		if (combineSneakSpread < 0.00001d) combineSneakSpread = 0.00001d;
+		// now add in base.
+		pbase += root;
+		// add in root.
+		pbase += gunroot;
 
-		double combineStillSpread = gun.getStillSpread() + bullet.getStillSpread();
-		if (combineStillSpread < 0.00001d) combineStillSpread = 0.00001d;
+		if (pbase > 1.0d) pbase = 1.0d;
+		if (pbase < 0.0d) pbase = 0.0d;
 
-		if (sneak != null) { // sneaking
-			base -= sigmoid((now - sneak) / 1000.0d, combineSneakInflection, 0.25d, combineSneakSpread);
-		}
-		if (still != null) { // still
-			base -= sigmoid((now - still) / 1000.0d, combineStillInflection, 0.25d, combineStillSpread);
-		}
+		return pbase; // accuracy is then computed.
 
-		return base > 0.0d ? base : 0.0d;
+		// TODO: These factors should be global...
 	}
 
 	/**

src/main/java/com/programmerdan/minecraft/addgun/guns/ShotTracker.java

@@ -0,0 +1,60 @@
+package com.programmerdan.minecraft.addgun.guns;
+
+import java.util.Queue;
+import java.util.concurrent.atomic.DoubleAccumulator;
+
+/**
+ * Tracks the shots that have been fired and accumulates their aim disturbing impact.
+ * 
+ * @author ProgrammerDan
+ */
+public class ShotTracker implements Runnable {
+	private Queue<Shot> shotQueue = new java.util.concurrent.ConcurrentLinkedQueue<>();
+	
+	private DoubleAccumulator offset = new DoubleAccumulator((a,b) -> {return a + b;}, 0.0);
+	
+	public void addShot(double aimOffset, double decay, int lifetime) {
+		shotQueue.offer(new Shot(aimOffset, decay, lifetime));
+	}
+	
+	public void run() {
+		DoubleAccumulator offset = new DoubleAccumulator((a,b) -> {return a + b;}, 0.0);
+
+		shotQueue.removeIf(s -> {
+			offset.accumulate(s.decay());
+			return s.ticksLeft == 0;
+		});
+		
+		this.offset = offset;
+		
+		if (shotQueue.isEmpty()) {
+			throw new RuntimeException("All done for now for this player");
+		}
+	}
+	
+	public double getAimOffset() {
+		return offset.get();
+	}
+	
+	private class Shot {
+		public double aimOffset;
+		public double decay;
+		public int ticksLeft;
+		
+		public Shot(double aimOffset, double decay, int ticksLeft) {
+			this.aimOffset = aimOffset;
+			this.decay = decay;
+			this.ticksLeft = ticksLeft;
+		}
+		
+		public double decay() {
+			if (ticksLeft > 0) {
+				this.aimOffset -= this.decay;
+				this.ticksLeft --;
+			} else {
+				this.aimOffset = 0.0d;
+			}
+			return this.aimOffset;
+		}
+	}
+}