mirror of
https://github.com/KAMKEEL/CustomNPC-Plus.git
synced 2026-11-13 18:24:10 +00:00
705 lines
24 KiB
Java
705 lines
24 KiB
Java
package kamkeel.npcs.entity;
|
|
|
|
import cpw.mods.fml.common.registry.IEntityAdditionalSpawnData;
|
|
import cpw.mods.fml.relauncher.Side;
|
|
import cpw.mods.fml.relauncher.SideOnly;
|
|
import io.netty.buffer.ByteBuf;
|
|
import kamkeel.npcs.controllers.data.ability.AbilityEffect;
|
|
import kamkeel.npcs.controllers.data.ability.data.EnergyColorData;
|
|
import kamkeel.npcs.controllers.data.ability.data.EnergyCombatData;
|
|
import kamkeel.npcs.controllers.data.ability.data.EnergyLifespanData;
|
|
import kamkeel.npcs.controllers.data.ability.data.EnergyLightningData;
|
|
import net.minecraft.entity.Entity;
|
|
import net.minecraft.entity.EntityLivingBase;
|
|
import net.minecraft.entity.player.EntityPlayer;
|
|
import net.minecraft.nbt.NBTTagCompound;
|
|
import net.minecraft.nbt.NBTTagList;
|
|
import net.minecraft.util.AxisAlignedBB;
|
|
import net.minecraft.util.DamageSource;
|
|
import net.minecraft.util.Vec3;
|
|
import net.minecraft.world.World;
|
|
import noppes.npcs.NpcDamageSource;
|
|
import noppes.npcs.entity.EntityNPCInterface;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
|
|
/**
|
|
* Base class for all ability projectiles (Orb, Disc, Beam, Laser).
|
|
* Provides common functionality for visuals, combat, effects, and interpolation.
|
|
*
|
|
* Design inspired by LouisXIV's energy attack system.
|
|
*/
|
|
public abstract class EntityAbilityProjectile extends Entity implements IEntityAdditionalSpawnData {
|
|
|
|
// ==================== VISUAL PROPERTIES ====================
|
|
protected float size = 1.0f;
|
|
protected int innerColor = 0xFFFFFF;
|
|
protected int outerColor = 0x8888FF;
|
|
protected boolean outerColorEnabled = true;
|
|
protected float outerColorWidth = 0.4f; // Additive offset from inner size
|
|
protected float outerColorAlpha = 0.5f;
|
|
protected float rotationSpeed = 4.0f;
|
|
|
|
// ==================== COMBAT PROPERTIES ====================
|
|
protected float damage = 7.0f;
|
|
protected float knockback = 1.0f;
|
|
protected float knockbackUp = 0.1f;
|
|
|
|
// ==================== EFFECT PROPERTIES ====================
|
|
protected List<AbilityEffect> effects = new ArrayList<>();
|
|
|
|
// ==================== EXPLOSION PROPERTIES ====================
|
|
protected boolean explosive = false;
|
|
protected float explosionRadius = 3.0f;
|
|
protected float explosionDamageFalloff = 0.5f;
|
|
|
|
// ==================== LIGHTNING EFFECT PROPERTIES ====================
|
|
protected boolean lightningEffect = false;
|
|
protected float lightningDensity = 0.15f; // Bolts spawned per tick (0.15 = ~15% chance per frame)
|
|
protected float lightningRadius = 0.5f; // Max distance lightning can arc from center
|
|
protected int lightningFadeTime = 6; // Ticks before lightning fades out
|
|
|
|
// Client-side lightning state (not saved to NBT)
|
|
@cpw.mods.fml.relauncher.SideOnly(cpw.mods.fml.relauncher.Side.CLIENT)
|
|
public transient Object lightningState; // Actually AttachedLightningRenderer.LightningState
|
|
|
|
// ==================== LIFESPAN ====================
|
|
protected float maxDistance = 30.0f;
|
|
protected int maxLifetime = 200;
|
|
protected long deathWorldTime = -1; // World time when entity should die (-1 = not set)
|
|
|
|
// ==================== TRACKING ====================
|
|
protected double startX, startY, startZ;
|
|
protected int ownerEntityId = -1;
|
|
protected int targetEntityId = -1;
|
|
|
|
// ==================== STATE ====================
|
|
protected boolean hasHit = false;
|
|
protected boolean previewMode = false; // Client-side preview mode (no damage/effects)
|
|
protected EntityLivingBase previewOwner = null; // Direct reference for GUI preview (no world lookup)
|
|
|
|
// ==================== ROTATION INTERPOLATION ====================
|
|
public float prevRotationValX, prevRotationValY, prevRotationValZ;
|
|
public float rotationValX, rotationValY, rotationValZ;
|
|
|
|
// ==================== SIZE INTERPOLATION ====================
|
|
protected float renderCurrentSize;
|
|
protected float prevRenderSize;
|
|
|
|
// ==================== POSITION INTERPOLATION ====================
|
|
protected double interpTargetX, interpTargetY, interpTargetZ;
|
|
protected double interpTargetMotionX, interpTargetMotionY, interpTargetMotionZ;
|
|
protected int interpSteps;
|
|
|
|
public EntityAbilityProjectile(World world) {
|
|
super(world);
|
|
this.setSize(0.5f, 0.5f);
|
|
this.noClip = false;
|
|
this.isImmuneToFire = true;
|
|
this.ignoreFrustumCheck = true;
|
|
}
|
|
|
|
/**
|
|
* Initialize common properties using data classes. Call from subclass constructors.
|
|
*/
|
|
protected void initProjectile(EntityLivingBase owner, EntityLivingBase target,
|
|
double x, double y, double z, float size,
|
|
EnergyColorData color, EnergyCombatData combat,
|
|
EnergyLightningData lightning, EnergyLifespanData lifespan) {
|
|
this.setPosition(x, y, z);
|
|
this.startX = x;
|
|
this.startY = y;
|
|
this.startZ = z;
|
|
|
|
this.ownerEntityId = owner.getEntityId();
|
|
this.targetEntityId = target != null ? target.getEntityId() : -1;
|
|
|
|
// Visual
|
|
this.size = size;
|
|
this.innerColor = color.innerColor;
|
|
this.outerColor = color.outerColor;
|
|
this.outerColorEnabled = color.outerColorEnabled;
|
|
this.outerColorWidth = color.outerColorWidth;
|
|
this.outerColorAlpha = color.outerColorAlpha;
|
|
this.rotationSpeed = color.rotationSpeed;
|
|
|
|
// Combat
|
|
this.damage = combat.damage;
|
|
this.knockback = combat.knockback;
|
|
this.knockbackUp = combat.knockbackUp;
|
|
|
|
// Explosion
|
|
this.explosive = combat.explosive;
|
|
this.explosionRadius = combat.explosionRadius;
|
|
this.explosionDamageFalloff = combat.explosionDamageFalloff;
|
|
|
|
// Lifespan
|
|
this.maxDistance = lifespan.maxDistance;
|
|
this.maxLifetime = lifespan.maxLifetime;
|
|
// deathWorldTime will be set on first tick when world is available
|
|
|
|
// Lightning
|
|
this.lightningEffect = lightning.lightningEffect;
|
|
this.lightningDensity = lightning.lightningDensity;
|
|
this.lightningRadius = lightning.lightningRadius;
|
|
this.lightningFadeTime = lightning.lightningFadeTime;
|
|
|
|
// Initialize render size
|
|
this.renderCurrentSize = size;
|
|
this.prevRenderSize = size;
|
|
}
|
|
|
|
@Override
|
|
protected void entityInit() {
|
|
// No DataWatcher needed - using IEntityAdditionalSpawnData with NBT
|
|
}
|
|
|
|
@Override
|
|
@SideOnly(Side.CLIENT)
|
|
public boolean isInRangeToRenderDist(double distance) {
|
|
double d1 = this.boundingBox.getAverageEdgeLength() * 4.0D;
|
|
d1 *= 128.0D;
|
|
return distance < d1 * d1;
|
|
}
|
|
|
|
@Override
|
|
public boolean shouldRenderInPass(int pass) {
|
|
return pass == 1; // Translucent pass
|
|
}
|
|
|
|
@Override
|
|
public void onUpdate() {
|
|
// Store previous values for interpolation
|
|
this.prevPosX = this.posX;
|
|
this.prevPosY = this.posY;
|
|
this.prevPosZ = this.posZ;
|
|
this.prevRotationValX = this.rotationValX;
|
|
this.prevRotationValY = this.rotationValY;
|
|
this.prevRotationValZ = this.rotationValZ;
|
|
this.prevRenderSize = this.renderCurrentSize;
|
|
|
|
// Skip super.onUpdate() in preview mode to avoid world checks
|
|
if (!previewMode) {
|
|
super.onUpdate();
|
|
}
|
|
|
|
// Update rotation
|
|
updateRotation();
|
|
|
|
// Lerp render size toward actual size
|
|
this.renderCurrentSize = this.renderCurrentSize + (this.size - this.renderCurrentSize) * 0.15f;
|
|
|
|
// Skip lifetime/distance checks in preview mode
|
|
if (!previewMode) {
|
|
// Failsafe: if owner entity is gone, dead, or NPC was killed/reset, self-destruct
|
|
if (ownerEntityId >= 0 && ticksExisted > 5) {
|
|
Entity owner = worldObj.getEntityByID(ownerEntityId);
|
|
if (owner == null || owner.isDead) {
|
|
this.setDead();
|
|
return;
|
|
}
|
|
if (owner instanceof EntityNPCInterface && ((EntityNPCInterface) owner).isKilled()) {
|
|
this.setDead();
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Set death time on first tick if not already set (handles chunk load/unload)
|
|
if (deathWorldTime < 0 && worldObj != null) {
|
|
deathWorldTime = worldObj.getTotalWorldTime() + maxLifetime;
|
|
}
|
|
|
|
// Check lifespan using world time (survives chunk unload/reload)
|
|
if (deathWorldTime > 0 && worldObj.getTotalWorldTime() >= deathWorldTime) {
|
|
this.setDead();
|
|
return;
|
|
}
|
|
|
|
// Check max distance (subclass can override if needed)
|
|
if (checkMaxDistance()) {
|
|
this.setDead();
|
|
return;
|
|
}
|
|
|
|
if (hasHit) {
|
|
this.setDead();
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Subclass-specific update
|
|
updateProjectile();
|
|
}
|
|
|
|
/**
|
|
* Update rotation values. Override for custom rotation behavior.
|
|
*/
|
|
protected void updateRotation() {
|
|
this.rotationValX += rotationSpeed * 0.7f;
|
|
this.rotationValY += rotationSpeed;
|
|
this.rotationValZ += rotationSpeed * 0.5f;
|
|
|
|
if (this.rotationValX > 360.0f) this.rotationValX -= 360.0f;
|
|
if (this.rotationValY > 360.0f) this.rotationValY -= 360.0f;
|
|
if (this.rotationValZ > 360.0f) this.rotationValZ -= 360.0f;
|
|
}
|
|
|
|
/**
|
|
* Check if projectile has exceeded max distance.
|
|
* @return true if should die
|
|
*/
|
|
protected boolean checkMaxDistance() {
|
|
double distTraveled = Math.sqrt(
|
|
(posX - startX) * (posX - startX) +
|
|
(posY - startY) * (posY - startY) +
|
|
(posZ - startZ) * (posZ - startZ)
|
|
);
|
|
return distTraveled >= maxDistance;
|
|
}
|
|
|
|
/**
|
|
* Subclass-specific update logic. Called every tick.
|
|
*/
|
|
protected abstract void updateProjectile();
|
|
|
|
// ==================== POSITION INTERPOLATION ====================
|
|
|
|
@Override
|
|
public void setPositionAndRotation2(double x, double y, double z, float yaw, float pitch, int posRotationIncrements) {
|
|
this.interpTargetX = x;
|
|
this.interpTargetY = y;
|
|
this.interpTargetZ = z;
|
|
this.interpSteps = posRotationIncrements;
|
|
}
|
|
|
|
@Override
|
|
public void setVelocity(double motionX, double motionY, double motionZ) {
|
|
this.interpTargetMotionX = motionX;
|
|
this.interpTargetMotionY = motionY;
|
|
this.interpTargetMotionZ = motionZ;
|
|
this.motionX = motionX;
|
|
this.motionY = motionY;
|
|
this.motionZ = motionZ;
|
|
}
|
|
|
|
/**
|
|
* Handle client-side position interpolation.
|
|
*/
|
|
protected void handleClientInterpolation() {
|
|
if (this.interpSteps > 0) {
|
|
double newX = this.posX + (this.interpTargetX - this.posX) / this.interpSteps;
|
|
double newY = this.posY + (this.interpTargetY - this.posY) / this.interpSteps;
|
|
double newZ = this.posZ + (this.interpTargetZ - this.posZ) / this.interpSteps;
|
|
|
|
this.motionX = this.motionX + (this.interpTargetMotionX - this.motionX) / this.interpSteps;
|
|
this.motionY = this.motionY + (this.interpTargetMotionY - this.motionY) / this.interpSteps;
|
|
this.motionZ = this.motionZ + (this.interpTargetMotionZ - this.motionZ) / this.interpSteps;
|
|
|
|
this.setPosition(newX, newY, newZ);
|
|
this.interpSteps--;
|
|
} else {
|
|
this.posX += this.motionX;
|
|
this.posY += this.motionY;
|
|
this.posZ += this.motionZ;
|
|
this.setPosition(this.posX, this.posY, this.posZ);
|
|
}
|
|
}
|
|
|
|
// ==================== PREVIEW MODE ====================
|
|
|
|
/**
|
|
* Set preview mode for GUI display.
|
|
* In preview mode, no damage or world effects are applied.
|
|
*/
|
|
public void setPreviewMode(boolean preview) {
|
|
this.previewMode = preview;
|
|
}
|
|
|
|
/**
|
|
* Check if entity is in preview mode.
|
|
*/
|
|
public boolean isPreviewMode() {
|
|
return previewMode;
|
|
}
|
|
|
|
// ==================== DAMAGE & EFFECTS ====================
|
|
|
|
protected void applyDamage(EntityLivingBase target) {
|
|
if (previewMode) return; // Skip damage in preview mode
|
|
applyDamage(target, this.damage, this.knockback);
|
|
}
|
|
|
|
protected void applyDamage(EntityLivingBase target, float dmg, float kb) {
|
|
if (previewMode) return; // Skip damage in preview mode
|
|
Entity owner = getOwner();
|
|
|
|
if (owner instanceof EntityNPCInterface) {
|
|
target.attackEntityFrom(new NpcDamageSource("npc_ability", (EntityNPCInterface) owner), dmg);
|
|
} else if (owner instanceof EntityPlayer) {
|
|
target.attackEntityFrom(DamageSource.causePlayerDamage((EntityPlayer) owner), dmg);
|
|
} else if (owner instanceof EntityLivingBase) {
|
|
target.attackEntityFrom(DamageSource.causeMobDamage((EntityLivingBase) owner), dmg);
|
|
} else {
|
|
target.attackEntityFrom(new NpcDamageSource("npc_ability", null), dmg);
|
|
}
|
|
|
|
if (kb > 0) {
|
|
double dx = target.posX - posX;
|
|
double dz = target.posZ - posZ;
|
|
double len = Math.sqrt(dx * dx + dz * dz);
|
|
if (len > 0) {
|
|
double kbX = (dx / len) * kb * 0.5;
|
|
double kbZ = (dz / len) * kb * 0.5;
|
|
double kbY = knockbackUp > 0 ? knockbackUp : 0.1;
|
|
target.addVelocity(kbX, kbY, kbZ);
|
|
target.velocityChanged = true;
|
|
}
|
|
}
|
|
|
|
applyEffects(target);
|
|
}
|
|
|
|
protected void applyEffects(EntityLivingBase target) {
|
|
for (AbilityEffect effect : effects) {
|
|
effect.apply(target);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set the effects list from the ability's configured effects.
|
|
*/
|
|
public void setEffects(List<AbilityEffect> effects) {
|
|
this.effects = effects != null ? effects : new ArrayList<>();
|
|
}
|
|
|
|
protected void doExplosion() {
|
|
if (previewMode) return; // Skip explosion in preview mode
|
|
worldObj.playSoundEffect(posX, posY, posZ, "random.explode", 1.0f, 1.0f);
|
|
|
|
Entity owner = getOwner();
|
|
|
|
AxisAlignedBB explosionBox = AxisAlignedBB.getBoundingBox(
|
|
posX - explosionRadius, posY - explosionRadius, posZ - explosionRadius,
|
|
posX + explosionRadius, posY + explosionRadius, posZ + explosionRadius
|
|
);
|
|
|
|
@SuppressWarnings("unchecked")
|
|
List<EntityLivingBase> targets = worldObj.getEntitiesWithinAABB(EntityLivingBase.class, explosionBox);
|
|
|
|
for (EntityLivingBase target : targets) {
|
|
if (target == owner) continue;
|
|
|
|
double dist = Math.sqrt(
|
|
Math.pow(target.posX - posX, 2) +
|
|
Math.pow(target.posY - posY, 2) +
|
|
Math.pow(target.posZ - posZ, 2)
|
|
);
|
|
|
|
if (dist <= explosionRadius) {
|
|
float falloff = 1.0f - (float) (dist / explosionRadius) * explosionDamageFalloff;
|
|
applyDamage(target, damage * falloff, knockback * falloff);
|
|
}
|
|
}
|
|
}
|
|
|
|
// ==================== ENTITY HELPERS ====================
|
|
|
|
public int getOwnerEntityId() {
|
|
return ownerEntityId;
|
|
}
|
|
|
|
protected Entity getOwner() {
|
|
// In preview mode, use direct reference (no world lookup)
|
|
if (previewMode && previewOwner != null) {
|
|
return previewOwner;
|
|
}
|
|
if (ownerEntityId == -1) return null;
|
|
return worldObj.getEntityByID(ownerEntityId);
|
|
}
|
|
|
|
/**
|
|
* Set the preview owner for GUI preview mode.
|
|
* This allows anchor point calculations without world entity lookup.
|
|
*/
|
|
public void setPreviewOwner(EntityLivingBase owner) {
|
|
this.previewOwner = owner;
|
|
}
|
|
|
|
protected Entity getTarget() {
|
|
if (targetEntityId == -1) return null;
|
|
return worldObj.getEntityByID(targetEntityId);
|
|
}
|
|
|
|
/**
|
|
* Check if an entity should be ignored for collision.
|
|
*/
|
|
protected boolean shouldIgnoreEntity(Entity entity) {
|
|
Entity owner = getOwner();
|
|
if (entity == owner) return true;
|
|
|
|
if (owner instanceof EntityNPCInterface && entity instanceof EntityNPCInterface) {
|
|
EntityNPCInterface ownerNpc = (EntityNPCInterface) owner;
|
|
EntityNPCInterface targetNpc = (EntityNPCInterface) entity;
|
|
if (ownerNpc.faction.id == targetNpc.faction.id) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// ==================== VISUAL GETTERS ====================
|
|
|
|
public float getSize() {
|
|
return size;
|
|
}
|
|
|
|
public int getInnerColor() {
|
|
return innerColor;
|
|
}
|
|
|
|
public int getOuterColor() {
|
|
return outerColor;
|
|
}
|
|
|
|
public boolean isOuterColorEnabled() {
|
|
return outerColorEnabled;
|
|
}
|
|
|
|
public float getOuterColorWidth() {
|
|
return outerColorWidth;
|
|
}
|
|
|
|
public float getOuterColorAlpha() {
|
|
return outerColorAlpha;
|
|
}
|
|
|
|
public float getRotationSpeed() {
|
|
return rotationSpeed;
|
|
}
|
|
|
|
public float getInterpolatedRotationX(float partialTicks) {
|
|
return this.prevRotationValX + (this.rotationValX - this.prevRotationValX) * partialTicks;
|
|
}
|
|
|
|
public float getInterpolatedRotationY(float partialTicks) {
|
|
return this.prevRotationValY + (this.rotationValY - this.prevRotationValY) * partialTicks;
|
|
}
|
|
|
|
public float getInterpolatedRotationZ(float partialTicks) {
|
|
return this.prevRotationValZ + (this.rotationValZ - this.prevRotationValZ) * partialTicks;
|
|
}
|
|
|
|
public float getInterpolatedSize(float partialTicks) {
|
|
return this.prevRenderSize + (this.renderCurrentSize - this.prevRenderSize) * partialTicks;
|
|
}
|
|
|
|
// ==================== LIGHTNING GETTERS ====================
|
|
|
|
public boolean hasLightningEffect() {
|
|
return lightningEffect;
|
|
}
|
|
|
|
public float getLightningDensity() {
|
|
return lightningDensity;
|
|
}
|
|
|
|
public float getLightningRadius() {
|
|
return lightningRadius;
|
|
}
|
|
|
|
public int getLightningFadeTime() {
|
|
return lightningFadeTime;
|
|
}
|
|
|
|
// ==================== BRIGHTNESS ====================
|
|
|
|
@Override
|
|
public float getBrightness(float partialTicks) {
|
|
return 1.0f;
|
|
}
|
|
|
|
@Override
|
|
@SideOnly(Side.CLIENT)
|
|
public int getBrightnessForRender(float partialTicks) {
|
|
return 0xF000F0;
|
|
}
|
|
|
|
// ==================== NBT ====================
|
|
|
|
@Override
|
|
protected void readEntityFromNBT(NBTTagCompound nbt) {
|
|
readBaseNBT(nbt);
|
|
readProjectileNBT(nbt);
|
|
}
|
|
|
|
@Override
|
|
protected void writeEntityToNBT(NBTTagCompound nbt) {
|
|
writeBaseNBT(nbt);
|
|
writeProjectileNBT(nbt);
|
|
}
|
|
|
|
/**
|
|
* Read base projectile properties from NBT.
|
|
*/
|
|
protected void readBaseNBT(NBTTagCompound nbt) {
|
|
this.size = nbt.getFloat("Size");
|
|
this.innerColor = nbt.getInteger("InnerColor");
|
|
this.outerColor = nbt.getInteger("OuterColor");
|
|
this.outerColorEnabled = !nbt.hasKey("OuterColorEnabled") || nbt.getBoolean("OuterColorEnabled");
|
|
this.outerColorAlpha = nbt.hasKey("OuterColorAlpha") ? nbt.getFloat("OuterColorAlpha") : 0.5f;
|
|
this.outerColorWidth = nbt.hasKey("OuterColorWidth") ? nbt.getFloat("OuterColorWidth") : 0.4f;
|
|
this.rotationSpeed = nbt.hasKey("RotationSpeed") ? nbt.getFloat("RotationSpeed") : 4.0f;
|
|
|
|
this.damage = nbt.getFloat("Damage");
|
|
this.knockback = nbt.getFloat("Knockback");
|
|
this.knockbackUp = nbt.getFloat("KnockbackUp");
|
|
|
|
this.explosive = nbt.getBoolean("Explosive");
|
|
this.explosionRadius = nbt.getFloat("ExplosionRadius");
|
|
this.explosionDamageFalloff = nbt.getFloat("ExplosionDamageFalloff");
|
|
|
|
// Read effects list
|
|
this.effects.clear();
|
|
if (nbt.hasKey("Effects")) {
|
|
NBTTagList effectsList = nbt.getTagList("Effects", 10); // 10 = compound tag
|
|
for (int i = 0; i < effectsList.tagCount(); i++) {
|
|
effects.add(AbilityEffect.fromNBT(effectsList.getCompoundTagAt(i)));
|
|
}
|
|
}
|
|
|
|
this.maxDistance = nbt.getFloat("MaxDistance");
|
|
this.maxLifetime = nbt.getInteger("MaxLifetime");
|
|
this.deathWorldTime = nbt.hasKey("DeathWorldTime") ? nbt.getLong("DeathWorldTime") : -1;
|
|
|
|
this.startX = nbt.getDouble("StartX");
|
|
this.startY = nbt.getDouble("StartY");
|
|
this.startZ = nbt.getDouble("StartZ");
|
|
|
|
this.ownerEntityId = nbt.getInteger("OwnerId");
|
|
this.targetEntityId = nbt.getInteger("TargetId");
|
|
|
|
this.motionX = nbt.getDouble("MotionX");
|
|
this.motionY = nbt.getDouble("MotionY");
|
|
this.motionZ = nbt.getDouble("MotionZ");
|
|
|
|
// Lightning
|
|
this.lightningEffect = nbt.getBoolean("LightningEffect");
|
|
this.lightningDensity = nbt.hasKey("LightningDensity") ? nbt.getFloat("LightningDensity") : 0.15f;
|
|
this.lightningRadius = nbt.hasKey("LightningRadius") ? nbt.getFloat("LightningRadius") : 0.5f;
|
|
this.lightningFadeTime = nbt.hasKey("LightningFadeTime") ? nbt.getInteger("LightningFadeTime") : 6;
|
|
|
|
if (this.worldObj != null && this.worldObj.isRemote) {
|
|
this.renderCurrentSize = this.size;
|
|
this.prevRenderSize = this.size;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Write base projectile properties to NBT.
|
|
*/
|
|
protected void writeBaseNBT(NBTTagCompound nbt) {
|
|
nbt.setFloat("Size", size);
|
|
nbt.setInteger("InnerColor", innerColor);
|
|
nbt.setInteger("OuterColor", outerColor);
|
|
nbt.setBoolean("OuterColorEnabled", outerColorEnabled);
|
|
nbt.setFloat("OuterColorWidth", outerColorWidth);
|
|
nbt.setFloat("OuterColorAlpha", outerColorAlpha);
|
|
nbt.setFloat("RotationSpeed", rotationSpeed);
|
|
|
|
nbt.setFloat("Damage", damage);
|
|
nbt.setFloat("Knockback", knockback);
|
|
nbt.setFloat("KnockbackUp", knockbackUp);
|
|
|
|
nbt.setBoolean("Explosive", explosive);
|
|
nbt.setFloat("ExplosionRadius", explosionRadius);
|
|
nbt.setFloat("ExplosionDamageFalloff", explosionDamageFalloff);
|
|
|
|
// Write effects list
|
|
if (!effects.isEmpty()) {
|
|
NBTTagList effectsList = new NBTTagList();
|
|
for (AbilityEffect effect : effects) {
|
|
effectsList.appendTag(effect.writeNBT());
|
|
}
|
|
nbt.setTag("Effects", effectsList);
|
|
}
|
|
|
|
nbt.setFloat("MaxDistance", maxDistance);
|
|
nbt.setLong("DeathWorldTime", deathWorldTime);
|
|
nbt.setInteger("MaxLifetime", maxLifetime);
|
|
|
|
nbt.setDouble("StartX", startX);
|
|
nbt.setDouble("StartY", startY);
|
|
nbt.setDouble("StartZ", startZ);
|
|
|
|
nbt.setInteger("OwnerId", ownerEntityId);
|
|
nbt.setInteger("TargetId", targetEntityId);
|
|
|
|
nbt.setDouble("MotionX", motionX);
|
|
nbt.setDouble("MotionY", motionY);
|
|
nbt.setDouble("MotionZ", motionZ);
|
|
|
|
// Lightning
|
|
nbt.setBoolean("LightningEffect", lightningEffect);
|
|
nbt.setFloat("LightningDensity", lightningDensity);
|
|
nbt.setFloat("LightningRadius", lightningRadius);
|
|
nbt.setInteger("LightningFadeTime", lightningFadeTime);
|
|
}
|
|
|
|
/**
|
|
* Subclass-specific NBT reading.
|
|
*/
|
|
protected abstract void readProjectileNBT(NBTTagCompound nbt);
|
|
|
|
/**
|
|
* Subclass-specific NBT writing.
|
|
*/
|
|
protected abstract void writeProjectileNBT(NBTTagCompound nbt);
|
|
|
|
// ==================== SPAWN DATA ====================
|
|
|
|
@Override
|
|
public void writeSpawnData(ByteBuf buffer) {
|
|
try {
|
|
NBTTagCompound compound = new NBTTagCompound();
|
|
this.writeEntityToNBT(compound);
|
|
cpw.mods.fml.common.network.ByteBufUtils.writeTag(buffer, compound);
|
|
} catch (Exception ignored) {}
|
|
}
|
|
|
|
@Override
|
|
public void readSpawnData(ByteBuf buffer) {
|
|
try {
|
|
NBTTagCompound compound = cpw.mods.fml.common.network.ByteBufUtils.readTag(buffer);
|
|
if (compound != null) {
|
|
this.readEntityFromNBT(compound);
|
|
}
|
|
} catch (Exception ignored) {}
|
|
}
|
|
|
|
// ==================== COLLISION SETTINGS ====================
|
|
|
|
@Override
|
|
public boolean canBeCollidedWith() {
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public boolean canBePushed() {
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
protected boolean canTriggerWalking() {
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public boolean isBurning() {
|
|
return false;
|
|
}
|
|
|
|
@SideOnly(Side.CLIENT)
|
|
public float getShadowSize() {
|
|
return 0.0f;
|
|
}
|
|
}
|