diff --git a/src/main/java/kamkeel/npcs/controllers/data/ability/Ability.java b/src/main/java/kamkeel/npcs/controllers/data/ability/Ability.java
index 49ffbf587..b95879c3b 100644
--- a/src/main/java/kamkeel/npcs/controllers/data/ability/Ability.java
+++ b/src/main/java/kamkeel/npcs/controllers/data/ability/Ability.java
@@ -392,6 +392,18 @@ public abstract class Ability implements IAbility {
return 45.0f;
}
+ /**
+ * Returns true if the caster is a player (not an NPC).
+ * Use this instead of checking {@code target != null} to make NPC/Player
+ * code paths explicit and readable.
+ *
+ * NPCs always have an aggro target passed to ability methods.
+ * Players never do — they use look direction for aiming instead.
+ */
+ protected final boolean isPlayerCaster(EntityLivingBase caster) {
+ return caster instanceof EntityPlayer;
+ }
+
/**
* Returns true if this ability controls NPC movement during ACTIVE phase.
* When true, AI pathfinding will be blocked during ability execution.
diff --git a/src/main/java/kamkeel/npcs/controllers/data/ability/type/AbilityBeam.java b/src/main/java/kamkeel/npcs/controllers/data/ability/type/AbilityBeam.java
index 91b0287eb..f99a03528 100644
--- a/src/main/java/kamkeel/npcs/controllers/data/ability/type/AbilityBeam.java
+++ b/src/main/java/kamkeel/npcs/controllers/data/ability/type/AbilityBeam.java
@@ -164,6 +164,11 @@ public class AbilityBeam extends Ability implements IAbilityEnergyBeam {
return new TargetingMode[]{TargetingMode.AGGRO_TARGET};
}
+ /**
+ * Create beam entities.
+ * NPC: target is the aggro target — beams will home toward it.
+ * Player: target is null — beams fire in caster's look direction.
+ */
private EntityAbilityBeam[] createBeamEntities(EntityLivingBase caster, EntityLivingBase target, World world) {
EntityAbilityBeam[] entities = new EntityAbilityBeam[projectileCount];
float offsetDist = 1.0f;
@@ -294,7 +299,9 @@ public class AbilityBeam extends Ability implements IAbilityEnergyBeam {
@Override
public TelegraphInstance createTelegraph(EntityLivingBase caster, EntityLivingBase target) {
- if (!showTelegraph || telegraphType == TelegraphType.NONE || target == null) {
+ // NPC: telegraph on aggro target position
+ // Player: no telegraph (beam fires in look direction, no fixed position to mark)
+ if (!showTelegraph || telegraphType == TelegraphType.NONE || isPlayerCaster(caster) || target == null) {
return null;
}
diff --git a/src/main/java/kamkeel/npcs/controllers/data/ability/type/AbilityCharge.java b/src/main/java/kamkeel/npcs/controllers/data/ability/type/AbilityCharge.java
index 8e179dc73..4ae81bfcb 100644
--- a/src/main/java/kamkeel/npcs/controllers/data/ability/type/AbilityCharge.java
+++ b/src/main/java/kamkeel/npcs/controllers/data/ability/type/AbilityCharge.java
@@ -87,11 +87,13 @@ public class AbilityCharge extends Ability implements IAbilityCharge {
}
/**
- * Locks the charge direction based on current target position.
- * Called once at windup start - direction won't change even if target moves.
+ * Locks the charge direction. Called once at windup start — direction won't change even if target moves.
+ * NPC: charges toward aggro target.
+ * Player: charges in look direction.
*/
private void lockChargeDirection(EntityLivingBase caster, EntityLivingBase target) {
- if (target != null) {
+ if (!isPlayerCaster(caster) && target != null) {
+ // NPC: charge toward aggro target
double dx = target.posX - caster.posX;
double dz = target.posZ - caster.posZ;
double len = Math.sqrt(dx * dx + dz * dz);
@@ -102,6 +104,7 @@ public class AbilityCharge extends Ability implements IAbilityCharge {
chargeDirection = Vec3.createVectorHelper(-Math.sin(yaw), 0, Math.cos(yaw));
}
} else {
+ // Player: charge in look direction
float yaw = (float) Math.toRadians(caster.rotationYaw);
chargeDirection = Vec3.createVectorHelper(-Math.sin(yaw), 0, Math.cos(yaw));
}
@@ -258,9 +261,10 @@ public class AbilityCharge extends Ability implements IAbilityCharge {
return null;
}
- // Calculate direction to target at this moment (locked)
+ // NPC: telegraph points toward aggro target
+ // Player: telegraph points in look direction
float yaw;
- if (target != null) {
+ if (!isPlayerCaster(caster) && target != null) {
double dx = target.posX - caster.posX;
double dz = target.posZ - caster.posZ;
yaw = (float) Math.toDegrees(Math.atan2(-dx, dz));
diff --git a/src/main/java/kamkeel/npcs/controllers/data/ability/type/AbilityDash.java b/src/main/java/kamkeel/npcs/controllers/data/ability/type/AbilityDash.java
index 2ea0095eb..0f8cbe374 100644
--- a/src/main/java/kamkeel/npcs/controllers/data/ability/type/AbilityDash.java
+++ b/src/main/java/kamkeel/npcs/controllers/data/ability/type/AbilityDash.java
@@ -149,9 +149,10 @@ public class AbilityDash extends Ability implements IAbilityDash {
: DEFENSIVE_DIRECTIONS;
chosenDirection = directions[RANDOM.nextInt(directions.length)];
- // Calculate dash direction relative to target
+ // NPC: dash direction is relative to aggro target facing
+ // Player: dash direction is relative to look direction
float baseYaw;
- if (target != null) {
+ if (!isPlayerCaster(caster) && target != null) {
double dx = target.posX - caster.posX;
double dz = target.posZ - caster.posZ;
baseYaw = (float) Math.toDegrees(Math.atan2(-dx, dz));
diff --git a/src/main/java/kamkeel/npcs/controllers/data/ability/type/AbilityDisc.java b/src/main/java/kamkeel/npcs/controllers/data/ability/type/AbilityDisc.java
index 22832a104..21d4073ed 100644
--- a/src/main/java/kamkeel/npcs/controllers/data/ability/type/AbilityDisc.java
+++ b/src/main/java/kamkeel/npcs/controllers/data/ability/type/AbilityDisc.java
@@ -169,6 +169,11 @@ public class AbilityDisc extends Ability implements IAbilityDisc {
return new TargetingMode[]{TargetingMode.AGGRO_TARGET};
}
+ /**
+ * Create disc entities.
+ * NPC: target is the aggro target — discs will home toward it.
+ * Player: target is null — discs fire in caster's look direction.
+ */
private EntityAbilityDisc[] createDiscEntities(EntityLivingBase caster, EntityLivingBase target, World world) {
EntityAbilityDisc[] entities = new EntityAbilityDisc[projectileCount];
for (int i = 0; i < projectileCount; i++) {
@@ -301,7 +306,9 @@ public class AbilityDisc extends Ability implements IAbilityDisc {
@Override
public TelegraphInstance createTelegraph(EntityLivingBase caster, EntityLivingBase target) {
- if (!showTelegraph || telegraphType == TelegraphType.NONE || target == null) {
+ // NPC: telegraph on aggro target position
+ // Player: no telegraph (discs fire in look direction, no fixed position to mark)
+ if (!showTelegraph || telegraphType == TelegraphType.NONE || isPlayerCaster(caster) || target == null) {
return null;
}
diff --git a/src/main/java/kamkeel/npcs/controllers/data/ability/type/AbilityHazard.java b/src/main/java/kamkeel/npcs/controllers/data/ability/type/AbilityHazard.java
index 70696eb8f..58c2560a4 100644
--- a/src/main/java/kamkeel/npcs/controllers/data/ability/type/AbilityHazard.java
+++ b/src/main/java/kamkeel/npcs/controllers/data/ability/type/AbilityHazard.java
@@ -3,6 +3,7 @@ package kamkeel.npcs.controllers.data.ability.type;
import kamkeel.npcs.controllers.data.ability.Ability;
import kamkeel.npcs.controllers.data.ability.LockMovementType;
import kamkeel.npcs.controllers.data.ability.TargetingMode;
+import kamkeel.npcs.controllers.data.ability.UserType;
import kamkeel.npcs.controllers.data.telegraph.TelegraphInstance;
import kamkeel.npcs.controllers.data.telegraph.TelegraphType;
import net.minecraft.entity.EntityLivingBase;
@@ -111,6 +112,7 @@ public class AbilityHazard extends Ability implements IAbilityHazard {
this.cooldownTicks = 0;
this.windUpTicks = 30;
this.telegraphType = TelegraphType.CIRCLE;
+ this.allowedBy = UserType.NPC_ONLY;
}
@Override
@@ -202,14 +204,12 @@ public class AbilityHazard extends Ability implements IAbilityHazard {
}
break;
case AT_TARGET:
- // Use telegraph position if available, apply offset
if (telegraph != null) {
double[] pos = Ability.calculateOffsetPosition(telegraph.getX(), telegraph.getY(), telegraph.getZ(),
minOffset, maxOffset, randomOffset, RANDOM);
zoneX = pos[0];
zoneY = pos[1];
zoneZ = pos[2];
- // Update telegraph to show actual hazard position
telegraph.setX(zoneX);
telegraph.setY(zoneY);
telegraph.setZ(zoneZ);
diff --git a/src/main/java/kamkeel/npcs/controllers/data/ability/type/AbilityLaserShot.java b/src/main/java/kamkeel/npcs/controllers/data/ability/type/AbilityLaserShot.java
index 7ddfcc0e7..afffa9c13 100644
--- a/src/main/java/kamkeel/npcs/controllers/data/ability/type/AbilityLaserShot.java
+++ b/src/main/java/kamkeel/npcs/controllers/data/ability/type/AbilityLaserShot.java
@@ -88,6 +88,11 @@ public class AbilityLaserShot extends Ability implements IAbilityLaserShot {
return laserWidth * 2.0f; // Make telegraph slightly wider for visibility
}
+ /**
+ * Spawn laser entity.
+ * NPC: target is the aggro target — laser expands toward it.
+ * Player: target is null — laser expands in caster's look direction.
+ */
private EntityAbilityLaser spawnLaserEntity(EntityLivingBase caster, EntityLivingBase target, World world) {
Vec3 spawnPos = AnchorPointHelper.calculateAnchorPosition(caster, anchorData);
EntityAbilityLaser entity = new EntityAbilityLaser(
diff --git a/src/main/java/kamkeel/npcs/controllers/data/ability/type/AbilityOrb.java b/src/main/java/kamkeel/npcs/controllers/data/ability/type/AbilityOrb.java
index e0f6bc19f..17b878305 100644
--- a/src/main/java/kamkeel/npcs/controllers/data/ability/type/AbilityOrb.java
+++ b/src/main/java/kamkeel/npcs/controllers/data/ability/type/AbilityOrb.java
@@ -172,6 +172,11 @@ public class AbilityOrb extends Ability implements IAbilityOrb {
return new TargetingMode[]{TargetingMode.AGGRO_TARGET};
}
+ /**
+ * Create orb entities.
+ * NPC: target is the aggro target — orbs will home toward it.
+ * Player: target is null — orbs fire in caster's look direction.
+ */
private EntityAbilityOrb[] createOrbEntities(EntityLivingBase caster, EntityLivingBase target, World world) {
EntityAbilityOrb[] entities = new EntityAbilityOrb[projectileCount];
for (int i = 0; i < projectileCount; i++) {
@@ -302,7 +307,9 @@ public class AbilityOrb extends Ability implements IAbilityOrb {
@Override
public TelegraphInstance createTelegraph(EntityLivingBase caster, EntityLivingBase target) {
- if (!showTelegraph || telegraphType == TelegraphType.NONE || target == null) {
+ // NPC: telegraph on aggro target position
+ // Player: no telegraph (orbs fire in look direction, no fixed position to mark)
+ if (!showTelegraph || telegraphType == TelegraphType.NONE || isPlayerCaster(caster) || target == null) {
return null;
}
diff --git a/src/main/java/kamkeel/npcs/controllers/data/ability/type/AbilityProjectile.java b/src/main/java/kamkeel/npcs/controllers/data/ability/type/AbilityProjectile.java
index b6657ac60..8abd5d01e 100644
--- a/src/main/java/kamkeel/npcs/controllers/data/ability/type/AbilityProjectile.java
+++ b/src/main/java/kamkeel/npcs/controllers/data/ability/type/AbilityProjectile.java
@@ -9,6 +9,7 @@ import kamkeel.npcs.controllers.data.telegraph.TelegraphType;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.Vec3;
import net.minecraft.world.World;
import noppes.npcs.entity.EntityNPCInterface;
@@ -67,68 +68,131 @@ public class AbilityProjectile extends Ability implements IAbilityProjectile {
@Override
public void onExecute(EntityLivingBase caster, EntityLivingBase target, World world) {
- if ((world.isRemote && !isPreview()) || target == null) {
+ if (world.isRemote && !isPreview()) {
signalCompletion();
return;
}
- if (!isPreview()) {
- // Calculate direction to target
- double dx = target.posX - caster.posX;
- double dy = (target.posY + target.height / 2) - (caster.posY + caster.getEyeHeight());
- double dz = target.posZ - caster.posZ;
- double len = Math.sqrt(dx * dx + dy * dy + dz * dz);
-
- if (len > 0) {
- dx /= len;
- dy /= len;
- dz /= len;
- }
-
- // Deal instant damage with scripted event support
- // TODO: Use custom EntityAbilityProjectile for actual tracking
- applyAbilityDamageWithDirection(caster, target, damage, knockback, dx, dz);
-
- // Play sound
- world.playSoundAtEntity(caster, "random.bow", 1.0f, 0.8f);
-
- // Handle splash damage for explosive projectiles
- if (explosive && explosionRadius > 0) {
- @SuppressWarnings("unchecked")
- List entities = world.getEntitiesWithinAABBExcludingEntity(target,
- target.boundingBox.expand(explosionRadius, explosionRadius, explosionRadius));
-
- for (Entity entity : entities) {
- if (entity instanceof EntityLivingBase && entity != caster) {
- EntityLivingBase living = (EntityLivingBase) entity;
- float dist = target.getDistanceToEntity(living);
- if (dist < explosionRadius) {
- float falloff = 1.0f - (dist / explosionRadius);
- // Apply splash damage with scripted event support (no knockback)
- applyAbilityDamage(caster, living, damage * falloff * 0.5f, 0);
- }
- }
- }
-
- // Explosion particles
- world.playSoundAtEntity(target, "random.explode", 0.5f, 1.0f);
- for (int i = 0; i < 10; i++) {
- world.spawnParticle("explode",
- target.posX + (world.rand.nextDouble() - 0.5) * explosionRadius,
- target.posY + world.rand.nextDouble() * target.height,
- target.posZ + (world.rand.nextDouble() - 0.5) * explosionRadius,
- 0, 0.1, 0);
- }
- }
-
- // Spawn projectile particles (visual trail)
- spawnProjectileParticles(world, caster, target);
+ if (isPlayerCaster(caster)) {
+ // Player: instant hit-scan in look direction
+ executePlayerProjectile(caster, world);
+ } else if (target != null) {
+ // NPC: instant hit-scan on aggro target
+ executeNpcProjectile(caster, target, world);
}
- // Projectile is instant
signalCompletion();
}
+ /**
+ * NPC projectile: instant hit-scan damage on the aggro target.
+ */
+ private void executeNpcProjectile(EntityLivingBase caster, EntityLivingBase target, World world) {
+ if (isPreview()) return;
+
+ double dx = target.posX - caster.posX;
+ double dy = (target.posY + target.height / 2) - (caster.posY + caster.getEyeHeight());
+ double dz = target.posZ - caster.posZ;
+ double len = Math.sqrt(dx * dx + dy * dy + dz * dz);
+ if (len > 0) { dx /= len; dy /= len; dz /= len; }
+
+ applyAbilityDamageWithDirection(caster, target, damage, knockback, dx, dz);
+ world.playSoundAtEntity(caster, "random.bow", 1.0f, 0.8f);
+
+ if (explosive && explosionRadius > 0) {
+ applyExplosionDamage(caster, target, world, target.posX, target.posY, target.posZ);
+ }
+
+ spawnProjectileParticles(world, caster, target);
+ }
+
+ /**
+ * Player projectile: fires instant hit-scan in look direction.
+ * Raycasts for the first entity in range and applies damage.
+ */
+ private void executePlayerProjectile(EntityLivingBase caster, World world) {
+ if (isPreview()) return;
+
+ Vec3 look = caster.getLookVec();
+ double eyeX = caster.posX;
+ double eyeY = caster.posY + caster.getEyeHeight();
+ double eyeZ = caster.posZ;
+
+ // Raycast: find the closest entity along look direction
+ EntityLivingBase hitTarget = null;
+ double closestDist = maxRange;
+
+ @SuppressWarnings("unchecked")
+ List candidates = world.getEntitiesWithinAABBExcludingEntity(caster,
+ caster.boundingBox.expand(maxRange, maxRange, maxRange));
+
+ for (Entity entity : candidates) {
+ if (!(entity instanceof EntityLivingBase)) continue;
+ if (entity.isDead) continue;
+
+ // Check if entity is roughly along look direction
+ double dx = entity.posX - eyeX;
+ double dy = (entity.posY + entity.height / 2) - eyeY;
+ double dz = entity.posZ - eyeZ;
+ double dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
+ if (dist > maxRange || dist < 0.5) continue;
+
+ // Dot product to check alignment with look vector
+ double dot = (dx * look.xCoord + dy * look.yCoord + dz * look.zCoord) / dist;
+ if (dot < 0.95) continue; // Must be within ~18 degree cone
+
+ if (dist < closestDist) {
+ closestDist = dist;
+ hitTarget = (EntityLivingBase) entity;
+ }
+ }
+
+ world.playSoundAtEntity(caster, "random.bow", 1.0f, 0.8f);
+
+ if (hitTarget != null) {
+ applyAbilityDamageWithDirection(caster, hitTarget, damage, knockback, look.xCoord, look.zCoord);
+
+ if (explosive && explosionRadius > 0) {
+ applyExplosionDamage(caster, hitTarget, world, hitTarget.posX, hitTarget.posY, hitTarget.posZ);
+ }
+
+ spawnProjectileParticles(world, caster, hitTarget);
+ } else {
+ // No hit — spawn particles along look direction anyway
+ spawnProjectileParticlesInDirection(world, caster, look);
+ }
+ }
+
+ /**
+ * Apply explosion splash damage around a point.
+ */
+ private void applyExplosionDamage(EntityLivingBase caster, EntityLivingBase primaryTarget, World world,
+ double x, double y, double z) {
+ @SuppressWarnings("unchecked")
+ List entities = world.getEntitiesWithinAABBExcludingEntity(primaryTarget,
+ primaryTarget.boundingBox.expand(explosionRadius, explosionRadius, explosionRadius));
+
+ for (Entity entity : entities) {
+ if (entity instanceof EntityLivingBase && entity != caster) {
+ EntityLivingBase living = (EntityLivingBase) entity;
+ float dist = primaryTarget.getDistanceToEntity(living);
+ if (dist < explosionRadius) {
+ float falloff = 1.0f - (dist / explosionRadius);
+ applyAbilityDamage(caster, living, damage * falloff * 0.5f, 0);
+ }
+ }
+ }
+
+ world.playSoundAtEntity(primaryTarget, "random.explode", 0.5f, 1.0f);
+ for (int i = 0; i < 10; i++) {
+ world.spawnParticle("explode",
+ x + (world.rand.nextDouble() - 0.5) * explosionRadius,
+ y + world.rand.nextDouble() * 2,
+ z + (world.rand.nextDouble() - 0.5) * explosionRadius,
+ 0, 0.1, 0);
+ }
+ }
+
private void spawnProjectileParticles(World world, EntityLivingBase caster, EntityLivingBase target) {
double startX = caster.posX;
double startY = caster.posY + caster.getEyeHeight();
@@ -160,6 +224,31 @@ public class AbilityProjectile extends Ability implements IAbilityProjectile {
}
}
+ /**
+ * Spawn projectile particles along a direction (player miss — no entity hit).
+ */
+ private void spawnProjectileParticlesInDirection(World world, EntityLivingBase caster, Vec3 look) {
+ double startX = caster.posX;
+ double startY = caster.posY + caster.getEyeHeight();
+ double startZ = caster.posZ;
+
+ String particle = "flame";
+ if (projectileType.equals("arrow")) {
+ particle = "crit";
+ } else if (projectileType.equals("magic")) {
+ particle = "witchMagic";
+ }
+
+ int steps = (int) Math.max(5, maxRange * 2);
+ for (int i = 0; i < steps; i++) {
+ double progress = (double) i / steps * maxRange;
+ double px = startX + look.xCoord * progress;
+ double py = startY + look.yCoord * progress;
+ double pz = startZ + look.zCoord * progress;
+ world.spawnParticle(particle, px, py, pz, 0, 0, 0);
+ }
+ }
+
@Override
public void onActiveTick(EntityLivingBase caster, EntityLivingBase target, World world, int tick) {
// Projectile is instant, nothing to do per-tick
diff --git a/src/main/java/kamkeel/npcs/controllers/data/ability/type/AbilitySlam.java b/src/main/java/kamkeel/npcs/controllers/data/ability/type/AbilitySlam.java
index 15b4060b8..a03ecdf6a 100644
--- a/src/main/java/kamkeel/npcs/controllers/data/ability/type/AbilitySlam.java
+++ b/src/main/java/kamkeel/npcs/controllers/data/ability/type/AbilitySlam.java
@@ -85,51 +85,74 @@ public class AbilitySlam extends Ability implements IAbilitySlam {
@Override
public void onWindUpTick(EntityLivingBase caster, EntityLivingBase target, World world, int tick) {
- // Update target position during windup
- if (targetingMode == TargetingMode.AOE_SELF) {
- // AOE_SELF: slam at caster's current position
+ if (isPlayerCaster(caster)) {
+ // Player: slam will launch from current position, no target tracking needed
targetX = caster.posX;
targetY = caster.posY;
targetZ = caster.posZ;
- } else if (targetingMode == TargetingMode.AOE_TARGET && target != null && !target.isDead) {
- // AOE_TARGET: telegraph follows target via setEntityIdToFollow
- targetX = target.posX;
- targetY = target.posY;
- targetZ = target.posZ;
+ } else {
+ // NPC: update target position during windup for telegraph tracking
+ if (targetingMode == TargetingMode.AOE_SELF) {
+ targetX = caster.posX;
+ targetY = caster.posY;
+ targetZ = caster.posZ;
+ } else if (targetingMode == TargetingMode.AOE_TARGET && target != null && !target.isDead) {
+ targetX = target.posX;
+ targetY = target.posY;
+ targetZ = target.posZ;
+ }
}
}
@Override
public void onExecute(EntityLivingBase caster, EntityLivingBase target, World world) {
- // Lock in the destination at moment of launch
+ hasLaunched = false;
+ hasLanded = false;
+ airTicks = 0;
+ caster.fallDistance = 0;
+
+ if (isPlayerCaster(caster)) {
+ executePlayerSlam(caster);
+ } else {
+ executeNpcSlam(caster, target);
+ }
+ }
+
+ /**
+ * NPC slam: Lock destination based on targeting mode, then launch in a ballistic arc toward it.
+ */
+ private void executeNpcSlam(EntityLivingBase caster, EntityLivingBase target) {
if (targetingMode == TargetingMode.AOE_SELF) {
- // AOE_SELF: slam in place (just jump up)
targetX = caster.posX;
targetY = caster.posY;
targetZ = caster.posZ;
} else if (targetingMode == TargetingMode.AOE_TARGET && target != null && !target.isDead) {
- // AOE_TARGET: leap to target's current position
targetX = target.posX;
targetY = target.posY;
targetZ = target.posZ;
} else {
- // Fallback: slam in place
targetX = caster.posX;
targetY = caster.posY;
targetZ = caster.posZ;
}
-
- hasLaunched = false;
- hasLanded = false;
- airTicks = 0;
-
- // Reset fall distance to prevent fall damage during slam
- caster.fallDistance = 0;
-
- // Calculate and apply leap velocity
launchTowardTarget(caster);
}
+ /**
+ * Player slam: Launch straight up. Player controls horizontal movement via WASD.
+ * AOE damage triggers wherever the player lands.
+ */
+ private void executePlayerSlam(EntityLivingBase caster) {
+ targetX = caster.posX;
+ targetY = caster.posY;
+ targetZ = caster.posZ;
+
+ double vy = calculateLaunchVelocity(Math.max(1.0, leapHeight));
+ caster.motionY = vy;
+ hasLaunched = true;
+ caster.velocityChanged = true;
+ }
+
/**
* Calculate the initial vertical velocity needed to reach a target height
* in Minecraft's physics (gravity=0.08, vertical drag=0.98).
@@ -273,8 +296,9 @@ public class AbilitySlam extends Ability implements IAbilitySlam {
return;
}
- // While in air, face toward target
- if (!isPreview()) {
+ // NPC: face toward target destination while in air
+ // Player: free look — player controls their own camera
+ if (!isPreview() && !isPlayerCaster(caster)) {
double dx = targetX - caster.posX;
double dz = targetZ - caster.posZ;
float targetYaw = (float) (Math.atan2(-dx, dz) * 180.0D / Math.PI);
@@ -441,11 +465,11 @@ public class AbilitySlam extends Ability implements IAbilitySlam {
TelegraphInstance instance = new TelegraphInstance(telegraph, targetX, groundY, targetZ, caster.rotationYaw);
instance.setCasterEntityId(caster.getEntityId());
- // AOE_TARGET: telegraph follows target during windup
- if (targetingMode == TargetingMode.AOE_TARGET && target != null) {
+ // NPC AOE_TARGET: telegraph follows target during windup
+ // Player: telegraph stays at caster position (no target to follow)
+ if (!isPlayerCaster(caster) && targetingMode == TargetingMode.AOE_TARGET && target != null) {
instance.setEntityIdToFollow(target.getEntityId());
}
- // AOE_SELF: telegraph stays at caster position, no follow
return instance;
}
diff --git a/src/main/java/kamkeel/npcs/controllers/data/ability/type/AbilitySweeper.java b/src/main/java/kamkeel/npcs/controllers/data/ability/type/AbilitySweeper.java
index 9be02101f..8638dd2a4 100644
--- a/src/main/java/kamkeel/npcs/controllers/data/ability/type/AbilitySweeper.java
+++ b/src/main/java/kamkeel/npcs/controllers/data/ability/type/AbilitySweeper.java
@@ -83,7 +83,9 @@ public class AbilitySweeper extends Ability implements IAbilitySweeper {
return;
}
- // Spawn the entity that handles BOTH visuals AND damage
+ // Spawn the sweeper entity that handles BOTH visuals AND damage.
+ // NPC: target is the aggro target — lockOnTarget tracks it during sweep.
+ // Player: target is null — sweep rotates around caster's facing direction, lockOnTarget has no effect.
activeEntity = new EntityAbilitySweeper(world, caster, target,
beamLength, beamWidth, beamHeight,
colorData,
diff --git a/src/main/java/kamkeel/npcs/controllers/data/ability/type/AbilityTeleport.java b/src/main/java/kamkeel/npcs/controllers/data/ability/type/AbilityTeleport.java
index fe847bf3a..8e09c43e7 100644
--- a/src/main/java/kamkeel/npcs/controllers/data/ability/type/AbilityTeleport.java
+++ b/src/main/java/kamkeel/npcs/controllers/data/ability/type/AbilityTeleport.java
@@ -3,6 +3,7 @@ package kamkeel.npcs.controllers.data.ability.type;
import kamkeel.npcs.controllers.data.ability.Ability;
import kamkeel.npcs.controllers.data.ability.LockMovementType;
import kamkeel.npcs.controllers.data.ability.TargetingMode;
+import kamkeel.npcs.controllers.data.ability.UserType;
import kamkeel.npcs.controllers.data.telegraph.TelegraphType;
import net.minecraft.block.Block;
import net.minecraft.entity.Entity;
@@ -72,6 +73,7 @@ public class AbilityTeleport extends Ability implements IAbilityTeleport {
this.typeId = "ability.cnpc.teleport";
this.name = "Teleport";
this.targetingMode = TargetingMode.AGGRO_TARGET;
+ this.allowedBy = UserType.NPC_ONLY;
this.maxRange = 30.0f;
this.minRange = 5.0f;
this.cooldownTicks = 0;
@@ -228,26 +230,8 @@ public class AbilityTeleport extends Ability implements IAbilityTeleport {
}
}
- // No target (player use) - teleport in caster's look direction
- Vec3 look = caster.getLookVec();
- switch (mode) {
- case BEHIND:
- // Teleport forward in look direction by behindDistance
- newX = caster.posX + look.xCoord * behindDistance;
- newZ = caster.posZ + look.zCoord * behindDistance;
- newY = caster.posY;
- return Vec3.createVectorHelper(newX, newY, newZ);
- case SINGLE:
- case BLINK:
- default:
- // Teleport forward in look direction within blinkRadius
- double dist = Math.min(blinkRadius, maxRange);
- double offset = (RANDOM.nextDouble() * 0.5 + 0.5) * dist; // 50-100% of max distance
- newX = caster.posX + look.xCoord * offset;
- newZ = caster.posZ + look.zCoord * offset;
- newY = caster.posY;
- return Vec3.createVectorHelper(newX, newY, newZ);
- }
+ // NPC-only ability — should not reach here
+ return null;
}
private Vec3 findSafeDestination(World world, double oldX, double oldY, double oldZ,
diff --git a/src/main/java/kamkeel/npcs/controllers/data/ability/type/AbilityTrap.java b/src/main/java/kamkeel/npcs/controllers/data/ability/type/AbilityTrap.java
index 5a540d634..494192e04 100644
--- a/src/main/java/kamkeel/npcs/controllers/data/ability/type/AbilityTrap.java
+++ b/src/main/java/kamkeel/npcs/controllers/data/ability/type/AbilityTrap.java
@@ -3,6 +3,7 @@ package kamkeel.npcs.controllers.data.ability.type;
import kamkeel.npcs.controllers.data.ability.Ability;
import kamkeel.npcs.controllers.data.ability.LockMovementType;
import kamkeel.npcs.controllers.data.ability.TargetingMode;
+import kamkeel.npcs.controllers.data.ability.UserType;
import kamkeel.npcs.controllers.data.telegraph.TelegraphInstance;
import kamkeel.npcs.controllers.data.telegraph.TelegraphType;
import net.minecraft.entity.EntityLivingBase;
@@ -83,6 +84,7 @@ public class AbilityTrap extends Ability implements IAbilityTrap {
this.cooldownTicks = 0;
this.windUpTicks = 20;
this.telegraphType = TelegraphType.CIRCLE;
+ this.allowedBy = UserType.NPC_ONLY;
}
@Override
@@ -128,7 +130,6 @@ public class AbilityTrap extends Ability implements IAbilityTrap {
}
break;
case AT_TARGET:
- // Telegraph follows target during windup, locks on execute
if (target != null) {
instance.setEntityIdToFollow(target.getEntityId());
}
@@ -154,14 +155,12 @@ public class AbilityTrap extends Ability implements IAbilityTrap {
trapZ = caster.posZ;
break;
case AT_TARGET:
- // Use telegraph position with offset
if (telegraph != null) {
double[] pos = Ability.calculateOffsetPosition(telegraph.getX(), telegraph.getY(), telegraph.getZ(),
minOffset, maxOffset, randomOffset, RANDOM);
trapX = pos[0];
trapY = pos[1];
trapZ = pos[2];
- // Update telegraph to show actual trap position
telegraph.setX(trapX);
telegraph.setY(trapY);
telegraph.setZ(trapZ);
diff --git a/src/main/java/kamkeel/npcs/controllers/data/ability/type/AbilityVortex.java b/src/main/java/kamkeel/npcs/controllers/data/ability/type/AbilityVortex.java
index 73f9816f7..90aaf054b 100644
--- a/src/main/java/kamkeel/npcs/controllers/data/ability/type/AbilityVortex.java
+++ b/src/main/java/kamkeel/npcs/controllers/data/ability/type/AbilityVortex.java
@@ -103,8 +103,9 @@ public class AbilityVortex extends Ability implements IAbilityVortex {
}
}
} else {
- // Single target mode - still check pullRadius
- if (target != null && !target.isDead) {
+ // NPC single-target mode: pull the aggro target
+ // Player: single-target mode has no effect (no target to pull — use AOE mode instead)
+ if (!isPlayerCaster(caster) && target != null && !target.isDead) {
double dist = caster.getDistanceToEntity(target);
if (dist <= pullRadius) {
getPulledEntities().add(target.getUniqueID());