mirror of
https://github.com/KAMKEEL/CustomNPC-Plus.git
synced 2026-11-12 17:47:32 +00:00
787 lines
31 KiB
Java
787 lines
31 KiB
Java
package kamkeel.npcs.entity;
|
|
|
|
import kamkeel.npcs.controllers.data.ability.AnchorPoint;
|
|
import kamkeel.npcs.util.AnchorPointHelper;
|
|
import net.minecraft.entity.Entity;
|
|
import net.minecraft.entity.EntityLivingBase;
|
|
import net.minecraft.nbt.NBTTagCompound;
|
|
import net.minecraft.nbt.NBTTagList;
|
|
import net.minecraft.util.AxisAlignedBB;
|
|
import net.minecraft.util.MovingObjectPosition;
|
|
import net.minecraft.util.Vec3;
|
|
import net.minecraft.world.World;
|
|
import noppes.npcs.LogWriter;
|
|
import noppes.npcs.entity.EntityNPCInterface;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
|
|
/**
|
|
* Beam projectile - head with trailing path that curves with homing.
|
|
* Stays attached to origin point, trail shows path of head.
|
|
*
|
|
* IMPORTANT: Trail points are stored RELATIVE to startX/Y/Z (origin).
|
|
* This ensures rendering is stable regardless of entity position interpolation.
|
|
*
|
|
* Design inspired by LouisXIV's energy attack system.
|
|
*/
|
|
public class EntityAbilityBeam extends EntityAbilityProjectile {
|
|
|
|
// Beam-specific movement properties
|
|
private float speed = 0.5f;
|
|
private boolean homing = true;
|
|
private float homingStrength = 0.35f; // Increased from 0.15 for better tracking
|
|
private float homingRange = 20.0f;
|
|
|
|
// Beam shape properties
|
|
private float beamWidth = 0.3f;
|
|
private float headSize = 0.5f;
|
|
|
|
// Trail - list of points showing beam path (RELATIVE to origin!)
|
|
private List<Vec3> trailPoints = new ArrayList<>();
|
|
private static final int MAX_TRAIL_POINTS = 200;
|
|
private static final double MIN_POINT_DISTANCE = 0.2;
|
|
|
|
// Head position relative to origin
|
|
private double headOffsetX, headOffsetY, headOffsetZ;
|
|
private double prevHeadOffsetX, prevHeadOffsetY, prevHeadOffsetZ;
|
|
|
|
// Origin stays fixed (or follows owner)
|
|
private boolean attachedToOwner = true;
|
|
|
|
// Whether to render tail orb (only when anchored)
|
|
private boolean renderTailOrb = true;
|
|
|
|
// Charging state (during windup)
|
|
private boolean charging = false;
|
|
private int chargeDuration = 40;
|
|
private int chargeTick = 0;
|
|
private float chargeOffsetDistance = 1.0f;
|
|
private AnchorPoint anchorPoint = AnchorPoint.FRONT;
|
|
|
|
// Trail fading for non-anchored beams (comet effect)
|
|
private boolean fadeTrail = false;
|
|
private int trailFadeTime = 20; // Ticks for trail to fully fade
|
|
private List<Integer> trailPointAges = new ArrayList<>();
|
|
|
|
// Data watcher index for charging state (synced to clients)
|
|
private static final int DW_CHARGING = 20;
|
|
|
|
// Debug logging
|
|
private static final boolean DEBUG_LOGGING = true;
|
|
|
|
public EntityAbilityBeam(World world) {
|
|
super(world);
|
|
}
|
|
|
|
@Override
|
|
protected void entityInit() {
|
|
super.entityInit();
|
|
// Register data watcher for charging state
|
|
this.dataWatcher.addObject(DW_CHARGING, (byte) 0);
|
|
}
|
|
|
|
/**
|
|
* Check if beam is in charging state (synced via data watcher).
|
|
*/
|
|
public boolean isCharging() {
|
|
return this.dataWatcher.getWatchableObjectByte(DW_CHARGING) == 1;
|
|
}
|
|
|
|
/**
|
|
* Set charging state (server only, synced to clients via data watcher).
|
|
*/
|
|
private void setCharging(boolean value) {
|
|
this.charging = value;
|
|
if (!worldObj.isRemote) {
|
|
this.dataWatcher.updateObject(DW_CHARGING, (byte) (value ? 1 : 0));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Full constructor with all parameters (no lightning).
|
|
*/
|
|
public EntityAbilityBeam(World world, EntityNPCInterface owner, EntityLivingBase target,
|
|
double x, double y, double z,
|
|
float beamWidth, float headSize, int innerColor, int outerColor,
|
|
boolean outerColorEnabled, float outerColorWidth, float rotationSpeed,
|
|
float damage, float knockback, float knockbackUp,
|
|
float speed, boolean homing, float homingStrength, float homingRange,
|
|
boolean explosive, float explosionRadius, float explosionDamageFalloff,
|
|
int stunDuration, int slowDuration, int slowLevel,
|
|
float maxDistance, int maxLifetime) {
|
|
this(world, owner, target, x, y, z,
|
|
beamWidth, headSize, innerColor, outerColor, outerColorEnabled, outerColorWidth, rotationSpeed,
|
|
damage, knockback, knockbackUp, speed, homing, homingStrength, homingRange,
|
|
explosive, explosionRadius, explosionDamageFalloff,
|
|
stunDuration, slowDuration, slowLevel, maxDistance, maxLifetime,
|
|
false, 0.15f, 0.5f);
|
|
}
|
|
|
|
/**
|
|
* Full constructor with all parameters including lightning.
|
|
*/
|
|
public EntityAbilityBeam(World world, EntityNPCInterface owner, EntityLivingBase target,
|
|
double x, double y, double z,
|
|
float beamWidth, float headSize, int innerColor, int outerColor,
|
|
boolean outerColorEnabled, float outerColorWidth, float rotationSpeed,
|
|
float damage, float knockback, float knockbackUp,
|
|
float speed, boolean homing, float homingStrength, float homingRange,
|
|
boolean explosive, float explosionRadius, float explosionDamageFalloff,
|
|
int stunDuration, int slowDuration, int slowLevel,
|
|
float maxDistance, int maxLifetime,
|
|
boolean lightningEffect, float lightningDensity, float lightningRadius) {
|
|
this(world, owner, target, x, y, z,
|
|
beamWidth, headSize, innerColor, outerColor, outerColorEnabled, outerColorWidth, rotationSpeed,
|
|
damage, knockback, knockbackUp, speed, homing, homingStrength, homingRange,
|
|
explosive, explosionRadius, explosionDamageFalloff,
|
|
stunDuration, slowDuration, slowLevel, maxDistance, maxLifetime,
|
|
lightningEffect, lightningDensity, lightningRadius,
|
|
true); // Default to anchored mode
|
|
}
|
|
|
|
/**
|
|
* Full constructor with all parameters including lightning and anchored mode.
|
|
* @param anchoredMode If true, origin follows owner and tail orb is rendered.
|
|
* If false, beam is free-moving with trailing length (no tail orb).
|
|
*/
|
|
public EntityAbilityBeam(World world, EntityNPCInterface owner, EntityLivingBase target,
|
|
double x, double y, double z,
|
|
float beamWidth, float headSize, int innerColor, int outerColor,
|
|
boolean outerColorEnabled, float outerColorWidth, float rotationSpeed,
|
|
float damage, float knockback, float knockbackUp,
|
|
float speed, boolean homing, float homingStrength, float homingRange,
|
|
boolean explosive, float explosionRadius, float explosionDamageFalloff,
|
|
int stunDuration, int slowDuration, int slowLevel,
|
|
float maxDistance, int maxLifetime,
|
|
boolean lightningEffect, float lightningDensity, float lightningRadius,
|
|
boolean anchoredMode) {
|
|
super(world);
|
|
|
|
// Initialize base properties with lightning
|
|
initProjectile(owner, target, x, y, z,
|
|
headSize, innerColor, outerColor, outerColorEnabled, outerColorWidth, rotationSpeed,
|
|
damage, knockback, knockbackUp,
|
|
explosive, explosionRadius, explosionDamageFalloff,
|
|
stunDuration, slowDuration, slowLevel,
|
|
maxDistance, maxLifetime,
|
|
lightningEffect, lightningDensity, lightningRadius, 6);
|
|
|
|
// Beam-specific properties
|
|
this.speed = speed;
|
|
this.homing = homing;
|
|
this.homingStrength = homingStrength;
|
|
this.homingRange = homingRange;
|
|
this.beamWidth = beamWidth;
|
|
this.headSize = headSize;
|
|
|
|
// Anchored mode controls whether origin follows owner and tail orb is rendered
|
|
this.attachedToOwner = anchoredMode;
|
|
this.renderTailOrb = anchoredMode;
|
|
|
|
// Initialize head offset at origin (0,0,0 relative)
|
|
this.headOffsetX = 0;
|
|
this.headOffsetY = 0;
|
|
this.headOffsetZ = 0;
|
|
this.prevHeadOffsetX = 0;
|
|
this.prevHeadOffsetY = 0;
|
|
this.prevHeadOffsetZ = 0;
|
|
|
|
// Add initial trail point at origin (relative 0,0,0)
|
|
trailPoints.add(Vec3.createVectorHelper(0, 0, 0));
|
|
|
|
if (DEBUG_LOGGING && !world.isRemote) {
|
|
LogWriter.info("[Beam] Created at origin " + x + ", " + y + ", " + z + " maxDist=" + maxDistance);
|
|
}
|
|
|
|
// Calculate initial velocity toward target
|
|
if (target != null) {
|
|
double dx = target.posX - x;
|
|
double dy = (target.posY + target.height * 0.5) - y;
|
|
double dz = target.posZ - z;
|
|
double len = Math.sqrt(dx * dx + dy * dy + dz * dz);
|
|
if (len > 0) {
|
|
this.motionX = (dx / len) * speed;
|
|
this.motionY = (dy / len) * speed;
|
|
this.motionZ = (dz / len) * speed;
|
|
}
|
|
} else {
|
|
float yaw = (float) Math.toRadians(owner.rotationYaw);
|
|
float pitch = (float) Math.toRadians(owner.rotationPitch);
|
|
this.motionX = -Math.sin(yaw) * Math.cos(pitch) * speed;
|
|
this.motionY = -Math.sin(pitch) * speed;
|
|
this.motionZ = Math.cos(yaw) * Math.cos(pitch) * speed;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Create a beam in charging mode (for windup phase).
|
|
* The beam will grow from 0 to headSize over chargeDuration ticks.
|
|
* Position follows the owner based on anchor point.
|
|
*/
|
|
public static EntityAbilityBeam createCharging(World world, EntityNPCInterface owner, EntityLivingBase target,
|
|
float beamWidth, float headSize, int innerColor, int outerColor,
|
|
boolean outerColorEnabled, float outerColorWidth, float rotationSpeed,
|
|
float damage, float knockback, float knockbackUp,
|
|
float speed, boolean homing, float homingStrength, float homingRange,
|
|
boolean explosive, float explosionRadius, float explosionDamageFalloff,
|
|
int stunDuration, int slowDuration, int slowLevel,
|
|
float maxDistance, int maxLifetime,
|
|
boolean lightningEffect, float lightningDensity, float lightningRadius,
|
|
boolean anchoredMode, int chargeDuration, float chargeOffsetDistance,
|
|
AnchorPoint anchorPoint) {
|
|
// Calculate initial position based on anchor point
|
|
Vec3 spawnPos = AnchorPointHelper.calculateAnchorPosition(owner, anchorPoint, chargeOffsetDistance);
|
|
double spawnX = spawnPos.xCoord;
|
|
double spawnY = spawnPos.yCoord;
|
|
double spawnZ = spawnPos.zCoord;
|
|
|
|
EntityAbilityBeam beam = new EntityAbilityBeam(
|
|
world, owner, target,
|
|
spawnX, spawnY, spawnZ,
|
|
beamWidth, headSize, innerColor, outerColor, outerColorEnabled, outerColorWidth, rotationSpeed,
|
|
damage, knockback, knockbackUp, speed, homing, homingStrength, homingRange,
|
|
explosive, explosionRadius, explosionDamageFalloff,
|
|
stunDuration, slowDuration, slowLevel, maxDistance, maxLifetime,
|
|
lightningEffect, lightningDensity, lightningRadius,
|
|
anchoredMode);
|
|
|
|
// Set charging state (uses data watcher for client sync)
|
|
beam.setCharging(true);
|
|
beam.chargeDuration = chargeDuration;
|
|
beam.chargeTick = 0;
|
|
beam.chargeOffsetDistance = chargeOffsetDistance;
|
|
beam.anchorPoint = anchorPoint;
|
|
|
|
// Non-anchored beams have fading trail (comet effect)
|
|
beam.fadeTrail = !anchoredMode;
|
|
|
|
// Clear motion while charging
|
|
beam.motionX = 0;
|
|
beam.motionY = 0;
|
|
beam.motionZ = 0;
|
|
|
|
return beam;
|
|
}
|
|
|
|
/**
|
|
* Start the beam firing (exit charging mode).
|
|
* Called by ability when windup ends.
|
|
*
|
|
* For anchored beams: origin follows owner, head starts at charged position
|
|
* For non-anchored beams: origin fixed at charged position, head starts there
|
|
*/
|
|
public void startFiring(EntityLivingBase target) {
|
|
if (!isCharging()) return;
|
|
|
|
setCharging(false);
|
|
|
|
// Origin (tail) stays at the charged position - where the orb was
|
|
// This is the same for both anchored and non-anchored modes
|
|
startX = posX;
|
|
startY = posY;
|
|
startZ = posZ;
|
|
|
|
// Head starts at the origin (tail position)
|
|
headOffsetX = 0;
|
|
headOffsetY = 0;
|
|
headOffsetZ = 0;
|
|
prevHeadOffsetX = 0;
|
|
prevHeadOffsetY = 0;
|
|
prevHeadOffsetZ = 0;
|
|
|
|
// Origin no longer follows owner after firing starts
|
|
// (for anchored mode, tail is fixed in space; for non-anchored, there's no tail)
|
|
attachedToOwner = false;
|
|
|
|
// Initialize trail with just the origin point
|
|
trailPoints.clear();
|
|
trailPointAges.clear();
|
|
trailPoints.add(Vec3.createVectorHelper(0, 0, 0));
|
|
if (fadeTrail) trailPointAges.add(0);
|
|
|
|
// Calculate velocity toward target (head starts at origin = startX/Y/Z)
|
|
Entity owner = getOwner();
|
|
|
|
if (target != null) {
|
|
double dx = target.posX - startX;
|
|
double dy = (target.posY + target.height * 0.5) - startY;
|
|
double dz = target.posZ - startZ;
|
|
double len = Math.sqrt(dx * dx + dy * dy + dz * dz);
|
|
if (len > 0) {
|
|
motionX = (dx / len) * speed;
|
|
motionY = (dy / len) * speed;
|
|
motionZ = (dz / len) * speed;
|
|
}
|
|
} else if (owner != null) {
|
|
float yaw = (float) Math.toRadians(owner.rotationYaw);
|
|
float pitch = (float) Math.toRadians(owner.rotationPitch);
|
|
motionX = -Math.sin(yaw) * Math.cos(pitch) * speed;
|
|
motionY = -Math.sin(pitch) * speed;
|
|
motionZ = Math.cos(yaw) * Math.cos(pitch) * speed;
|
|
}
|
|
|
|
if (DEBUG_LOGGING && !worldObj.isRemote) {
|
|
LogWriter.info("[Beam] startFiring: origin=(" + startX + "," + startY + "," + startZ +
|
|
") headOffset=(" + headOffsetX + "," + headOffsetY + "," + headOffsetZ +
|
|
") motion=(" + motionX + "," + motionY + "," + motionZ + ")");
|
|
}
|
|
}
|
|
|
|
@Override
|
|
protected boolean checkMaxDistance() {
|
|
// Check distance using head offset (distance from origin)
|
|
double distFromOrigin = Math.sqrt(
|
|
headOffsetX * headOffsetX +
|
|
headOffsetY * headOffsetY +
|
|
headOffsetZ * headOffsetZ
|
|
);
|
|
boolean exceeded = distFromOrigin >= maxDistance;
|
|
if (exceeded && !worldObj.isRemote && DEBUG_LOGGING) {
|
|
LogWriter.info("[Beam] DEAD: Max distance exceeded. dist=" + distFromOrigin + " max=" + maxDistance);
|
|
}
|
|
return exceeded;
|
|
}
|
|
|
|
@Override
|
|
protected void updateProjectile() {
|
|
// Handle charging state (windup phase) - use isCharging() for synced value
|
|
if (isCharging()) {
|
|
updateCharging();
|
|
return;
|
|
}
|
|
|
|
// Store previous head offset for interpolation
|
|
prevHeadOffsetX = headOffsetX;
|
|
prevHeadOffsetY = headOffsetY;
|
|
prevHeadOffsetZ = headOffsetZ;
|
|
|
|
// Age trail points for fading effect
|
|
if (fadeTrail) {
|
|
ageTrailPoints();
|
|
}
|
|
|
|
if (worldObj.isRemote) {
|
|
// Client: interpolate entity position
|
|
handleClientInterpolation();
|
|
|
|
// Client: derive head offset from entity position and origin
|
|
// Entity position = head world position, so headOffset = pos - origin
|
|
// Note: During charging, updateCharging() handles origin positioning
|
|
// After firing, origin is fixed at the charged position
|
|
headOffsetX = posX - startX;
|
|
headOffsetY = posY - startY;
|
|
headOffsetZ = posZ - startZ;
|
|
|
|
// Add trail point on client
|
|
addTrailPoint();
|
|
} else {
|
|
// Server-side logic
|
|
updateHoming();
|
|
|
|
// Move head offset
|
|
headOffsetX += motionX;
|
|
headOffsetY += motionY;
|
|
headOffsetZ += motionZ;
|
|
|
|
// Update origin if attached to owner
|
|
if (attachedToOwner) {
|
|
Entity owner = getOwner();
|
|
if (owner != null) {
|
|
startX = owner.posX;
|
|
startY = owner.posY + owner.getEyeHeight() * 0.7;
|
|
startZ = owner.posZ;
|
|
}
|
|
}
|
|
|
|
// Calculate world position of head for collision detection
|
|
double headWorldX = startX + headOffsetX;
|
|
double headWorldY = startY + headOffsetY;
|
|
double headWorldZ = startZ + headOffsetZ;
|
|
|
|
// Update entity position to head (for network sync)
|
|
this.setPosition(headWorldX, headWorldY, headWorldZ);
|
|
|
|
// Add trail point
|
|
addTrailPoint();
|
|
|
|
// Debug log periodically
|
|
if (DEBUG_LOGGING && ticksExisted % 20 == 0) {
|
|
LogWriter.info("[Beam] Server tick=" + ticksExisted + " headOffset=(" +
|
|
String.format("%.2f", headOffsetX) + "," +
|
|
String.format("%.2f", headOffsetY) + "," +
|
|
String.format("%.2f", headOffsetZ) + ") origin=(" +
|
|
String.format("%.2f", startX) + "," +
|
|
String.format("%.2f", startY) + "," +
|
|
String.format("%.2f", startZ) + ") trail=" + trailPoints.size());
|
|
}
|
|
|
|
// Skip collision checks on first few ticks
|
|
if (ticksExisted > 2) {
|
|
checkBlockCollision(headWorldX, headWorldY, headWorldZ);
|
|
checkEntityCollision(headWorldX, headWorldY, headWorldZ);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Update during charging state - follow owner based on anchor point.
|
|
*/
|
|
private void updateCharging() {
|
|
chargeTick++;
|
|
|
|
Entity owner = getOwner();
|
|
if (owner == null || owner.isDead) {
|
|
setDead();
|
|
return;
|
|
}
|
|
|
|
// Calculate position based on anchor point
|
|
Vec3 pos;
|
|
if (owner instanceof EntityLivingBase) {
|
|
pos = AnchorPointHelper.calculateAnchorPosition((EntityLivingBase) owner, anchorPoint, chargeOffsetDistance);
|
|
} else {
|
|
// Fallback for non-living entities (shouldn't happen normally)
|
|
float yaw = (float) Math.toRadians(owner.rotationYaw);
|
|
double offsetX = -Math.sin(yaw) * chargeOffsetDistance;
|
|
double offsetZ = Math.cos(yaw) * chargeOffsetDistance;
|
|
pos = Vec3.createVectorHelper(
|
|
owner.posX + offsetX,
|
|
owner.posY + owner.getEyeHeight() * 0.7,
|
|
owner.posZ + offsetZ
|
|
);
|
|
}
|
|
|
|
setPosition(pos.xCoord, pos.yCoord, pos.zCoord);
|
|
|
|
// Also update origin for when firing starts
|
|
startX = pos.xCoord;
|
|
startY = pos.yCoord;
|
|
startZ = pos.zCoord;
|
|
}
|
|
|
|
/**
|
|
* Age trail points and remove old ones (for comet effect).
|
|
*/
|
|
private void ageTrailPoints() {
|
|
// Age all trail points
|
|
for (int i = 0; i < trailPointAges.size(); i++) {
|
|
trailPointAges.set(i, trailPointAges.get(i) + 1);
|
|
}
|
|
|
|
// Remove trail points that have fully faded
|
|
while (!trailPointAges.isEmpty() && trailPointAges.get(0) >= trailFadeTime) {
|
|
trailPointAges.remove(0);
|
|
if (!trailPoints.isEmpty()) {
|
|
trailPoints.remove(0);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void addTrailPoint() {
|
|
// Trail points are RELATIVE to origin
|
|
if (trailPoints.isEmpty()) {
|
|
trailPoints.add(Vec3.createVectorHelper(headOffsetX, headOffsetY, headOffsetZ));
|
|
if (fadeTrail) {
|
|
trailPointAges.add(0);
|
|
}
|
|
return;
|
|
}
|
|
|
|
Vec3 lastPoint = trailPoints.get(trailPoints.size() - 1);
|
|
double dist = Math.sqrt(
|
|
(headOffsetX - lastPoint.xCoord) * (headOffsetX - lastPoint.xCoord) +
|
|
(headOffsetY - lastPoint.yCoord) * (headOffsetY - lastPoint.yCoord) +
|
|
(headOffsetZ - lastPoint.zCoord) * (headOffsetZ - lastPoint.zCoord)
|
|
);
|
|
|
|
if (dist >= MIN_POINT_DISTANCE) {
|
|
trailPoints.add(Vec3.createVectorHelper(headOffsetX, headOffsetY, headOffsetZ));
|
|
if (fadeTrail) {
|
|
trailPointAges.add(0);
|
|
}
|
|
|
|
// Limit trail length (only if not using fading - fading handles its own cleanup)
|
|
if (!fadeTrail) {
|
|
while (trailPoints.size() > MAX_TRAIL_POINTS) {
|
|
trailPoints.remove(0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void updateHoming() {
|
|
if (!homing) return;
|
|
|
|
Entity target = getTarget();
|
|
if (target == null || !target.isEntityAlive()) return;
|
|
|
|
// Calculate world position of head
|
|
double headWorldX = startX + headOffsetX;
|
|
double headWorldY = startY + headOffsetY;
|
|
double headWorldZ = startZ + headOffsetZ;
|
|
|
|
double dx = target.posX - headWorldX;
|
|
double dy = (target.posY + target.height * 0.5) - headWorldY;
|
|
double dz = target.posZ - headWorldZ;
|
|
double dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
|
|
|
|
if (dist <= homingRange && dist > 0) {
|
|
// Calculate effective homing strength - increases when closer to commit to target
|
|
float effectiveStrength = homingStrength;
|
|
if (dist < homingRange * 0.3) {
|
|
effectiveStrength = Math.min(1.0f, homingStrength * 2.5f);
|
|
} else if (dist < homingRange * 0.6) {
|
|
effectiveStrength = Math.min(0.8f, homingStrength * 1.5f);
|
|
}
|
|
|
|
double desiredVX = (dx / dist) * speed;
|
|
double desiredVY = (dy / dist) * speed;
|
|
double desiredVZ = (dz / dist) * speed;
|
|
|
|
motionX += (desiredVX - motionX) * effectiveStrength;
|
|
motionY += (desiredVY - motionY) * effectiveStrength;
|
|
motionZ += (desiredVZ - motionZ) * effectiveStrength;
|
|
|
|
double vLen = Math.sqrt(motionX * motionX + motionY * motionY + motionZ * motionZ);
|
|
if (vLen > 0) {
|
|
motionX = (motionX / vLen) * speed;
|
|
motionY = (motionY / vLen) * speed;
|
|
motionZ = (motionZ / vLen) * speed;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void checkBlockCollision(double headX, double headY, double headZ) {
|
|
// Previous head world position
|
|
double prevHeadWorldX = startX + prevHeadOffsetX;
|
|
double prevHeadWorldY = startY + prevHeadOffsetY;
|
|
double prevHeadWorldZ = startZ + prevHeadOffsetZ;
|
|
|
|
Vec3 currentPos = Vec3.createVectorHelper(prevHeadWorldX, prevHeadWorldY, prevHeadWorldZ);
|
|
Vec3 nextPos = Vec3.createVectorHelper(headX, headY, headZ);
|
|
MovingObjectPosition blockHit = worldObj.rayTraceBlocks(currentPos, nextPos);
|
|
|
|
if (blockHit != null && blockHit.typeOfHit == MovingObjectPosition.MovingObjectType.BLOCK) {
|
|
if (DEBUG_LOGGING) {
|
|
LogWriter.info("[Beam] DEAD: Block collision at tick " + ticksExisted);
|
|
}
|
|
hasHit = true;
|
|
if (explosive) {
|
|
posX = blockHit.hitVec.xCoord;
|
|
posY = blockHit.hitVec.yCoord;
|
|
posZ = blockHit.hitVec.zCoord;
|
|
doExplosion();
|
|
}
|
|
this.setDead();
|
|
}
|
|
}
|
|
|
|
private void checkEntityCollision(double headX, double headY, double headZ) {
|
|
double hitSize = headSize * 0.5;
|
|
AxisAlignedBB hitBox = AxisAlignedBB.getBoundingBox(
|
|
headX - hitSize, headY - hitSize, headZ - hitSize,
|
|
headX + hitSize, headY + hitSize, headZ + hitSize
|
|
);
|
|
|
|
@SuppressWarnings("unchecked")
|
|
List<EntityLivingBase> entities = worldObj.getEntitiesWithinAABB(EntityLivingBase.class, hitBox);
|
|
|
|
for (EntityLivingBase entity : entities) {
|
|
if (shouldIgnoreEntity(entity)) continue;
|
|
|
|
if (DEBUG_LOGGING) {
|
|
LogWriter.info("[Beam] DEAD: Entity collision with " + entity.getClass().getSimpleName() + " at tick " + ticksExisted);
|
|
}
|
|
hasHit = true;
|
|
|
|
if (explosive) {
|
|
posX = headX;
|
|
posY = headY;
|
|
posZ = headZ;
|
|
doExplosion();
|
|
} else {
|
|
applyDamage(entity);
|
|
}
|
|
|
|
this.setDead();
|
|
return;
|
|
}
|
|
}
|
|
|
|
// ==================== GETTERS FOR RENDERER ====================
|
|
|
|
public float getBeamWidth() {
|
|
return beamWidth;
|
|
}
|
|
|
|
public float getHeadSize() {
|
|
return headSize;
|
|
}
|
|
|
|
/**
|
|
* Get interpolated head offset for smooth rendering.
|
|
* Returns offset RELATIVE to origin.
|
|
*/
|
|
public double getInterpolatedHeadOffsetX(float partialTicks) {
|
|
return prevHeadOffsetX + (headOffsetX - prevHeadOffsetX) * partialTicks;
|
|
}
|
|
|
|
public double getInterpolatedHeadOffsetY(float partialTicks) {
|
|
return prevHeadOffsetY + (headOffsetY - prevHeadOffsetY) * partialTicks;
|
|
}
|
|
|
|
public double getInterpolatedHeadOffsetZ(float partialTicks) {
|
|
return prevHeadOffsetZ + (headOffsetZ - prevHeadOffsetZ) * partialTicks;
|
|
}
|
|
|
|
/**
|
|
* Get trail points. These are RELATIVE to origin (startX/Y/Z).
|
|
*/
|
|
public List<Vec3> getTrailPoints() {
|
|
return trailPoints;
|
|
}
|
|
|
|
public double getOriginX() {
|
|
return startX;
|
|
}
|
|
|
|
public double getOriginY() {
|
|
return startY;
|
|
}
|
|
|
|
public double getOriginZ() {
|
|
return startZ;
|
|
}
|
|
|
|
/**
|
|
* Whether the tail orb should be rendered (only true in anchored mode).
|
|
*/
|
|
public boolean shouldRenderTailOrb() {
|
|
return renderTailOrb;
|
|
}
|
|
|
|
/**
|
|
* Whether the beam is attached to its owner (anchored mode).
|
|
*/
|
|
public boolean isAttachedToOwner() {
|
|
return attachedToOwner;
|
|
}
|
|
|
|
/**
|
|
* Get the charge progress (0-1).
|
|
*/
|
|
public float getChargeProgress() {
|
|
if (chargeDuration <= 0) return 1.0f;
|
|
return Math.min(1.0f, (float) chargeTick / chargeDuration);
|
|
}
|
|
|
|
/**
|
|
* Get interpolated charge progress for smooth rendering.
|
|
*/
|
|
public float getInterpolatedChargeProgress(float partialTicks) {
|
|
if (chargeDuration <= 0) return 1.0f;
|
|
float prevProgress = Math.max(0, (float) (chargeTick - 1) / chargeDuration);
|
|
float currProgress = Math.min(1.0f, (float) chargeTick / chargeDuration);
|
|
return prevProgress + (currProgress - prevProgress) * partialTicks;
|
|
}
|
|
|
|
/**
|
|
* Whether trail should fade (comet effect for non-anchored beams).
|
|
*/
|
|
public boolean hasFadingTrail() {
|
|
return fadeTrail;
|
|
}
|
|
|
|
/**
|
|
* Get trail point ages for fading calculation.
|
|
*/
|
|
public List<Integer> getTrailPointAges() {
|
|
return trailPointAges;
|
|
}
|
|
|
|
/**
|
|
* Get trail fade time in ticks.
|
|
*/
|
|
public int getTrailFadeTime() {
|
|
return trailFadeTime;
|
|
}
|
|
|
|
// ==================== NBT ====================
|
|
|
|
@Override
|
|
protected void readProjectileNBT(NBTTagCompound nbt) {
|
|
this.speed = nbt.hasKey("Speed") ? nbt.getFloat("Speed") : 0.5f;
|
|
this.homing = !nbt.hasKey("Homing") || nbt.getBoolean("Homing");
|
|
this.homingStrength = nbt.hasKey("HomingStrength") ? nbt.getFloat("HomingStrength") : 0.15f;
|
|
this.homingRange = nbt.hasKey("HomingRange") ? nbt.getFloat("HomingRange") : 20.0f;
|
|
this.beamWidth = nbt.hasKey("BeamWidth") ? nbt.getFloat("BeamWidth") : 0.3f;
|
|
this.headSize = nbt.hasKey("HeadSize") ? nbt.getFloat("HeadSize") : 0.5f;
|
|
this.headOffsetX = nbt.hasKey("HeadOffsetX") ? nbt.getDouble("HeadOffsetX") : 0;
|
|
this.headOffsetY = nbt.hasKey("HeadOffsetY") ? nbt.getDouble("HeadOffsetY") : 0;
|
|
this.headOffsetZ = nbt.hasKey("HeadOffsetZ") ? nbt.getDouble("HeadOffsetZ") : 0;
|
|
this.prevHeadOffsetX = this.headOffsetX;
|
|
this.prevHeadOffsetY = this.headOffsetY;
|
|
this.prevHeadOffsetZ = this.headOffsetZ;
|
|
this.attachedToOwner = !nbt.hasKey("AttachedToOwner") || nbt.getBoolean("AttachedToOwner");
|
|
this.renderTailOrb = !nbt.hasKey("RenderTailOrb") || nbt.getBoolean("RenderTailOrb");
|
|
// Read charging state and sync to data watcher
|
|
boolean isCharging = nbt.hasKey("Charging") && nbt.getBoolean("Charging");
|
|
this.charging = isCharging;
|
|
this.dataWatcher.updateObject(DW_CHARGING, (byte) (isCharging ? 1 : 0));
|
|
this.chargeDuration = nbt.hasKey("ChargeDuration") ? nbt.getInteger("ChargeDuration") : 40;
|
|
this.chargeTick = nbt.hasKey("ChargeTick") ? nbt.getInteger("ChargeTick") : 0;
|
|
this.chargeOffsetDistance = nbt.hasKey("ChargeOffsetDistance") ? nbt.getFloat("ChargeOffsetDistance") : 1.0f;
|
|
this.anchorPoint = nbt.hasKey("AnchorPoint") ? AnchorPoint.fromId(nbt.getInteger("AnchorPoint")) : AnchorPoint.FRONT;
|
|
this.fadeTrail = nbt.hasKey("FadeTrail") && nbt.getBoolean("FadeTrail");
|
|
this.trailFadeTime = nbt.hasKey("TrailFadeTime") ? nbt.getInteger("TrailFadeTime") : 20;
|
|
|
|
// Read trail points (relative to origin)
|
|
trailPoints.clear();
|
|
if (nbt.hasKey("Trail")) {
|
|
NBTTagList trailList = nbt.getTagList("Trail", 10);
|
|
for (int i = 0; i < trailList.tagCount(); i++) {
|
|
NBTTagCompound point = trailList.getCompoundTagAt(i);
|
|
trailPoints.add(Vec3.createVectorHelper(
|
|
point.getDouble("X"),
|
|
point.getDouble("Y"),
|
|
point.getDouble("Z")
|
|
));
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
protected void writeProjectileNBT(NBTTagCompound nbt) {
|
|
nbt.setFloat("Speed", speed);
|
|
nbt.setBoolean("Homing", homing);
|
|
nbt.setFloat("HomingStrength", homingStrength);
|
|
nbt.setFloat("HomingRange", homingRange);
|
|
nbt.setFloat("BeamWidth", beamWidth);
|
|
nbt.setFloat("HeadSize", headSize);
|
|
nbt.setDouble("HeadOffsetX", headOffsetX);
|
|
nbt.setDouble("HeadOffsetY", headOffsetY);
|
|
nbt.setDouble("HeadOffsetZ", headOffsetZ);
|
|
nbt.setBoolean("AttachedToOwner", attachedToOwner);
|
|
nbt.setBoolean("RenderTailOrb", renderTailOrb);
|
|
nbt.setBoolean("Charging", isCharging());
|
|
nbt.setInteger("ChargeDuration", chargeDuration);
|
|
nbt.setInteger("ChargeTick", chargeTick);
|
|
nbt.setFloat("ChargeOffsetDistance", chargeOffsetDistance);
|
|
nbt.setInteger("AnchorPoint", anchorPoint.getId());
|
|
nbt.setBoolean("FadeTrail", fadeTrail);
|
|
nbt.setInteger("TrailFadeTime", trailFadeTime);
|
|
|
|
// Write trail points
|
|
NBTTagList trailList = new NBTTagList();
|
|
for (Vec3 point : trailPoints) {
|
|
NBTTagCompound pointNbt = new NBTTagCompound();
|
|
pointNbt.setDouble("X", point.xCoord);
|
|
pointNbt.setDouble("Y", point.yCoord);
|
|
pointNbt.setDouble("Z", point.zCoord);
|
|
trailList.appendTag(pointNbt);
|
|
}
|
|
nbt.setTag("Trail", trailList);
|
|
}
|
|
}
|