Energy Explosion API and some changes to Energy Projectile API

This commit is contained in:
Kam committed 2026-03-03 17:11:12 -05:00
1 parent 6f6e080ee0
commit b59f0b8f2f
14 files changed
+476 -101

No files matched your search

@@ -2,16 +2,28 @@ package kamkeel.npcs.entity;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
import kamkeel.npcs.controllers.EnergyController;
import kamkeel.npcs.controllers.data.ability.Ability;
import kamkeel.npcs.controllers.data.ability.data.energy.EnergyDisplayData;
import kamkeel.npcs.controllers.data.ability.data.energy.EnergyLightningData;
import kamkeel.npcs.util.AttributeAttackUtil;
import kamkeel.npcs.util.CNPCDebug;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.util.AxisAlignedBB;
import net.minecraft.util.DamageSource;
import net.minecraft.util.MathHelper;
import net.minecraft.world.World;
import noppes.npcs.NpcDamageSource;
import noppes.npcs.entity.EntityNPCInterface;
import java.util.List;
/**
* Short-lived visual explosion entity for energy projectile impacts.
* This is render-only and never applies damage itself.
* Short-lived explosion entity for energy projectile impacts and standalone API use.
* Renders an expanding voxel shell. When damage is enabled, applies area damage on the first tick.
*/
public class EntityEnergyExplosion extends EntityEnergyAbility {
@@ -21,12 +33,23 @@ public class EntityEnergyExplosion extends EntityEnergyAbility {
private float renderRadius = 0.0f;
private long renderSeed = 0L;
// ==================== DAMAGE (for standalone API use) ====================
private float damage = 0f;
private float knockback = 0f;
private float knockbackUp = 0.1f;
private float damageFalloff = 0.5f;
private boolean damageEnabled = false;
private boolean hasDamaged = false;
public EntityEnergyExplosion(World world) {
super(world);
this.noClip = true;
this.setSize(0.1f, 0.1f);
}
/**
* Constructor for projectile-spawned explosions (render-only, no damage).
*/
public EntityEnergyExplosion(World world, EntityEnergyProjectile source, float radius) {
this(world);
@@ -43,6 +66,19 @@ public class EntityEnergyExplosion extends EntityEnergyAbility {
this.renderSeed = world != null ? world.rand.nextLong() : 0L;
}
/**
* Constructor for standalone API-spawned explosions.
*/
public EntityEnergyExplosion(World world, Entity owner, double x, double y, double z, float radius) {
this(world);
if (owner != null) {
this.ownerEntityId = owner.getEntityId();
}
this.setPosition(x, y, z);
setExplosionRadius(radius);
this.renderSeed = world != null ? world.rand.nextLong() : 0L;
}
@Override
protected void entityInit() {
super.entityInit();
@@ -58,6 +94,12 @@ public class EntityEnergyExplosion extends EntityEnergyAbility {
float eased = 1.0f - (1.0f - progress) * (1.0f - progress);
this.renderRadius = maxRadius * eased;
// Apply damage on first server tick
if (damageEnabled && !hasDamaged && !worldObj.isRemote && ticksExisted >= 1) {
applyExplosionDamage();
hasDamaged = true;
}
// Debug logging
{
boolean isClient = worldObj.isRemote;
@@ -74,12 +116,110 @@ public class EntityEnergyExplosion extends EntityEnergyAbility {
}
}
// ==================== DAMAGE LOGIC ====================
private void applyExplosionDamage() {
if (damage <= 0 || maxRadius <= 0) return;
Entity owner = getOwnerEntity();
double explosionRadSq = maxRadius * maxRadius;
AxisAlignedBB explosionBox = AxisAlignedBB.getBoundingBox(
posX - maxRadius, posY - maxRadius, posZ - maxRadius,
posX + maxRadius, posY + maxRadius, posZ + maxRadius
);
@SuppressWarnings("unchecked")
List<EntityLivingBase> targets = worldObj.getEntitiesWithinAABB(EntityLivingBase.class, explosionBox);
for (EntityLivingBase target : targets) {
if (target == owner) continue;
if (target.boundingBox == null) continue;
double closestX = Math.max(target.boundingBox.minX, Math.min(posX, target.boundingBox.maxX));
double closestY = Math.max(target.boundingBox.minY, Math.min(posY, target.boundingBox.maxY));
double closestZ = Math.max(target.boundingBox.minZ, Math.min(posZ, target.boundingBox.maxZ));
double dx = closestX - posX;
double dy = closestY - posY;
double dz = closestZ - posZ;
double distSq = dx * dx + dy * dy + dz * dz;
if (distSq > explosionRadSq) continue;
float falloff = 1.0f;
if (damageFalloff != 0.0f && distSq > 0.0D) {
float dist = (float) Math.sqrt(distSq);
falloff = 1.0f - (dist / maxRadius) * damageFalloff;
}
float finalDmg = damage * falloff;
float finalKb = knockback * falloff;
// Route through EnergyController for addon integration (e.g. DBC)
boolean handled = false;
if (customDamageData != null && owner instanceof EntityLivingBase) {
double kbDirX = target.posX - posX;
double kbDirZ = target.posZ - posZ;
handled = EnergyController.Instance.fireOnEnergyDamage(
this, (EntityLivingBase) owner, target,
finalDmg, finalKb, knockbackUp, kbDirX, kbDirZ, 1.0f, customDamageData);
}
int prevHurtResist = Ability.clearHurtResistanceIfNeeded(target, ignoreIFrames);
try {
if (!handled) {
float dmgToApply = finalDmg;
// Magic pipeline
if (this.magicData != null && !this.magicData.isEmpty() && owner instanceof EntityLivingBase) {
dmgToApply = AttributeAttackUtil.calculateAbilityDamage(
(EntityLivingBase) owner, target, finalDmg, this.magicData);
}
if (owner instanceof EntityNPCInterface) {
target.attackEntityFrom(new NpcDamageSource("npc_ability", (EntityNPCInterface) owner), dmgToApply);
} else if (owner instanceof EntityPlayer) {
target.attackEntityFrom(DamageSource.causePlayerDamage((EntityPlayer) owner), dmgToApply);
} else if (owner instanceof EntityLivingBase) {
target.attackEntityFrom(DamageSource.causeMobDamage((EntityLivingBase) owner), dmgToApply);
} else {
target.attackEntityFrom(new NpcDamageSource("npc_ability", null), dmgToApply);
}
}
} finally {
Ability.restoreHurtResistanceIfNeeded(target, ignoreIFrames, prevHurtResist);
}
// Apply knockback
if (finalKb > 0) {
double kbDx = target.posX - posX;
double kbDz = target.posZ - posZ;
double len = Math.sqrt(kbDx * kbDx + kbDz * kbDz);
if (len > 0) {
target.addVelocity((kbDx / len) * finalKb * 0.5, knockbackUp, (kbDz / len) * finalKb * 0.5);
target.velocityChanged = true;
}
}
}
worldObj.playSoundEffect(posX, posY, posZ, "random.explode", 1.0f, 1.0f);
}
// ==================== RADIUS / DURATION ====================
public void setExplosionRadius(float radius) {
this.maxRadius = Math.max(0.5f, sanitize(radius, 2.0f, MAX_ENTITY_RADIUS));
this.durationTicks = Math.max(6, Math.min(18, (int) (6 + this.maxRadius * 1.8f)));
this.setSize(this.maxRadius * 2.0f, this.maxRadius * 2.0f);
}
public float getExplosionRadius() {
return maxRadius;
}
public int getDurationTicks() {
return durationTicks;
}
public float getInterpolatedRadius(float partialTicks) {
return this.prevRenderRadius + (this.renderRadius - this.prevRenderRadius) * partialTicks;
}
@@ -94,6 +234,47 @@ public class EntityEnergyExplosion extends EntityEnergyAbility {
return renderSeed;
}
// ==================== DAMAGE GETTERS/SETTERS ====================
public float getDamage() {
return damage;
}
public void setDamage(float damage) {
this.damage = Math.max(0, damage);
this.damageEnabled = this.damage > 0;
}
public float getKnockback() {
return knockback;
}
public void setKnockback(float knockback) {
this.knockback = Math.max(0, knockback);
}
public float getKnockbackUp() {
return knockbackUp;
}
public void setKnockbackUp(float knockbackUp) {
this.knockbackUp = knockbackUp;
}
public float getDamageFalloff() {
return damageFalloff;
}
public void setDamageFalloff(float falloff) {
this.damageFalloff = MathHelper.clamp_float(falloff, 0.0f, 1.0f);
}
public boolean isDamageEnabled() {
return damageEnabled;
}
// ==================== RENDER / COLLISION ====================
@Override
@SideOnly(Side.CLIENT)
public boolean isInRangeToRenderDist(double distance) {
@@ -106,6 +287,8 @@ public class EntityEnergyExplosion extends EntityEnergyAbility {
return false;
}
// ==================== NBT ====================
@Override
protected void readEntityFromNBT(NBTTagCompound nbt) {
// Intentionally empty - transient visual entity.
@@ -125,6 +308,12 @@ public class EntityEnergyExplosion extends EntityEnergyAbility {
nbt.setFloat("ExplosionRadius", maxRadius);
nbt.setInteger("ExplosionDuration", durationTicks);
nbt.setLong("ExplosionSeed", renderSeed);
if (damageEnabled) {
nbt.setFloat("Damage", damage);
nbt.setFloat("Knockback", knockback);
nbt.setFloat("KnockbackUp", knockbackUp);
nbt.setFloat("DamageFalloff", damageFalloff);
}
}
@Override
@@ -146,5 +335,12 @@ public class EntityEnergyExplosion extends EntityEnergyAbility {
this.renderSeed = nbt.hasKey("ExplosionSeed") ? nbt.getLong("ExplosionSeed") : 0L;
this.renderRadius = 0.0f;
this.prevRenderRadius = 0.0f;
if (nbt.hasKey("Damage")) {
this.damage = nbt.getFloat("Damage");
this.knockback = nbt.getFloat("Knockback");
this.knockbackUp = nbt.getFloat("KnockbackUp");
this.damageFalloff = nbt.getFloat("DamageFalloff");
this.damageEnabled = this.damage > 0;
}
}
}