mirror of
https://github.com/KAMKEEL/CustomNPC-Plus.git
synced 2026-11-20 02:59:42 +00:00
Merge branch 'dev' into syntax-highlighter-unified
This commit is contained in:
commit
381da07b46
110 files changed
+7557
-1512
No files matched your search
+5
-5
@@ -2,7 +2,7 @@ package kamkeel.npcs.client.renderer;
|
||||
|
||||
import cpw.mods.fml.relauncher.Side;
|
||||
import cpw.mods.fml.relauncher.SideOnly;
|
||||
import kamkeel.npcs.entity.EntityEnergyDome;
|
||||
import kamkeel.npcs.entity.EntityAbilityDome;
|
||||
import net.minecraft.client.renderer.Tessellator;
|
||||
import net.minecraft.entity.Entity;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
@@ -13,11 +13,11 @@ import org.lwjgl.opengl.GL11;
|
||||
* Optional skybox texture rendered on the interior surface.
|
||||
*/
|
||||
@SideOnly(Side.CLIENT)
|
||||
public class RenderEnergyDome extends RenderEnergyBarrier {
|
||||
public class RenderAbilityDome extends RenderEnergyBarrier {
|
||||
|
||||
@Override
|
||||
public void doRender(Entity entity, double x, double y, double z, float yaw, float partialTicks) {
|
||||
EntityEnergyDome dome = (EntityEnergyDome) entity;
|
||||
EntityAbilityDome dome = (EntityAbilityDome) entity;
|
||||
float radius = dome.getDomeRadius();
|
||||
float healthPercent = dome.getHealthPercent();
|
||||
|
||||
@@ -34,7 +34,7 @@ public class RenderEnergyDome extends RenderEnergyBarrier {
|
||||
// Hit flash effect
|
||||
float flashAlpha = computeFlashAlpha(dome);
|
||||
|
||||
float innerScale = 0.95f;
|
||||
float innerScale = 1.0f;
|
||||
|
||||
// Render outer dome (translucent glow)
|
||||
if (dome.isOuterColorEnabled()) {
|
||||
@@ -51,7 +51,7 @@ public class RenderEnergyDome extends RenderEnergyBarrier {
|
||||
|
||||
GL11.glDepthMask(true);
|
||||
// Render inner dome (depth write enabled so inner sphere properly occludes)
|
||||
renderSphere(dome.getInnerColor(), dome.getInnerAlpha(), radius * innerScale, 8);
|
||||
renderSphere(dome.getInnerColor(), dome.getInnerAlpha() * healthPercent, radius * innerScale, 8);
|
||||
GL11.glPopMatrix();
|
||||
|
||||
restoreRenderState();
|
||||
+15
-7
@@ -2,7 +2,7 @@ package kamkeel.npcs.client.renderer;
|
||||
|
||||
import cpw.mods.fml.relauncher.Side;
|
||||
import cpw.mods.fml.relauncher.SideOnly;
|
||||
import kamkeel.npcs.entity.EntityEnergyPanel;
|
||||
import kamkeel.npcs.entity.EntityAbilityPanel;
|
||||
import net.minecraft.client.renderer.Tessellator;
|
||||
import net.minecraft.entity.Entity;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
@@ -13,17 +13,25 @@ import org.lwjgl.opengl.GL11;
|
||||
* Voxel-blocky style with inner/outer layers.
|
||||
*/
|
||||
@SideOnly(Side.CLIENT)
|
||||
public class RenderEnergyPanel extends RenderEnergyBarrier {
|
||||
public class RenderAbilityPanel extends RenderEnergyBarrier {
|
||||
|
||||
@Override
|
||||
public void doRender(Entity entity, double x, double y, double z, float yaw, float partialTicks) {
|
||||
EntityEnergyPanel panel = (EntityEnergyPanel) entity;
|
||||
EntityAbilityPanel panel = (EntityAbilityPanel) entity;
|
||||
|
||||
float width = panel.getPanelData().panelWidth;
|
||||
float height = panel.getPanelData().panelHeight;
|
||||
float panelYaw = panel.getPanelYaw();
|
||||
float healthPercent = panel.getHealthPercent();
|
||||
|
||||
// Interpolate panel yaw for smooth rotation between ticks
|
||||
float prevYaw = panel.getPrevPanelYaw();
|
||||
float currentYaw = panel.getPanelYaw();
|
||||
float yawDelta = currentYaw - prevYaw;
|
||||
// Wrap angle delta to -180..180 for shortest rotation path
|
||||
while (yawDelta > 180.0f) yawDelta -= 360.0f;
|
||||
while (yawDelta < -180.0f) yawDelta += 360.0f;
|
||||
float renderYaw = prevYaw + yawDelta * partialTicks;
|
||||
|
||||
setupRenderState();
|
||||
|
||||
GL11.glPushMatrix();
|
||||
@@ -34,8 +42,8 @@ public class RenderEnergyPanel extends RenderEnergyBarrier {
|
||||
renderAttachedLightning(panel, 0.9f, Math.max(width, height) * 0.5f);
|
||||
}
|
||||
|
||||
// Rotate panel to face the correct direction
|
||||
GL11.glRotatef(-panelYaw, 0.0f, 1.0f, 0.0f);
|
||||
// Rotate panel to face the correct direction (interpolated)
|
||||
GL11.glRotatef(-renderYaw, 0.0f, 1.0f, 0.0f);
|
||||
|
||||
// Hit flash
|
||||
float flashAlpha = computeFlashAlpha(panel);
|
||||
@@ -48,7 +56,7 @@ public class RenderEnergyPanel extends RenderEnergyBarrier {
|
||||
GL11.glPushMatrix();
|
||||
GL11.glScalef(scale, scale, scale);
|
||||
|
||||
float innerScale = 0.9f;
|
||||
float innerScale = 1.0f;
|
||||
float panelThickness = 0.1f;
|
||||
|
||||
// Render outer panel (translucent glow)
|
||||
@@ -25,6 +25,7 @@ public class RenderAbilitySweeper extends Render {
|
||||
|
||||
float beamLength = sweeper.getBeamLength();
|
||||
float beamWidth = sweeper.getBeamWidth();
|
||||
float beamHeight = sweeper.getBeamHeight();
|
||||
int innerColor = sweeper.getInnerColor();
|
||||
int outerColor = sweeper.getOuterColor();
|
||||
boolean outerColorEnabled = sweeper.isOuterColorEnabled();
|
||||
@@ -38,7 +39,7 @@ public class RenderAbilitySweeper extends Render {
|
||||
GL11.glRotatef(-angle, 0, 1, 0); // Negative for correct direction
|
||||
|
||||
// Render the beam extending in the +Z direction (like beam trail segments)
|
||||
renderBeam(beamLength, beamWidth, innerColor, outerColor, outerColorEnabled, outerColorWidth);
|
||||
renderBeam(beamLength, beamWidth, beamHeight, innerColor, outerColor, outerColorEnabled, outerColorWidth);
|
||||
|
||||
GL11.glPopMatrix();
|
||||
|
||||
@@ -71,8 +72,9 @@ public class RenderAbilitySweeper extends Render {
|
||||
* Render beam using the same style as the Beam entity trail.
|
||||
* Three layers: outer glow, middle, inner core.
|
||||
* outerColorWidth is an additive offset from inner width (consistent with other renderers).
|
||||
* Width and height control the rectangular cross-section independently.
|
||||
*/
|
||||
private void renderBeam(float length, float width, int innerColor, int outerColor,
|
||||
private void renderBeam(float length, float width, float height, int innerColor, int outerColor,
|
||||
boolean outerColorEnabled, float outerColorWidth) {
|
||||
// Extract colors
|
||||
float outerR = ((outerColor >> 16) & 0xFF) / 255.0f;
|
||||
@@ -83,37 +85,40 @@ public class RenderAbilitySweeper extends Render {
|
||||
float innerG = ((innerColor >> 8) & 0xFF) / 255.0f;
|
||||
float innerB = (innerColor & 0xFF) / 255.0f;
|
||||
|
||||
// Inner scale defines the core width (consistent with other renderers)
|
||||
// Inner scale defines the core size (consistent with other renderers)
|
||||
float innerScale = 0.6f;
|
||||
float innerWidth = width * innerScale;
|
||||
float innerHeight = height * innerScale;
|
||||
|
||||
// Render from origin (0,0,0) to (0,0,length) in local coords
|
||||
// After rotation this extends in the correct world direction
|
||||
|
||||
// Outer glow (wider, translucent) - only if enabled
|
||||
// outerColorWidth is additive offset from inner width
|
||||
// outerColorWidth is additive offset from inner size
|
||||
if (outerColorEnabled) {
|
||||
float outerWidth = innerWidth + outerColorWidth * width;
|
||||
float outerHeight = innerHeight + outerColorWidth * height;
|
||||
GL11.glDepthMask(false);
|
||||
renderBeamSegment(0, 0, 0, 0, 0, length, outerWidth, outerR, outerG, outerB, 0.3f);
|
||||
renderBeamSegment(0, 0, 0, 0, 0, length, outerWidth, outerHeight, outerR, outerG, outerB, 0.3f);
|
||||
GL11.glDepthMask(true);
|
||||
|
||||
// Middle layer (halfway between inner and outer)
|
||||
float midWidth = innerWidth + (outerWidth - innerWidth) * 0.5f;
|
||||
renderBeamSegment(0, 0, 0, 0, 0, length, midWidth, outerR, outerG, outerB, 0.6f);
|
||||
float midHeight = innerHeight + (outerHeight - innerHeight) * 0.5f;
|
||||
renderBeamSegment(0, 0, 0, 0, 0, length, midWidth, midHeight, outerR, outerG, outerB, 0.6f);
|
||||
}
|
||||
|
||||
// Inner core (solid)
|
||||
renderBeamSegment(0, 0, 0, 0, 0, length, innerWidth, innerR, innerG, innerB, 1.0f);
|
||||
renderBeamSegment(0, 0, 0, 0, 0, length, innerWidth, innerHeight, innerR, innerG, innerB, 1.0f);
|
||||
}
|
||||
|
||||
/**
|
||||
* Render a beam segment as a 3D rectangular prism.
|
||||
* Render a beam segment as a 3D rectangular prism with independent width and height.
|
||||
* Uses the same approach as RenderAbilityBeam.renderBeamRectangle.
|
||||
*/
|
||||
private void renderBeamSegment(double x1, double y1, double z1,
|
||||
double x2, double y2, double z2,
|
||||
float width, float r, float g, float b, float a) {
|
||||
float width, float height, float r, float g, float b, float a) {
|
||||
// Calculate direction
|
||||
double dx = x2 - x1;
|
||||
double dy = y2 - y1;
|
||||
@@ -151,39 +156,40 @@ public class RenderAbilitySweeper extends Render {
|
||||
double vertZ = dx * horzY - dy * horzX;
|
||||
|
||||
float halfWidth = width * 0.5f;
|
||||
float halfHeight = height * 0.5f;
|
||||
|
||||
// Calculate 8 corners of the box
|
||||
double s1x = x1 - horzX * halfWidth - vertX * halfWidth;
|
||||
double s1y = y1 - horzY * halfWidth - vertY * halfWidth;
|
||||
double s1z = z1 - horzZ * halfWidth - vertZ * halfWidth;
|
||||
// Calculate 8 corners of the box (horz scaled by halfWidth, vert scaled by halfHeight)
|
||||
double s1x = x1 - horzX * halfWidth - vertX * halfHeight;
|
||||
double s1y = y1 - horzY * halfWidth - vertY * halfHeight;
|
||||
double s1z = z1 - horzZ * halfWidth - vertZ * halfHeight;
|
||||
|
||||
double s2x = x1 + horzX * halfWidth - vertX * halfWidth;
|
||||
double s2y = y1 + horzY * halfWidth - vertY * halfWidth;
|
||||
double s2z = z1 + horzZ * halfWidth - vertZ * halfWidth;
|
||||
double s2x = x1 + horzX * halfWidth - vertX * halfHeight;
|
||||
double s2y = y1 + horzY * halfWidth - vertY * halfHeight;
|
||||
double s2z = z1 + horzZ * halfWidth - vertZ * halfHeight;
|
||||
|
||||
double s3x = x1 + horzX * halfWidth + vertX * halfWidth;
|
||||
double s3y = y1 + horzY * halfWidth + vertY * halfWidth;
|
||||
double s3z = z1 + horzZ * halfWidth + vertZ * halfWidth;
|
||||
double s3x = x1 + horzX * halfWidth + vertX * halfHeight;
|
||||
double s3y = y1 + horzY * halfWidth + vertY * halfHeight;
|
||||
double s3z = z1 + horzZ * halfWidth + vertZ * halfHeight;
|
||||
|
||||
double s4x = x1 - horzX * halfWidth + vertX * halfWidth;
|
||||
double s4y = y1 - horzY * halfWidth + vertY * halfWidth;
|
||||
double s4z = z1 - horzZ * halfWidth + vertZ * halfWidth;
|
||||
double s4x = x1 - horzX * halfWidth + vertX * halfHeight;
|
||||
double s4y = y1 - horzY * halfWidth + vertY * halfHeight;
|
||||
double s4z = z1 - horzZ * halfWidth + vertZ * halfHeight;
|
||||
|
||||
double e1x = x2 - horzX * halfWidth - vertX * halfWidth;
|
||||
double e1y = y2 - horzY * halfWidth - vertY * halfWidth;
|
||||
double e1z = z2 - horzZ * halfWidth - vertZ * halfWidth;
|
||||
double e1x = x2 - horzX * halfWidth - vertX * halfHeight;
|
||||
double e1y = y2 - horzY * halfWidth - vertY * halfHeight;
|
||||
double e1z = z2 - horzZ * halfWidth - vertZ * halfHeight;
|
||||
|
||||
double e2x = x2 + horzX * halfWidth - vertX * halfWidth;
|
||||
double e2y = y2 + horzY * halfWidth - vertY * halfWidth;
|
||||
double e2z = z2 + horzZ * halfWidth - vertZ * halfWidth;
|
||||
double e2x = x2 + horzX * halfWidth - vertX * halfHeight;
|
||||
double e2y = y2 + horzY * halfWidth - vertY * halfHeight;
|
||||
double e2z = z2 + horzZ * halfWidth - vertZ * halfHeight;
|
||||
|
||||
double e3x = x2 + horzX * halfWidth + vertX * halfWidth;
|
||||
double e3y = y2 + horzY * halfWidth + vertY * halfWidth;
|
||||
double e3z = z2 + horzZ * halfWidth + vertZ * halfWidth;
|
||||
double e3x = x2 + horzX * halfWidth + vertX * halfHeight;
|
||||
double e3y = y2 + horzY * halfWidth + vertY * halfHeight;
|
||||
double e3z = z2 + horzZ * halfWidth + vertZ * halfHeight;
|
||||
|
||||
double e4x = x2 - horzX * halfWidth + vertX * halfWidth;
|
||||
double e4y = y2 - horzY * halfWidth + vertY * halfWidth;
|
||||
double e4z = z2 - horzZ * halfWidth + vertZ * halfWidth;
|
||||
double e4x = x2 - horzX * halfWidth + vertX * halfHeight;
|
||||
double e4y = y2 - horzY * halfWidth + vertY * halfHeight;
|
||||
double e4z = z2 - horzZ * halfWidth + vertZ * halfHeight;
|
||||
|
||||
Tessellator tess = Tessellator.instance;
|
||||
tess.startDrawingQuads();
|
||||
|
||||
@@ -2,7 +2,7 @@ package kamkeel.npcs.client.renderer;
|
||||
|
||||
import cpw.mods.fml.relauncher.Side;
|
||||
import cpw.mods.fml.relauncher.SideOnly;
|
||||
import kamkeel.npcs.entity.EntityEnergyBarrier;
|
||||
import kamkeel.npcs.entity.EntityAbilityBarrier;
|
||||
|
||||
/**
|
||||
* Intermediate renderer base for energy barrier entities (Dome, Panel).
|
||||
@@ -15,7 +15,7 @@ public abstract class RenderEnergyBarrier extends RenderEnergyAbility {
|
||||
* Compute the alpha boost from a hit flash effect.
|
||||
* Flash value decays from 4 to 0, producing alpha from 0.3 to 0.
|
||||
*/
|
||||
protected float computeFlashAlpha(EntityEnergyBarrier barrier) {
|
||||
protected float computeFlashAlpha(EntityAbilityBarrier barrier) {
|
||||
byte flash = barrier.getHitFlash();
|
||||
if (flash <= 0) return 0.0f;
|
||||
return flash / 4.0f * 0.3f;
|
||||
|
||||
@@ -1,15 +1,12 @@
|
||||
package kamkeel.npcs.controllers;
|
||||
|
||||
import kamkeel.npcs.controllers.data.ability.Ability;
|
||||
import kamkeel.npcs.controllers.data.ability.AbilityPhase;
|
||||
import kamkeel.npcs.controllers.data.ability.AbilityVariant;
|
||||
import kamkeel.npcs.controllers.data.ability.ChainedAbility;
|
||||
import kamkeel.npcs.controllers.data.ability.IAbilityAction;
|
||||
import kamkeel.npcs.controllers.data.ability.IAbilityExtender;
|
||||
import kamkeel.npcs.controllers.data.ability.IAbilityFieldProvider;
|
||||
import kamkeel.npcs.controllers.data.ability.IEffectAction;
|
||||
import kamkeel.npcs.controllers.data.ability.IChainedAbilityFieldProvider;
|
||||
import kamkeel.npcs.controllers.data.ability.UserType;
|
||||
import kamkeel.npcs.controllers.data.ability.*;
|
||||
import kamkeel.npcs.controllers.data.ability.conditions.AbilityCondition;
|
||||
import kamkeel.npcs.controllers.data.ability.conditions.ConditionHPThreshold;
|
||||
import kamkeel.npcs.controllers.data.ability.conditions.ConditionHitCount;
|
||||
import kamkeel.npcs.controllers.data.ability.conditions.ConditionItem;
|
||||
import kamkeel.npcs.controllers.data.ability.conditions.ConditionHasEffect;
|
||||
import kamkeel.npcs.controllers.data.ability.conditions.ConditionQuestCompleted;
|
||||
import kamkeel.npcs.controllers.data.ability.type.AbilityCharge;
|
||||
import kamkeel.npcs.controllers.data.ability.type.AbilityCutter;
|
||||
import kamkeel.npcs.controllers.data.ability.type.AbilityDash;
|
||||
@@ -43,14 +40,7 @@ import noppes.npcs.controllers.data.PlayerData;
|
||||
import noppes.npcs.util.NBTJsonUtil;
|
||||
|
||||
import java.io.File;
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashSet;
|
||||
import java.util.LinkedHashMap;
|
||||
import java.util.LinkedHashSet;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.Set;
|
||||
import java.util.UUID;
|
||||
import java.util.*;
|
||||
import java.util.function.Predicate;
|
||||
import java.util.function.Supplier;
|
||||
import java.util.regex.Pattern;
|
||||
@@ -70,6 +60,7 @@ public class AbilityController implements IAbilityHandler {
|
||||
private final List<IAbilityFieldProvider> fieldProviders = new ArrayList<>();
|
||||
private final List<IChainedAbilityFieldProvider> chainedFieldProviders = new ArrayList<>();
|
||||
private final List<IAbilityExtender> extenders = new ArrayList<>();
|
||||
private final Map<String, Supplier<AbilityCondition>> conditionTypes = new HashMap<>();
|
||||
private final List<Predicate<EntityPlayer>> flightCheckers = new ArrayList<>();
|
||||
|
||||
// ── Legacy Migration ─────────────────────────────────────────────────────
|
||||
@@ -90,6 +81,7 @@ public class AbilityController implements IAbilityHandler {
|
||||
|
||||
public AbilityController() {
|
||||
registerBuiltinTypes();
|
||||
registerBuiltinConditionTypes();
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════════════
|
||||
@@ -132,19 +124,23 @@ public class AbilityController implements IAbilityHandler {
|
||||
|
||||
private void registerBuiltinTypes() {
|
||||
registerType("cnpc:slam", AbilitySlam::new);
|
||||
registerType("cnpc:charge", AbilityCharge::new);
|
||||
|
||||
registerType("cnpc:heavy_hit", AbilityHeavyHit::new);
|
||||
registerType("cnpc:cutter", AbilityCutter::new);
|
||||
|
||||
// registerType("cnpc:projectile", AbilityProjectile::new);
|
||||
|
||||
registerType("cnpc:sweeper", AbilitySweeper::new);
|
||||
registerType("cnpc:projectile", AbilityProjectile::new);
|
||||
registerType("cnpc:orb", AbilityOrb::new);
|
||||
registerType("cnpc:disc", AbilityDisc::new);
|
||||
registerType("cnpc:laser_shot", AbilityLaserShot::new);
|
||||
registerType("cnpc:beam", AbilityBeam::new);
|
||||
// registerType("cnpc:slicer", AbilitySlicer::new);
|
||||
|
||||
registerType("cnpc:charge", AbilityCharge::new);
|
||||
registerType("cnpc:dash", AbilityDash::new);
|
||||
registerType("cnpc:teleport", AbilityTeleport::new);
|
||||
|
||||
registerType("cnpc:vortex", AbilityVortex::new);
|
||||
registerType("cnpc:shockwave", AbilityShockwave::new);
|
||||
|
||||
@@ -157,7 +153,14 @@ public class AbilityController implements IAbilityHandler {
|
||||
registerType("cnpc:dome", AbilityDome::new);
|
||||
registerType("cnpc:wall", AbilityWall::new);
|
||||
registerType("cnpc:shield", AbilityShield::new);
|
||||
registerType("cnpc:slicer", AbilitySlicer::new);
|
||||
}
|
||||
|
||||
private void registerBuiltinConditionTypes() {
|
||||
registerCondition(ConditionHPThreshold::new);
|
||||
registerCondition(ConditionHitCount::new);
|
||||
registerCondition(ConditionItem::new);
|
||||
registerCondition(ConditionQuestCompleted::new);
|
||||
registerCondition(ConditionHasEffect::new);
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════════════
|
||||
@@ -890,6 +893,45 @@ public class AbilityController implements IAbilityHandler {
|
||||
return extenders;
|
||||
}
|
||||
|
||||
public void registerCondition(Supplier<AbilityCondition> conditionFactory) {
|
||||
AbilityCondition temp = conditionFactory.get();
|
||||
String typeId = temp.getTypeId();
|
||||
if (conditionTypes.containsKey(typeId)) {
|
||||
LogWriter.info("AbilityController: Overwriting Condition type: " + typeId);
|
||||
}
|
||||
conditionTypes.put(typeId, conditionFactory);
|
||||
}
|
||||
|
||||
public Supplier<AbilityCondition> getConditionType(String key) {
|
||||
return conditionTypes.get(key);
|
||||
}
|
||||
|
||||
public String[] getConditionTypes() {
|
||||
return conditionTypes.keySet().toArray(new String[0]);
|
||||
}
|
||||
|
||||
public List<String> getConditionNamespaces() {
|
||||
LinkedHashSet<String> seen = new LinkedHashSet<>();
|
||||
for (String typeId : conditionTypes.keySet()) {
|
||||
String[] parts = typeId.split("\\.", 3);
|
||||
if (parts.length >= 2) {
|
||||
seen.add(parts[1]);
|
||||
}
|
||||
}
|
||||
return new ArrayList<>(seen);
|
||||
}
|
||||
|
||||
public String[] getConditionTypesByNamespace(String namespace) {
|
||||
String prefix = "condition." + namespace + ".";
|
||||
List<String> result = new ArrayList<>();
|
||||
for (String typeId : conditionTypes.keySet()) {
|
||||
if (typeId.startsWith(prefix)) {
|
||||
result.add(typeId);
|
||||
}
|
||||
}
|
||||
return result.toArray(new String[0]);
|
||||
}
|
||||
|
||||
public void registerFlightChecker(Predicate<EntityPlayer> checker) {
|
||||
flightCheckers.add(checker);
|
||||
}
|
||||
@@ -952,6 +994,40 @@ public class AbilityController implements IAbilityHandler {
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Fire modifyProjectileDamage on all extenders. Cumulative — each extender's output feeds the next.
|
||||
*/
|
||||
public float fireModifyProjectileDamage(Ability ability, EntityLivingBase caster, float baseDamage) {
|
||||
float damage = baseDamage;
|
||||
for (IAbilityExtender ext : extenders) {
|
||||
damage = ext.modifyProjectileDamage(ability, caster, damage);
|
||||
}
|
||||
return damage;
|
||||
}
|
||||
|
||||
/**
|
||||
* Fire modifyBarrierHealth on all extenders. Cumulative — each extender's output feeds the next.
|
||||
*/
|
||||
public float fireModifyBarrierHealth(Ability ability, EntityLivingBase caster, float baseHealth) {
|
||||
float health = baseHealth;
|
||||
for (IAbilityExtender ext : extenders) {
|
||||
health = ext.modifyBarrierHealth(ability, caster, health);
|
||||
}
|
||||
return health;
|
||||
}
|
||||
|
||||
/**
|
||||
* Fire onAbilityHeal on all extenders. Chain of responsibility — first true wins.
|
||||
*/
|
||||
public boolean fireOnAbilityHeal(Ability ability, EntityLivingBase caster, EntityLivingBase target, float healAmount) {
|
||||
for (IAbilityExtender ext : extenders) {
|
||||
if (ext.onAbilityHeal(ability, caster, target, healAmount)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════════════
|
||||
// IAbilityHandler
|
||||
// ═══════════════════════════════════════════════════════════════════════════
|
||||
|
||||
@@ -3,9 +3,13 @@ package kamkeel.npcs.controllers.data.ability;
|
||||
import cpw.mods.fml.relauncher.Side;
|
||||
import cpw.mods.fml.relauncher.SideOnly;
|
||||
import kamkeel.npcs.controllers.AbilityController;
|
||||
import kamkeel.npcs.controllers.data.ability.conditions.AbilityCondition;
|
||||
import kamkeel.npcs.controllers.data.telegraph.Telegraph;
|
||||
import kamkeel.npcs.controllers.data.telegraph.TelegraphInstance;
|
||||
import kamkeel.npcs.controllers.data.telegraph.TelegraphType;
|
||||
import kamkeel.npcs.entity.EntityAbilityBarrier;
|
||||
import kamkeel.npcs.entity.EntityAbilityDome;
|
||||
import kamkeel.npcs.entity.EntityAbilityPanel;
|
||||
import net.minecraft.block.Block;
|
||||
import net.minecraft.entity.Entity;
|
||||
import net.minecraft.entity.EntityLivingBase;
|
||||
@@ -15,7 +19,9 @@ import net.minecraft.nbt.NBTTagList;
|
||||
import net.minecraft.nbt.NBTTagString;
|
||||
import net.minecraft.util.AxisAlignedBB;
|
||||
import net.minecraft.util.DamageSource;
|
||||
import net.minecraft.util.MovingObjectPosition;
|
||||
import net.minecraft.util.StatCollector;
|
||||
import net.minecraft.util.Vec3;
|
||||
import net.minecraft.world.World;
|
||||
import noppes.npcs.DataAbilities;
|
||||
import noppes.npcs.NpcDamageSource;
|
||||
@@ -53,7 +59,7 @@ public abstract class Ability implements IAbility, IAbilityAction {
|
||||
// Selection
|
||||
protected int weight = 10;
|
||||
protected boolean enabled = true;
|
||||
protected List<Condition> conditions = new ArrayList<>();
|
||||
protected List<AbilityCondition> conditions = new ArrayList<>();
|
||||
|
||||
// Targeting
|
||||
protected TargetingMode targetingMode = TargetingMode.AGGRO_TARGET;
|
||||
@@ -104,6 +110,14 @@ public abstract class Ability implements IAbility, IAbilityAction {
|
||||
// Cooldown override
|
||||
protected boolean ignoreCooldown = false;
|
||||
|
||||
// Per-ability cooldown: if true, this ability has its own independent cooldown
|
||||
// instead of sharing the global cooldown with other abilities
|
||||
protected boolean perAbilityCooldown = false;
|
||||
|
||||
// Free on Cast: if true, ability enters cooldown immediately after entities are spawned,
|
||||
// allowing the caster to use other abilities while summoned entities remain active
|
||||
protected boolean freeOnCast = false;
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
// BUILT-IN (set in constructor via configureAsBuiltIn, NOT persisted)
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
@@ -245,6 +259,22 @@ public abstract class Ability implements IAbility, IAbilityAction {
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Whether this ability type supports the Free on Cast option.
|
||||
* Override to return true for abilities that spawn persistent entities (projectiles, barriers, zones, sweeper).
|
||||
*/
|
||||
public boolean allowFreeOnCast() {
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Detach all spawned entities (let them live independently) without killing them.
|
||||
* Called during signalCompletion() when freeOnCast is enabled.
|
||||
* Override in subclasses to null entity references without calling setDead().
|
||||
*/
|
||||
public void detach() {
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
// TOGGLE CALLBACKS (optional overrides for toggleable abilities)
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
@@ -598,8 +628,14 @@ public abstract class Ability implements IAbility, IAbilityAction {
|
||||
FieldDef.boolField("ability.syncWindup", this::isSyncWindupWithAnimation, this::setSyncWindupWithAnimation)
|
||||
.hover("ability.hover.sync")
|
||||
).tab("General").visibleWhen(() -> hasWindUpAnimation() && isSyncWindupWithAnimation()));
|
||||
defs.add(FieldDef.intField("ability.cooldownTicks", this::getCooldownTicks, this::setCooldownTicks)
|
||||
.tab("General").range(0, 10000));
|
||||
defs.add(FieldDef.row(
|
||||
FieldDef.intField("ability.cooldownTicks", this::getCooldownTicks, this::setCooldownTicks).range(0, 10000),
|
||||
FieldDef.boolField("ability.perAbilityCooldown", this::isPerAbilityCooldown, this::setPerAbilityCooldown)
|
||||
).tab("General"));
|
||||
if (allowFreeOnCast()) {
|
||||
defs.add(FieldDef.boolField("ability.freeOnCast", this::isFreeOnCast, this::setFreeOnCast)
|
||||
.tab("General").hover("ability.hover.freeOnCast"));
|
||||
}
|
||||
defs.add(FieldDef.section("ability.section.movement").tab("General"));
|
||||
defs.add(FieldDef.stringEnumField("ability.lockMovement", LockMovementType.getDisplayKeys(),
|
||||
() -> this.getLockMovement().getDisplayKey(),
|
||||
@@ -734,6 +770,25 @@ public abstract class Ability implements IAbility, IAbilityAction {
|
||||
}
|
||||
}
|
||||
|
||||
// ── Icon tab (native) ─────────────────────────────────────
|
||||
if (!isNpcInlineEdit()) {
|
||||
AbilityIconData icon = AbilityIconData.fromAbility(this);
|
||||
defs.add(FieldDef.stringField("gui.texture", icon::getTexture, icon::setTexture)
|
||||
.tab("Icon"));
|
||||
defs.add(FieldDef.section("ability.icon.section.uv").tab("Icon"));
|
||||
defs.add(FieldDef.intField("ability.icon.x", icon::getIconX, icon::setIconX)
|
||||
.tab("Icon").range(0, 4096));
|
||||
defs.add(FieldDef.intField("ability.icon.y", icon::getIconY, icon::setIconY)
|
||||
.tab("Icon").range(0, 4096));
|
||||
defs.add(FieldDef.section("gui.size").tab("Icon"));
|
||||
defs.add(FieldDef.intField("gui.width", icon::getWidth, icon::setWidth)
|
||||
.tab("Icon").range(1, 256));
|
||||
defs.add(FieldDef.intField("gui.height", icon::getHeight, icon::setHeight)
|
||||
.tab("Icon").range(1, 256));
|
||||
defs.add(FieldDef.floatField("gui.scale", icon::getScale, icon::setScale)
|
||||
.tab("Icon").range(0.1f, 10.0f));
|
||||
}
|
||||
|
||||
// External field providers (e.g., DBC Addon injecting a "DBC" tab)
|
||||
for (IAbilityFieldProvider provider : AbilityController.Instance.getFieldProviders()) {
|
||||
provider.addFieldDefinitions(this, defs);
|
||||
@@ -832,11 +887,17 @@ public abstract class Ability implements IAbility, IAbilityAction {
|
||||
// AOE_SELF abilities: telegraph follows caster during windup
|
||||
instance.setEntityIdToFollow(caster.getEntityId());
|
||||
|
||||
// For LINE/CONE telegraphs: track target direction during windup
|
||||
// For LINE/CONE telegraphs: track direction during windup
|
||||
// Only track if rotation is NOT locked during windup (NPC can still turn)
|
||||
if ((telegraphType == TelegraphType.LINE || telegraphType == TelegraphType.CONE) && target != null) {
|
||||
if (telegraphType == TelegraphType.LINE || telegraphType == TelegraphType.CONE) {
|
||||
if (!isRotationLockedDuringWindup()) {
|
||||
instance.setTargetEntityId(target.getEntityId());
|
||||
if (target != null) {
|
||||
// Face the target entity
|
||||
instance.setTargetEntityId(target.getEntityId());
|
||||
} else {
|
||||
// No target (AOE_SELF etc.): track caster's own rotationYaw
|
||||
instance.setTrackFollowedEntityYaw(true);
|
||||
}
|
||||
}
|
||||
// If rotation is locked, yaw stays fixed at creation time
|
||||
}
|
||||
@@ -1035,7 +1096,12 @@ public abstract class Ability implements IAbility, IAbilityAction {
|
||||
|
||||
// Final completion - let burst entities die naturally (don't force-kill)
|
||||
burstEntities.clear();
|
||||
cleanup();
|
||||
if (freeOnCast) {
|
||||
// Free on Cast: detach entities (let them live independently) instead of killing
|
||||
detach();
|
||||
} else {
|
||||
cleanup();
|
||||
}
|
||||
phase = AbilityPhase.IDLE;
|
||||
currentTick = 0;
|
||||
return true;
|
||||
@@ -1064,6 +1130,20 @@ public abstract class Ability implements IAbility, IAbilityAction {
|
||||
telegraphInstances.clear();
|
||||
}
|
||||
|
||||
/**
|
||||
* Cancel this ability (voluntary player action). Goes directly to IDLE, skipping DAZED.
|
||||
* Entities are killed via cleanup(). Unlike interrupt(), this never enters DAZED phase.
|
||||
*/
|
||||
public void cancel() {
|
||||
cleanupBurstEntities();
|
||||
cleanup();
|
||||
phase = AbilityPhase.IDLE;
|
||||
currentTick = 0;
|
||||
burstIndex = 0;
|
||||
currentTarget = null;
|
||||
telegraphInstances.clear();
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if executing
|
||||
*/
|
||||
@@ -1201,7 +1281,8 @@ public abstract class Ability implements IAbility, IAbilityAction {
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
|
||||
public boolean checkConditions(EntityLivingBase caster, EntityLivingBase target) {
|
||||
for (Condition c : conditions) {
|
||||
for (AbilityCondition c : conditions) {
|
||||
if (!c.getUserType().allowsNpc()) continue;
|
||||
if (!c.check(caster, target)) return false;
|
||||
}
|
||||
return true;
|
||||
@@ -1211,7 +1292,8 @@ public abstract class Ability implements IAbility, IAbilityAction {
|
||||
* Check conditions for a player caster, skipping target-requiring conditions.
|
||||
*/
|
||||
public boolean checkConditionsForPlayer(EntityLivingBase caster) {
|
||||
for (Condition c : conditions) {
|
||||
for (AbilityCondition c : conditions) {
|
||||
if (!c.getUserType().allowsPlayer()) continue;
|
||||
if (c.requiresTarget()) continue;
|
||||
if (!c.check(caster, null)) return false;
|
||||
}
|
||||
@@ -1258,6 +1340,8 @@ public abstract class Ability implements IAbility, IAbilityAction {
|
||||
nbt.setTag("customData", (NBTTagCompound) customData.copy());
|
||||
nbt.setInteger("allowedBy", allowedBy.ordinal());
|
||||
nbt.setBoolean("ignoreCooldown", ignoreCooldown);
|
||||
nbt.setBoolean("perAbilityCooldown", perAbilityCooldown);
|
||||
nbt.setBoolean("freeOnCast", freeOnCast);
|
||||
|
||||
// Toggle
|
||||
nbt.setInteger("toggleStates", toggleStates);
|
||||
@@ -1279,7 +1363,7 @@ public abstract class Ability implements IAbility, IAbilityAction {
|
||||
|
||||
// Conditions
|
||||
NBTTagList condList = new NBTTagList();
|
||||
for (Condition c : conditions) condList.appendTag(c.writeNBT());
|
||||
for (AbilityCondition c : conditions) condList.appendTag(c.writeNBT());
|
||||
nbt.setTag("conditions", condList);
|
||||
|
||||
// Effects
|
||||
@@ -1325,7 +1409,7 @@ public abstract class Ability implements IAbility, IAbilityAction {
|
||||
activeSound = nbt.getString("activeSound");
|
||||
windUpAnimationId = nbt.getInteger("windUpAnimationId");
|
||||
activeAnimationId = nbt.getInteger("activeAnimationId");
|
||||
dazedAnimationId = nbt.getInteger("dazedAnimationId");
|
||||
dazedAnimationId = nbt.hasKey("dazedAnimationId") ? nbt.getInteger("dazedAnimationId") : -1;
|
||||
windUpAnimationName = nbt.getString("windUpAnimationName");
|
||||
activeAnimationName = nbt.getString("activeAnimationName");
|
||||
dazedAnimationName = nbt.getString("dazedAnimationName");
|
||||
@@ -1339,6 +1423,8 @@ public abstract class Ability implements IAbility, IAbilityAction {
|
||||
customData = nbt.getCompoundTag("customData");
|
||||
allowedBy = UserType.fromOrdinal(nbt.getInteger("allowedBy"));
|
||||
ignoreCooldown = nbt.getBoolean("ignoreCooldown");
|
||||
perAbilityCooldown = nbt.getBoolean("perAbilityCooldown");
|
||||
freeOnCast = nbt.getBoolean("freeOnCast");
|
||||
|
||||
// Toggle
|
||||
toggleStates = nbt.getInteger("toggleStates");
|
||||
@@ -1365,7 +1451,7 @@ public abstract class Ability implements IAbility, IAbilityAction {
|
||||
conditions.clear();
|
||||
NBTTagList condList = nbt.getTagList("conditions", 10);
|
||||
for (int i = 0; i < condList.tagCount(); i++) {
|
||||
Condition c = Condition.fromNBT(condList.getCompoundTagAt(i));
|
||||
AbilityCondition c = AbilityCondition.fromNBT(condList.getCompoundTagAt(i));
|
||||
if (c != null) conditions.add(c);
|
||||
}
|
||||
|
||||
@@ -1903,11 +1989,11 @@ public abstract class Ability implements IAbility, IAbilityAction {
|
||||
return customData;
|
||||
}
|
||||
|
||||
public List<Condition> getConditions() {
|
||||
public List<AbilityCondition> getConditions() {
|
||||
return conditions;
|
||||
}
|
||||
|
||||
public void addCondition(Condition c) {
|
||||
public void addCondition(AbilityCondition c) {
|
||||
conditions.add(c);
|
||||
}
|
||||
|
||||
@@ -1927,6 +2013,22 @@ public abstract class Ability implements IAbility, IAbilityAction {
|
||||
this.ignoreCooldown = ignoreCooldown;
|
||||
}
|
||||
|
||||
public boolean isPerAbilityCooldown() {
|
||||
return perAbilityCooldown;
|
||||
}
|
||||
|
||||
public void setPerAbilityCooldown(boolean perAbilityCooldown) {
|
||||
this.perAbilityCooldown = perAbilityCooldown;
|
||||
}
|
||||
|
||||
public boolean isFreeOnCast() {
|
||||
return freeOnCast;
|
||||
}
|
||||
|
||||
public void setFreeOnCast(boolean freeOnCast) {
|
||||
this.freeOnCast = freeOnCast;
|
||||
}
|
||||
|
||||
public boolean isToggleable() {
|
||||
return toggleStates > 0;
|
||||
}
|
||||
@@ -2125,6 +2227,134 @@ public abstract class Ability implements IAbility, IAbilityAction {
|
||||
return false;
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
// LINE-OF-SIGHT UTILITIES
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
|
||||
/**
|
||||
* Check if there is a clear line of sight (no solid blocks) between caster and target.
|
||||
* Raycasts from caster's eye position to target's body center.
|
||||
*
|
||||
* @return true if there IS line of sight (no blocks in the way)
|
||||
*/
|
||||
public static boolean hasLineOfSight(World world, EntityLivingBase caster, EntityLivingBase target) {
|
||||
Vec3 start = Vec3.createVectorHelper(caster.posX, caster.posY + caster.getEyeHeight(), caster.posZ);
|
||||
Vec3 end = Vec3.createVectorHelper(target.posX, target.posY + target.height * 0.5, target.posZ);
|
||||
MovingObjectPosition result = world.rayTraceBlocks(start, end);
|
||||
return result == null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if an enemy barrier (dome or panel) blocks the line between caster and target.
|
||||
* Barriers owned by the caster or allies of the caster are not considered blocking.
|
||||
*
|
||||
* @return true if an enemy barrier blocks the attack
|
||||
*/
|
||||
@SuppressWarnings("unchecked")
|
||||
public static boolean isBlockedByBarrier(World world, EntityLivingBase caster, EntityLivingBase target) {
|
||||
// Barrier entities have tiny Minecraft bounding boxes (1x1 for domes, 0.5x0.5 for panels)
|
||||
// but their actual collision geometry extends up to MAX_ENTITY_RADIUS (50) blocks.
|
||||
// Must expand search to match EntityEnergyProjectile.checkBarrierCollision() pattern.
|
||||
double searchRange = 55.0; // MAX_ENTITY_RADIUS(50) + 5
|
||||
double minX = Math.min(caster.posX, target.posX) - searchRange;
|
||||
double minY = Math.min(caster.posY, target.posY) - searchRange;
|
||||
double minZ = Math.min(caster.posZ, target.posZ) - searchRange;
|
||||
double maxX = Math.max(caster.posX, target.posX) + searchRange;
|
||||
double maxY = Math.max(caster.posY, target.posY) + searchRange;
|
||||
double maxZ = Math.max(caster.posZ, target.posZ) + searchRange;
|
||||
|
||||
AxisAlignedBB searchBox = AxisAlignedBB.getBoundingBox(minX, minY, minZ, maxX, maxY, maxZ);
|
||||
List<EntityAbilityBarrier> barriers = world.getEntitiesWithinAABB(EntityAbilityBarrier.class, searchBox);
|
||||
|
||||
for (EntityAbilityBarrier barrier : barriers) {
|
||||
if (barrier.isDead) continue;
|
||||
if (barrier.isCharging()) continue;
|
||||
|
||||
// Skip barriers owned by caster or allies
|
||||
if (barrier.getOwnerEntityId() == caster.getEntityId()) continue;
|
||||
Entity barrierOwner = barrier.getOwnerEntity();
|
||||
if (barrierOwner instanceof EntityLivingBase) {
|
||||
if (AbilityTargetHelper.isAlly(caster, (EntityLivingBase) barrierOwner)) continue;
|
||||
}
|
||||
|
||||
if (barrier instanceof EntityAbilityDome) {
|
||||
if (isDomeBlocking((EntityAbilityDome) barrier, caster, target)) return true;
|
||||
} else if (barrier instanceof EntityAbilityPanel) {
|
||||
if (isPanelBlocking((EntityAbilityPanel) barrier, caster, target)) return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if a dome blocks an attack from caster to target.
|
||||
* Blocks when caster is outside and target is inside the dome.
|
||||
*/
|
||||
private static boolean isDomeBlocking(EntityAbilityDome dome, EntityLivingBase caster, EntityLivingBase target) {
|
||||
float radius = dome.getDomeRadius();
|
||||
|
||||
double cdx = caster.posX - dome.posX;
|
||||
double cdy = (caster.posY + caster.getEyeHeight()) - dome.posY;
|
||||
double cdz = caster.posZ - dome.posZ;
|
||||
double casterDist = Math.sqrt(cdx * cdx + cdy * cdy + cdz * cdz);
|
||||
|
||||
double tdx = target.posX - dome.posX;
|
||||
double tdy = (target.posY + target.height * 0.5) - dome.posY;
|
||||
double tdz = target.posZ - dome.posZ;
|
||||
double targetDist = Math.sqrt(tdx * tdx + tdy * tdy + tdz * tdz);
|
||||
|
||||
// Block when caster is outside and target is inside
|
||||
return casterDist > radius && targetDist < radius;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if a panel blocks an attack from caster to target.
|
||||
* Checks if the line from caster to target crosses through the panel bounds.
|
||||
*/
|
||||
private static boolean isPanelBlocking(EntityAbilityPanel panel, EntityLivingBase caster, EntityLivingBase target) {
|
||||
float halfW = panel.getPanelData().panelWidth * 0.5f;
|
||||
float halfH = panel.getPanelData().panelHeight * 0.5f;
|
||||
|
||||
// Panel normal direction
|
||||
float yawRad = (float) Math.toRadians(panel.getPanelYaw());
|
||||
double normalX = -Math.sin(yawRad);
|
||||
double normalZ = Math.cos(yawRad);
|
||||
|
||||
// Line from caster to target
|
||||
double startX = caster.posX;
|
||||
double startY = caster.posY + caster.getEyeHeight();
|
||||
double startZ = caster.posZ;
|
||||
double dx = target.posX - startX;
|
||||
double dy = (target.posY + target.height * 0.5) - startY;
|
||||
double dz = target.posZ - startZ;
|
||||
|
||||
// Dot product of line direction with panel normal
|
||||
double denom = dx * normalX + dz * normalZ;
|
||||
if (Math.abs(denom) < 0.0001) return false; // Line parallel to panel
|
||||
|
||||
// Parameter t where line crosses panel plane
|
||||
double relX = panel.posX - startX;
|
||||
double relZ = panel.posZ - startZ;
|
||||
double t = (relX * normalX + relZ * normalZ) / denom;
|
||||
|
||||
if (t < 0 || t > 1) return false; // Intersection outside the line segment
|
||||
|
||||
// Calculate intersection point
|
||||
double hitX = startX + dx * t;
|
||||
double hitY = startY + dy * t;
|
||||
double hitZ = startZ + dz * t;
|
||||
|
||||
// Transform to panel local space (right axis)
|
||||
double cos = Math.cos(yawRad);
|
||||
double sin = Math.sin(yawRad);
|
||||
double localRight = (hitX - panel.posX) * cos + (hitZ - panel.posZ) * sin;
|
||||
double localUp = hitY - panel.posY;
|
||||
|
||||
// Check bounds
|
||||
return Math.abs(localRight) <= halfW && Math.abs(localUp) <= halfH;
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
// IAbility API METHODS
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
|
||||
@@ -5,7 +5,7 @@ import net.minecraft.nbt.NBTTagCompound;
|
||||
|
||||
/**
|
||||
* Unified slot for storing any combat action: inline ability, ability reference, or chain reference.
|
||||
* Replaces {@link AbilitySlot} with support for all {@link IAbilityAction} types.
|
||||
* Support for all {@link IAbilityAction} types.
|
||||
* <p>
|
||||
* References are lazy-resolved via their respective controllers and cached until
|
||||
* the controller revision changes.
|
||||
|
||||
@@ -0,0 +1,202 @@
|
||||
package kamkeel.npcs.controllers.data.ability;
|
||||
|
||||
import net.minecraft.nbt.NBTTagCompound;
|
||||
import net.minecraft.nbt.NBTTagList;
|
||||
|
||||
/**
|
||||
* Icon data for abilities, stored in the ability's customData NBT under "AbilityIcon".
|
||||
* Used to render ability icons in the Ability Hotbar, Wheel, and Abilities Tab.
|
||||
*/
|
||||
public class AbilityIconData {
|
||||
public static final String NBT_KEY = "AbilityIcon";
|
||||
|
||||
private final NBTTagCompound customData;
|
||||
|
||||
// Icon properties
|
||||
public String texture = "";
|
||||
public int iconX = 0;
|
||||
public int iconY = 0;
|
||||
public int width = 32;
|
||||
public int height = 32;
|
||||
public float scale = 1.0f;
|
||||
|
||||
/** Per-state icon UV overrides (0-indexed, maps to toggle states 1, 2, ...). */
|
||||
private int[][] stateIcons = null;
|
||||
|
||||
private AbilityIconData(NBTTagCompound customData) {
|
||||
this.customData = customData;
|
||||
}
|
||||
|
||||
/**
|
||||
* Create an AbilityIconData instance from a raw customData compound.
|
||||
* Reads existing values if present, otherwise uses defaults.
|
||||
*/
|
||||
public static AbilityIconData fromCustomData(NBTTagCompound customData) {
|
||||
AbilityIconData icon = new AbilityIconData(customData);
|
||||
if (customData.hasKey(NBT_KEY)) {
|
||||
icon.readFromNBT(customData.getCompoundTag(NBT_KEY));
|
||||
}
|
||||
return icon;
|
||||
}
|
||||
|
||||
/**
|
||||
* Create an AbilityIconData instance from an ability's customData.
|
||||
*/
|
||||
public static AbilityIconData fromAbility(Ability ability) {
|
||||
return fromCustomData(ability.getCustomData());
|
||||
}
|
||||
|
||||
/**
|
||||
* Create an AbilityIconData instance from a chained ability's customData.
|
||||
*/
|
||||
public static AbilityIconData fromChainedAbility(ChainedAbility chain) {
|
||||
return fromCustomData(chain.getCustomData());
|
||||
}
|
||||
|
||||
/**
|
||||
* Write current state back to the customData NBT.
|
||||
*/
|
||||
public void save() {
|
||||
NBTTagCompound tag = new NBTTagCompound();
|
||||
writeToNBT(tag);
|
||||
customData.setTag(NBT_KEY, tag);
|
||||
}
|
||||
|
||||
public void writeToNBT(NBTTagCompound nbt) {
|
||||
nbt.setString("Texture", texture);
|
||||
nbt.setInteger("IconX", iconX);
|
||||
nbt.setInteger("IconY", iconY);
|
||||
nbt.setInteger("Width", width);
|
||||
nbt.setInteger("Height", height);
|
||||
nbt.setFloat("Scale", scale);
|
||||
if (stateIcons != null && stateIcons.length > 0) {
|
||||
NBTTagList list = new NBTTagList();
|
||||
for (int[] pair : stateIcons) {
|
||||
NBTTagCompound comp = new NBTTagCompound();
|
||||
comp.setInteger("IconX", pair[0]);
|
||||
comp.setInteger("IconY", pair[1]);
|
||||
list.appendTag(comp);
|
||||
}
|
||||
nbt.setTag("StateIcons", list);
|
||||
}
|
||||
}
|
||||
|
||||
public void readFromNBT(NBTTagCompound nbt) {
|
||||
texture = nbt.getString("Texture");
|
||||
iconX = nbt.getInteger("IconX");
|
||||
iconY = nbt.getInteger("IconY");
|
||||
width = nbt.getInteger("Width");
|
||||
if (width <= 0) width = 32;
|
||||
height = nbt.getInteger("Height");
|
||||
if (height <= 0) height = 32;
|
||||
scale = nbt.getFloat("Scale");
|
||||
if (scale <= 0) scale = 1.0f;
|
||||
if (nbt.hasKey("StateIcons")) {
|
||||
NBTTagList list = nbt.getTagList("StateIcons", 10);
|
||||
stateIcons = new int[list.tagCount()][2];
|
||||
for (int i = 0; i < list.tagCount(); i++) {
|
||||
NBTTagCompound comp = list.getCompoundTagAt(i);
|
||||
stateIcons[i][0] = comp.getInteger("IconX");
|
||||
stateIcons[i][1] = comp.getInteger("IconY");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if this icon has a valid texture configured.
|
||||
*/
|
||||
public boolean hasTexture() {
|
||||
return texture != null && !texture.isEmpty();
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
// GETTERS AND SETTERS (with auto-save)
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
|
||||
public String getTexture() {
|
||||
return texture;
|
||||
}
|
||||
|
||||
public void setTexture(String texture) {
|
||||
this.texture = texture != null ? texture : "";
|
||||
save();
|
||||
}
|
||||
|
||||
public int getIconX() {
|
||||
return iconX;
|
||||
}
|
||||
|
||||
public void setIconX(int iconX) {
|
||||
this.iconX = Math.max(0, iconX);
|
||||
save();
|
||||
}
|
||||
|
||||
public int getIconY() {
|
||||
return iconY;
|
||||
}
|
||||
|
||||
public void setIconY(int iconY) {
|
||||
this.iconY = Math.max(0, iconY);
|
||||
save();
|
||||
}
|
||||
|
||||
public int getWidth() {
|
||||
return width;
|
||||
}
|
||||
|
||||
public void setWidth(int width) {
|
||||
this.width = Math.max(1, width);
|
||||
save();
|
||||
}
|
||||
|
||||
public int getHeight() {
|
||||
return height;
|
||||
}
|
||||
|
||||
public void setHeight(int height) {
|
||||
this.height = Math.max(1, height);
|
||||
save();
|
||||
}
|
||||
|
||||
public float getScale() {
|
||||
return scale;
|
||||
}
|
||||
|
||||
public void setScale(float scale) {
|
||||
this.scale = Math.max(0.1f, scale);
|
||||
save();
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
// PER-STATE ICON OVERRIDES
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
|
||||
public void setStateIcons(int[][] stateIcons) {
|
||||
this.stateIcons = stateIcons;
|
||||
save();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get iconX for a specific toggle state.
|
||||
* Falls back to default iconX if no state override exists.
|
||||
* @param state 1-indexed toggle state (0 = off/default)
|
||||
*/
|
||||
public int getIconXForState(int state) {
|
||||
if (state > 0 && stateIcons != null && state - 1 < stateIcons.length) {
|
||||
return stateIcons[state - 1][0];
|
||||
}
|
||||
return iconX;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get iconY for a specific toggle state.
|
||||
* Falls back to default iconY if no state override exists.
|
||||
* @param state 1-indexed toggle state (0 = off/default)
|
||||
*/
|
||||
public int getIconYForState(int state) {
|
||||
if (state > 0 && stateIcons != null && state - 1 < stateIcons.length) {
|
||||
return stateIcons[state - 1][1];
|
||||
}
|
||||
return iconY;
|
||||
}
|
||||
}
|
||||
@@ -1,163 +0,0 @@
|
||||
package kamkeel.npcs.controllers.data.ability;
|
||||
|
||||
import kamkeel.npcs.controllers.AbilityController;
|
||||
import net.minecraft.nbt.NBTTagCompound;
|
||||
|
||||
/**
|
||||
* Wrapper that stores either an inline ability (full NBT) or a reference
|
||||
* to a built-in/custom ability (by name or UUID).
|
||||
* <p>
|
||||
* References are lazy-resolved via {@link AbilityController#resolveAbility(String)}
|
||||
* and cached until the controller version changes.
|
||||
*
|
||||
* @deprecated Use {@link AbilityAction} instead, which supports abilities and chained abilities.
|
||||
*/
|
||||
@Deprecated
|
||||
public class AbilitySlot {
|
||||
|
||||
private Ability inlineAbility;
|
||||
private String referenceId;
|
||||
|
||||
/**
|
||||
* Per-slot enabled override for reference slots (null = use master's default).
|
||||
*/
|
||||
private Boolean enabledOverride;
|
||||
|
||||
private transient Ability cachedAbility;
|
||||
private transient int cachedVersion = -1;
|
||||
|
||||
private AbilitySlot() {
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a slot with an inline (embedded) ability.
|
||||
*/
|
||||
public static AbilitySlot inline(Ability ability) {
|
||||
AbilitySlot slot = new AbilitySlot();
|
||||
slot.inlineAbility = ability;
|
||||
slot.referenceId = null;
|
||||
return slot;
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a slot that references a built-in ability (by name) or custom ability (by name).
|
||||
*/
|
||||
public static AbilitySlot reference(String referenceId) {
|
||||
AbilitySlot slot = new AbilitySlot();
|
||||
slot.inlineAbility = null;
|
||||
slot.referenceId = referenceId;
|
||||
return slot;
|
||||
}
|
||||
|
||||
public boolean isReference() {
|
||||
return referenceId != null;
|
||||
}
|
||||
|
||||
public String getReferenceId() {
|
||||
return referenceId;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the resolved ability. For inline slots, returns the ability directly.
|
||||
* For reference slots, lazily resolves from AbilityController and caches.
|
||||
* Returns null if the reference cannot be resolved (broken ref).
|
||||
*/
|
||||
public Ability getAbility() {
|
||||
if (!isReference()) {
|
||||
return inlineAbility;
|
||||
}
|
||||
|
||||
// Lazy resolve with version-based cache invalidation
|
||||
AbilityController controller = AbilityController.Instance;
|
||||
if (controller == null) return null;
|
||||
|
||||
int currentVersion = controller.getCustomAbilityRevision();
|
||||
if (cachedAbility != null && cachedVersion == currentVersion) {
|
||||
return cachedAbility;
|
||||
}
|
||||
|
||||
cachedAbility = controller.resolveAbility(referenceId);
|
||||
// Apply per-slot enabled override so NPC-specific enable/disable persists
|
||||
if (cachedAbility != null && enabledOverride != null) {
|
||||
cachedAbility.setEnabled(enabledOverride);
|
||||
}
|
||||
cachedVersion = currentVersion;
|
||||
return cachedAbility;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the per-slot enabled override for reference slots.
|
||||
* For inline slots, delegates directly to the ability.
|
||||
*/
|
||||
public void setEnabled(boolean enabled) {
|
||||
if (!isReference()) {
|
||||
if (inlineAbility != null) {
|
||||
inlineAbility.setEnabled(enabled);
|
||||
}
|
||||
} else {
|
||||
this.enabledOverride = enabled;
|
||||
// Also update the cached ability immediately if present
|
||||
if (cachedAbility != null) {
|
||||
cachedAbility.setEnabled(enabled);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the inline ability directly (null for reference slots).
|
||||
*/
|
||||
public Ability getInlineAbility() {
|
||||
return inlineAbility;
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert this reference slot to an inline slot by copying the resolved ability.
|
||||
* No-op if already inline. Returns false if resolution fails.
|
||||
*/
|
||||
public boolean convertToInline() {
|
||||
if (!isReference()) return true;
|
||||
|
||||
Ability resolved = getAbility();
|
||||
if (resolved == null) return false;
|
||||
|
||||
// Deep copy via NBT round-trip
|
||||
inlineAbility = AbilityController.Instance.fromNBT(resolved.writeNBT());
|
||||
referenceId = null;
|
||||
cachedAbility = null;
|
||||
cachedVersion = -1;
|
||||
return true;
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
// NBT
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
|
||||
public NBTTagCompound writeNBT() {
|
||||
if (isReference()) {
|
||||
NBTTagCompound nbt = new NBTTagCompound();
|
||||
nbt.setString("Reference", referenceId);
|
||||
if (enabledOverride != null) {
|
||||
nbt.setBoolean("RefEnabled", enabledOverride);
|
||||
}
|
||||
return nbt;
|
||||
}
|
||||
return inlineAbility != null ? inlineAbility.writeNBT() : new NBTTagCompound();
|
||||
}
|
||||
|
||||
public static AbilitySlot fromNBT(NBTTagCompound nbt) {
|
||||
if (nbt == null) return null;
|
||||
|
||||
if (nbt.hasKey("Reference")) {
|
||||
AbilitySlot slot = reference(nbt.getString("Reference"));
|
||||
if (nbt.hasKey("RefEnabled")) {
|
||||
slot.enabledOverride = nbt.getBoolean("RefEnabled");
|
||||
}
|
||||
return slot;
|
||||
}
|
||||
|
||||
// Inline ability
|
||||
Ability ability = AbilityController.Instance.fromNBT(nbt);
|
||||
if (ability == null) return null;
|
||||
return inline(ability);
|
||||
}
|
||||
}
|
||||
@@ -1,6 +1,7 @@
|
||||
package kamkeel.npcs.controllers.data.ability;
|
||||
|
||||
import kamkeel.npcs.controllers.AbilityController;
|
||||
import kamkeel.npcs.controllers.data.ability.conditions.AbilityCondition;
|
||||
import net.minecraft.entity.EntityLivingBase;
|
||||
import net.minecraft.nbt.NBTTagCompound;
|
||||
import net.minecraft.nbt.NBTTagList;
|
||||
@@ -57,7 +58,7 @@ public class ChainedAbility implements IChainedAbility, IAbilityAction {
|
||||
/**
|
||||
* Chain-level conditions (individual ability conditions are ignored).
|
||||
*/
|
||||
private List<Condition> conditions = new ArrayList<>();
|
||||
private List<AbilityCondition> conditions = new ArrayList<>();
|
||||
|
||||
/**
|
||||
* Ordered list of ability entries to execute.
|
||||
@@ -185,11 +186,11 @@ public class ChainedAbility implements IChainedAbility, IAbilityAction {
|
||||
return UserType.NPC_ONLY;
|
||||
}
|
||||
|
||||
public List<Condition> getConditions() {
|
||||
public List<AbilityCondition> getConditions() {
|
||||
return conditions;
|
||||
}
|
||||
|
||||
public void setConditions(List<Condition> conditions) {
|
||||
public void setConditions(List<AbilityCondition> conditions) {
|
||||
this.conditions = conditions != null ? conditions : new ArrayList<>();
|
||||
}
|
||||
|
||||
@@ -279,7 +280,7 @@ public class ChainedAbility implements IChainedAbility, IAbilityAction {
|
||||
* Check all chain-level conditions against the caster and target.
|
||||
*/
|
||||
public boolean checkConditions(EntityLivingBase caster, EntityLivingBase target) {
|
||||
for (Condition c : conditions) {
|
||||
for (AbilityCondition c : conditions) {
|
||||
if (!c.check(caster, target)) {
|
||||
return false;
|
||||
}
|
||||
@@ -291,7 +292,7 @@ public class ChainedAbility implements IChainedAbility, IAbilityAction {
|
||||
* Check conditions for player use (skip target-requiring conditions).
|
||||
*/
|
||||
public boolean checkConditionsForPlayer(EntityLivingBase caster) {
|
||||
for (Condition c : conditions) {
|
||||
for (AbilityCondition c : conditions) {
|
||||
if (c.requiresTarget()) continue;
|
||||
if (!c.check(caster, null)) {
|
||||
return false;
|
||||
@@ -382,7 +383,7 @@ public class ChainedAbility implements IChainedAbility, IAbilityAction {
|
||||
|
||||
// Conditions
|
||||
NBTTagList condList = new NBTTagList();
|
||||
for (Condition c : conditions) {
|
||||
for (AbilityCondition c : conditions) {
|
||||
condList.appendTag(c.writeNBT());
|
||||
}
|
||||
nbt.setTag("Conditions", condList);
|
||||
@@ -416,7 +417,7 @@ public class ChainedAbility implements IChainedAbility, IAbilityAction {
|
||||
conditions.clear();
|
||||
NBTTagList condList = nbt.getTagList("Conditions", 10);
|
||||
for (int i = 0; i < condList.tagCount(); i++) {
|
||||
Condition c = Condition.fromNBT(condList.getCompoundTagAt(i));
|
||||
AbilityCondition c = AbilityCondition.fromNBT(condList.getCompoundTagAt(i));
|
||||
if (c != null) {
|
||||
conditions.add(c);
|
||||
}
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
package kamkeel.npcs.controllers.data.ability;
|
||||
|
||||
import kamkeel.npcs.controllers.data.ability.conditions.AbilityCondition;
|
||||
import net.minecraft.entity.EntityLivingBase;
|
||||
import net.minecraft.nbt.NBTTagCompound;
|
||||
|
||||
@@ -30,7 +31,7 @@ public interface IAbilityAction {
|
||||
|
||||
UserType getAllowedBy();
|
||||
|
||||
List<Condition> getConditions();
|
||||
List<AbilityCondition> getConditions();
|
||||
|
||||
boolean checkConditions(EntityLivingBase caster, EntityLivingBase target);
|
||||
|
||||
|
||||
@@ -73,4 +73,46 @@ public interface IAbilityExtender {
|
||||
double knockbackDirX, double knockbackDirZ) {
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Called to modify outgoing projectile damage before it hits a barrier or is used in other contexts.
|
||||
* Unlike onAbilityDamage (chain of responsibility), this is cumulative — all extenders apply their
|
||||
* modifications in sequence, each receiving the previous extender's output.
|
||||
*
|
||||
* @param ability The source ability of the projectile
|
||||
* @param caster The entity that fired the projectile
|
||||
* @param baseDamage The base damage from the ability configuration
|
||||
* @return The modified damage value
|
||||
*/
|
||||
default float modifyProjectileDamage(Ability ability, EntityLivingBase caster, float baseDamage) {
|
||||
return baseDamage;
|
||||
}
|
||||
|
||||
/**
|
||||
* Called when a barrier entity is about to be created, allowing extenders to modify its max health.
|
||||
* Cumulative: all extenders apply in sequence, each receiving the previous output.
|
||||
*
|
||||
* @param ability The barrier ability being executed
|
||||
* @param caster The entity creating the barrier
|
||||
* @param baseHealth The base max health from EnergyBarrierData.maxHealth
|
||||
* @return The modified max health value
|
||||
*/
|
||||
default float modifyBarrierHealth(Ability ability, EntityLivingBase caster, float baseHealth) {
|
||||
return baseHealth;
|
||||
}
|
||||
|
||||
/**
|
||||
* Called when an ability is about to heal an entity.
|
||||
* Return true to handle the healing (skip default entity.heal()).
|
||||
* Chain of responsibility: first returning true wins.
|
||||
*
|
||||
* @param ability The ability performing the heal
|
||||
* @param caster The entity casting the ability
|
||||
* @param target The entity being healed
|
||||
* @param healAmount The heal amount calculated by the ability
|
||||
* @return true if healing was handled (skip default), false to pass to next extender or default
|
||||
*/
|
||||
default boolean onAbilityHeal(Ability ability, EntityLivingBase caster, EntityLivingBase target, float healAmount) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,127 @@
|
||||
package kamkeel.npcs.controllers.data.ability.conditions;
|
||||
|
||||
import cpw.mods.fml.relauncher.Side;
|
||||
import cpw.mods.fml.relauncher.SideOnly;
|
||||
import kamkeel.npcs.controllers.AbilityController;
|
||||
import kamkeel.npcs.controllers.data.ability.UserType;
|
||||
import net.minecraft.entity.EntityLivingBase;
|
||||
import net.minecraft.nbt.NBTTagCompound;
|
||||
import net.minecraft.util.StatCollector;
|
||||
import noppes.npcs.LogWriter;
|
||||
import noppes.npcs.client.gui.builder.FieldDef;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.function.Supplier;
|
||||
|
||||
public abstract class AbilityCondition {
|
||||
public static final int MAX_CONDITIONS = 5;
|
||||
|
||||
protected String typeId = "";
|
||||
protected String name = "";
|
||||
protected UserType userType = UserType.BOTH;
|
||||
protected ConditionFilter conditionFilter = ConditionFilter.CASTER;
|
||||
|
||||
public boolean check(EntityLivingBase caster, EntityLivingBase target) {
|
||||
switch (getFilter()) {
|
||||
case CASTER:
|
||||
return checkEntity(caster);
|
||||
case TARGET:
|
||||
return target != null && checkEntity(target);
|
||||
case BOTH:
|
||||
return checkEntity(caster) && (target != null && checkEntity(target));
|
||||
default:
|
||||
return checkEntity(caster);
|
||||
}
|
||||
}
|
||||
|
||||
protected abstract boolean checkEntity(EntityLivingBase entity);
|
||||
|
||||
public boolean requiresTarget() {
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns true if all required fields are filled in.
|
||||
* Used to disable the Done button in SubGuiConditionEdit when incomplete.
|
||||
*/
|
||||
public boolean isConfigured() {
|
||||
return true;
|
||||
}
|
||||
|
||||
public UserType getUserType() {
|
||||
return userType;
|
||||
}
|
||||
|
||||
public String getTypeId() {
|
||||
return typeId;
|
||||
}
|
||||
|
||||
public String getName() {
|
||||
return name;
|
||||
}
|
||||
|
||||
public ConditionFilter getFilter() {
|
||||
return conditionFilter;
|
||||
}
|
||||
|
||||
public void setFilter(ConditionFilter filter) {
|
||||
this.conditionFilter = filter;
|
||||
}
|
||||
|
||||
@SideOnly(Side.CLIENT)
|
||||
public abstract void getConditionDefinitions(List<FieldDef> defs);
|
||||
|
||||
/**
|
||||
* Returns a human-readable summary of this condition's configuration.
|
||||
* Used for tooltips when hovering over condition buttons.
|
||||
*/
|
||||
@SideOnly(Side.CLIENT)
|
||||
public abstract String getConditionSummary();
|
||||
|
||||
@SideOnly(Side.CLIENT)
|
||||
public final List<FieldDef> getAllDefinitions() {
|
||||
List<FieldDef> defs = new ArrayList<>();
|
||||
|
||||
defs.add(FieldDef.labelField("ability.validFor", () ->
|
||||
"\u00A7e" + StatCollector.translateToLocal("ability.userType." + getUserType().name())));
|
||||
defs.add(FieldDef.enumField("condition.filter", ConditionFilter.class, this::getFilter, this::setFilter));
|
||||
getConditionDefinitions(defs);
|
||||
return defs;
|
||||
}
|
||||
|
||||
public final NBTTagCompound writeNBT() {
|
||||
NBTTagCompound nbt = new NBTTagCompound();
|
||||
nbt.setString("typeId", getTypeId());
|
||||
nbt.setString("name", getName());
|
||||
nbt.setInteger("userType", getUserType().ordinal());
|
||||
nbt.setInteger("filter", getFilter().ordinal());
|
||||
writeTypeNBT(nbt);
|
||||
return nbt;
|
||||
}
|
||||
|
||||
public abstract void writeTypeNBT(NBTTagCompound nbt);
|
||||
|
||||
public abstract void readTypeNBT(NBTTagCompound nbt);
|
||||
|
||||
public final void readNBT(NBTTagCompound nbt) {
|
||||
typeId = nbt.getString("typeId");
|
||||
name = nbt.getString("name");
|
||||
userType = UserType.fromOrdinal(nbt.getInteger("userType"));
|
||||
conditionFilter = ConditionFilter.fromOrdinal(nbt.getInteger("filter"));
|
||||
readTypeNBT(nbt);
|
||||
}
|
||||
|
||||
public static AbilityCondition fromNBT(NBTTagCompound nbt) {
|
||||
String typeId = nbt.getString("typeId");
|
||||
Supplier<AbilityCondition> factory = AbilityController.Instance.getConditionType(typeId);
|
||||
if (factory == null) {
|
||||
LogWriter.info("AbilityController: Unknown condition type: " + typeId);
|
||||
return null;
|
||||
}
|
||||
AbilityCondition condition = factory.get();
|
||||
condition.readNBT(nbt);
|
||||
|
||||
return condition;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,39 @@
|
||||
package kamkeel.npcs.controllers.data.ability.conditions;
|
||||
|
||||
import kamkeel.npcs.controllers.data.ability.UserType;
|
||||
|
||||
public enum ConditionFilter {
|
||||
CASTER,
|
||||
TARGET,
|
||||
BOTH;
|
||||
|
||||
public boolean checksCaster() {
|
||||
return this == CASTER || this == BOTH;
|
||||
}
|
||||
|
||||
public boolean checksTarget() {
|
||||
return this == TARGET || this == BOTH;
|
||||
}
|
||||
|
||||
public static ConditionFilter fromOrdinal(int ordinal) {
|
||||
ConditionFilter[] values = values();
|
||||
if (ordinal >= 0 && ordinal < values.length) {
|
||||
return values[ordinal];
|
||||
}
|
||||
return BOTH;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
switch (this) {
|
||||
case BOTH:
|
||||
return "condition.filter.both";
|
||||
case CASTER:
|
||||
return "condition.filter.caster";
|
||||
case TARGET:
|
||||
return "condition.filter.target";
|
||||
default:
|
||||
return name();
|
||||
}
|
||||
}
|
||||
}
|
||||
+26
@@ -0,0 +1,26 @@
|
||||
package kamkeel.npcs.controllers.data.ability.conditions;
|
||||
|
||||
import net.minecraft.entity.EntityLivingBase;
|
||||
|
||||
public class ConditionHPThreshold extends ConditionThreshold {
|
||||
|
||||
public ConditionHPThreshold() {
|
||||
this.typeId = "condition.cnpc.hp_threshold";
|
||||
this.name = "condition.hp_threshold";
|
||||
}
|
||||
|
||||
@Override
|
||||
protected float getEntityValue(EntityLivingBase entity) {
|
||||
return entity.getHealth();
|
||||
}
|
||||
|
||||
@Override
|
||||
protected float getEntityMaxValue(EntityLivingBase entity) {
|
||||
return entity.getMaxHealth();
|
||||
}
|
||||
|
||||
@Override
|
||||
protected String getStatName() {
|
||||
return "HP";
|
||||
}
|
||||
}
|
||||
+106
@@ -0,0 +1,106 @@
|
||||
package kamkeel.npcs.controllers.data.ability.conditions;
|
||||
|
||||
import kamkeel.npcs.controllers.data.ability.UserType;
|
||||
import net.minecraft.entity.EntityLivingBase;
|
||||
import net.minecraft.entity.player.EntityPlayer;
|
||||
import net.minecraft.nbt.NBTTagCompound;
|
||||
import net.minecraft.util.StatCollector;
|
||||
import noppes.npcs.client.gui.advanced.SubGuiCustomEffectSelect;
|
||||
import noppes.npcs.client.gui.builder.FieldDef;
|
||||
import noppes.npcs.client.gui.util.SubGuiInterface;
|
||||
import noppes.npcs.controllers.CustomEffectController;
|
||||
import noppes.npcs.controllers.data.CustomEffect;
|
||||
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
|
||||
public class ConditionHasEffect extends AbilityCondition {
|
||||
private int effectId = -1;
|
||||
private int effectIndex = 0;
|
||||
|
||||
public ConditionHasEffect() {
|
||||
this.typeId = "condition.cnpc.has_effect";
|
||||
this.name = "condition.has_effect";
|
||||
this.userType = UserType.PLAYER_ONLY;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected boolean checkEntity(EntityLivingBase entity) {
|
||||
if (!(entity instanceof EntityPlayer)) return false;
|
||||
if (effectId < 0) return false;
|
||||
|
||||
EntityPlayer player = (EntityPlayer) entity;
|
||||
return CustomEffectController.getInstance().hasEffect(player, effectId, effectIndex);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void getConditionDefinitions(List<FieldDef> defs) {
|
||||
defs.add(FieldDef.subGuiField("condition.select_effect",
|
||||
() -> new SubGuiCustomEffectSelect(effectId, effectIndex),
|
||||
(SubGuiInterface gui) -> {
|
||||
SubGuiCustomEffectSelect sel = (SubGuiCustomEffectSelect) gui;
|
||||
if (sel.getSelectedEffectId() >= 0) {
|
||||
effectId = sel.getSelectedEffectId();
|
||||
effectIndex = sel.getSelectedIndex();
|
||||
}
|
||||
})
|
||||
.buttonLabel(() -> {
|
||||
if (effectId < 0) return "None";
|
||||
CustomEffect effect = getEffect();
|
||||
return effect != null ? effect.getName() : "ID:" + effectId;
|
||||
})
|
||||
.clearable(() -> {
|
||||
effectId = -1;
|
||||
effectIndex = 0;
|
||||
}));
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getConditionSummary() {
|
||||
String filterLabel = StatCollector.translateToLocal(getFilter().toString());
|
||||
String effectName = "None";
|
||||
if (effectId >= 0) {
|
||||
CustomEffect effect = getEffect();
|
||||
effectName = effect != null ? effect.getName() : "ID:" + effectId;
|
||||
}
|
||||
return "[" + filterLabel + "] Effect: " + effectName;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isConfigured() {
|
||||
return effectId >= 0;
|
||||
}
|
||||
|
||||
private CustomEffect getEffect() {
|
||||
HashMap<Integer, CustomEffect> map = CustomEffectController.getInstance().getEffectMap(effectIndex);
|
||||
return map != null ? map.get(effectId) : null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void writeTypeNBT(NBTTagCompound nbt) {
|
||||
nbt.setInteger("effectId", effectId);
|
||||
nbt.setInteger("effectIndex", effectIndex);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void readTypeNBT(NBTTagCompound nbt) {
|
||||
effectId = nbt.getInteger("effectId");
|
||||
effectIndex = nbt.getInteger("effectIndex");
|
||||
}
|
||||
|
||||
public int getEffectId() {
|
||||
return effectId;
|
||||
}
|
||||
|
||||
public void setEffectId(int effectId) {
|
||||
this.effectId = effectId;
|
||||
}
|
||||
|
||||
public int getEffectIndex() {
|
||||
return effectIndex;
|
||||
}
|
||||
|
||||
public void setEffectIndex(int effectIndex) {
|
||||
this.effectIndex = effectIndex;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,78 @@
|
||||
package kamkeel.npcs.controllers.data.ability.conditions;
|
||||
|
||||
import net.minecraft.entity.EntityLivingBase;
|
||||
import net.minecraft.nbt.NBTTagCompound;
|
||||
import net.minecraft.util.StatCollector;
|
||||
import noppes.npcs.client.gui.builder.FieldDef;
|
||||
import noppes.npcs.entity.EntityNPCInterface;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public class ConditionHitCount extends AbilityCondition {
|
||||
private int requiredHits = 3;
|
||||
private int withinTicks = 60;
|
||||
|
||||
public ConditionHitCount() {
|
||||
this.typeId = "condition.cnpc.hit_count";
|
||||
this.name = "condition.hit_count";
|
||||
}
|
||||
|
||||
@Override
|
||||
protected boolean checkEntity(EntityLivingBase entity) {
|
||||
// Not used — this condition overrides check() directly
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean check(EntityLivingBase caster, EntityLivingBase target) {
|
||||
if (caster instanceof EntityNPCInterface) {
|
||||
EntityNPCInterface npc = (EntityNPCInterface) caster;
|
||||
if (npc.abilities != null) {
|
||||
return npc.abilities.getRecentHitCount(withinTicks) >= requiredHits;
|
||||
}
|
||||
}
|
||||
|
||||
// For players, hit count tracking is not yet supported
|
||||
return false;
|
||||
}
|
||||
|
||||
public int getRequiredHits() {
|
||||
return requiredHits;
|
||||
}
|
||||
|
||||
public void setRequiredHits(int requiredHits) {
|
||||
this.requiredHits = Math.max(0, requiredHits);
|
||||
}
|
||||
|
||||
public int getWithinTicks() {
|
||||
return withinTicks;
|
||||
}
|
||||
|
||||
public void setWithinTicks(int withinTicks) {
|
||||
this.withinTicks = Math.max(0, withinTicks);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void getConditionDefinitions(List<FieldDef> defs) {
|
||||
defs.add(FieldDef.intField("condition.required_hits", this::getRequiredHits, this::setRequiredHits).min(1));
|
||||
defs.add(FieldDef.intField("condition.within_ticks", this::getWithinTicks, this::setWithinTicks).min(0));
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getConditionSummary() {
|
||||
String filterLabel = StatCollector.translateToLocal(getFilter().toString());
|
||||
return "[" + filterLabel + "] Hit " + requiredHits + " times in " + withinTicks + " ticks";
|
||||
}
|
||||
|
||||
@Override
|
||||
public void writeTypeNBT(NBTTagCompound nbt) {
|
||||
nbt.setInteger("requiredHits", requiredHits);
|
||||
nbt.setInteger("withinTicks", withinTicks);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void readTypeNBT(NBTTagCompound nbt) {
|
||||
requiredHits = nbt.getInteger("requiredHits");
|
||||
withinTicks = nbt.getInteger("withinTicks");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,202 @@
|
||||
package kamkeel.npcs.controllers.data.ability.conditions;
|
||||
|
||||
import net.minecraft.entity.EntityLivingBase;
|
||||
import net.minecraft.entity.player.EntityPlayer;
|
||||
import net.minecraft.item.ItemStack;
|
||||
import net.minecraft.nbt.NBTTagCompound;
|
||||
import net.minecraft.util.StatCollector;
|
||||
import noppes.npcs.client.gui.builder.FieldDef;
|
||||
import noppes.npcs.entity.EntityNPCInterface;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public class ConditionItem extends AbilityCondition {
|
||||
|
||||
public enum UsageType {
|
||||
ARMOR, HOLDING, AMMO, OFFHAND;
|
||||
|
||||
public static UsageType fromOrdinal(int ordinal) {
|
||||
UsageType[] values = values();
|
||||
return (ordinal >= 0 && ordinal < values.length) ? values[ordinal] : HOLDING;
|
||||
}
|
||||
}
|
||||
|
||||
public enum ArmorSlot {
|
||||
BOOTS, LEGS, CHEST, HELMET;
|
||||
|
||||
public static ArmorSlot fromOrdinal(int ordinal) {
|
||||
ArmorSlot[] values = values();
|
||||
return (ordinal >= 0 && ordinal < values.length) ? values[ordinal] : BOOTS;
|
||||
}
|
||||
}
|
||||
|
||||
// Shared
|
||||
private UsageType usageType = UsageType.HOLDING;
|
||||
private String itemName = "";
|
||||
|
||||
// ARMOR only
|
||||
private ArmorSlot armorSlot = ArmorSlot.BOOTS;
|
||||
private boolean fullArmorSet = false;
|
||||
|
||||
// AMMO + PLAYER only
|
||||
private int requiredCount = 1;
|
||||
|
||||
public ConditionItem() {
|
||||
this.typeId = "condition.cnpc.item";
|
||||
this.name = "condition.item";
|
||||
}
|
||||
|
||||
@Override
|
||||
protected boolean checkEntity(EntityLivingBase entity) {
|
||||
switch (usageType) {
|
||||
case HOLDING:
|
||||
return checkHolding(entity);
|
||||
case ARMOR:
|
||||
return checkArmor(entity);
|
||||
case AMMO:
|
||||
return checkAmmo(entity);
|
||||
case OFFHAND:
|
||||
return checkOffhand(entity);
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
private boolean checkHolding(EntityLivingBase entity) {
|
||||
ItemStack held = entity.getHeldItem();
|
||||
return matchesItem(held);
|
||||
}
|
||||
|
||||
private boolean checkArmor(EntityLivingBase entity) {
|
||||
// MC getEquipmentInSlot: 1=boots, 2=legs, 3=chest, 4=helmet
|
||||
int slot = armorSlot.ordinal() + 1; // BOOTS=0, LEGS=1, CHEST=2, HELMET=3
|
||||
return matchesItem(entity.getEquipmentInSlot(slot));
|
||||
}
|
||||
|
||||
private boolean checkFullArmor(EntityLivingBase entity) {
|
||||
for (int i = 0; i < 4; i++) {
|
||||
int slot = i + 1;
|
||||
if (!matchesItem(i, entity.getEquipmentInSlot(slot)))
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
private boolean checkAmmo(EntityLivingBase entity) {
|
||||
if (entity instanceof EntityPlayer) {
|
||||
return checkPlayerInventoryCount((EntityPlayer) entity);
|
||||
}
|
||||
if (entity instanceof EntityNPCInterface) {
|
||||
return checkNPCProjectile((EntityNPCInterface) entity);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
private boolean checkOffhand(EntityLivingBase entity) {
|
||||
// No offhand for players
|
||||
if (entity instanceof EntityPlayer) return false;
|
||||
|
||||
ItemStack item = ((EntityNPCInterface) entity).getOffHand();
|
||||
return matchesItem(item);
|
||||
}
|
||||
|
||||
private boolean checkPlayerInventoryCount(EntityPlayer player) {
|
||||
int count = 0;
|
||||
for (ItemStack stack : player.inventory.mainInventory) {
|
||||
if (matchesItem(stack)) {
|
||||
count += stack.stackSize;
|
||||
}
|
||||
}
|
||||
return count >= requiredCount;
|
||||
}
|
||||
|
||||
private boolean checkNPCProjectile(EntityNPCInterface npc) {
|
||||
ItemStack projectile = npc.inventory.getProjectile();
|
||||
return matchesItem(projectile);
|
||||
}
|
||||
|
||||
private boolean matchesItem(ItemStack stack) {
|
||||
return matchesItem(0, stack);
|
||||
}
|
||||
|
||||
private boolean matchesItem(int index, ItemStack stack) {
|
||||
if (stack == null || itemName == null || itemName.isEmpty()) return false;
|
||||
String registryName = net.minecraft.item.Item.itemRegistry.getNameForObject(stack.getItem());
|
||||
return itemName.equals(registryName);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void getConditionDefinitions(List<FieldDef> defs) {
|
||||
defs.add(FieldDef.enumField("condition.usage_type", UsageType.class,
|
||||
this::getUsageType, this::setUsageType));
|
||||
|
||||
defs.add(FieldDef.stringField("condition.item_name",
|
||||
this::getItemName, this::setItemName));
|
||||
// .hover("condition.hover.item_name"));
|
||||
|
||||
|
||||
|
||||
defs.add(FieldDef.enumField("condition.armor_slot", ArmorSlot.class,
|
||||
this::getArmorSlot, this::setArmorSlot)
|
||||
.visibleWhen(() -> usageType == UsageType.ARMOR));
|
||||
// .hover("condition.hover.armor_slots"));
|
||||
|
||||
defs.add(FieldDef.intField("condition.item_count",
|
||||
this::getRequiredCount, this::setRequiredCount)
|
||||
.range(1, 64)
|
||||
.visibleWhen(() -> usageType == UsageType.AMMO && userType.allowsPlayer()));
|
||||
// .hover("condition.hover.required_count"));
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getConditionSummary() {
|
||||
String filterLabel = StatCollector.translateToLocal(getFilter().toString());
|
||||
String usage = usageType.name();
|
||||
String item = itemName.isEmpty() ? "None" : itemName;
|
||||
return "[" + filterLabel + "] " + usage + ": " + item;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void writeTypeNBT(NBTTagCompound nbt) {
|
||||
nbt.setString("itemName", itemName);
|
||||
nbt.setInteger("usageType", usageType.ordinal());
|
||||
nbt.setInteger("armorSlot", armorSlot.ordinal());
|
||||
nbt.setInteger("requiredCount", requiredCount);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void readTypeNBT(NBTTagCompound nbt) {
|
||||
itemName = nbt.getString("itemName");
|
||||
usageType = UsageType.fromOrdinal(nbt.getInteger("usageType"));
|
||||
armorSlot = ArmorSlot.fromOrdinal(nbt.getInteger("armorSlot"));
|
||||
requiredCount = nbt.getInteger("requiredCount");
|
||||
}
|
||||
|
||||
|
||||
@Override
|
||||
public boolean isConfigured() {
|
||||
return itemName != null && !itemName.isEmpty();
|
||||
}
|
||||
|
||||
public UsageType getUsageType() { return usageType; }
|
||||
public void setUsageType(UsageType usageType) { this.usageType = usageType; }
|
||||
|
||||
public String getItemName() { return itemName; }
|
||||
public void setItemName(String itemName) { this.itemName = itemName; }
|
||||
|
||||
public ArmorSlot getArmorSlot() { return armorSlot; }
|
||||
public void setArmorSlot(ArmorSlot armorSlot) { this.armorSlot = armorSlot; }
|
||||
|
||||
public boolean isFullArmorSet() {
|
||||
return fullArmorSet;
|
||||
}
|
||||
|
||||
public void setFullArmorSet(boolean fullArmorSet) {
|
||||
this.fullArmorSet = fullArmorSet;
|
||||
}
|
||||
|
||||
public int getRequiredCount() { return requiredCount; }
|
||||
public void setRequiredCount(int requiredCount) { this.requiredCount = Math.max(1, requiredCount); }
|
||||
}
|
||||
+86
@@ -0,0 +1,86 @@
|
||||
package kamkeel.npcs.controllers.data.ability.conditions;
|
||||
|
||||
import kamkeel.npcs.controllers.data.ability.UserType;
|
||||
import net.minecraft.entity.EntityLivingBase;
|
||||
import net.minecraft.entity.player.EntityPlayer;
|
||||
import net.minecraft.nbt.NBTTagCompound;
|
||||
import net.minecraft.util.StatCollector;
|
||||
import noppes.npcs.client.gui.builder.FieldDef;
|
||||
import noppes.npcs.client.gui.select.GuiQuestSelection;
|
||||
import noppes.npcs.client.gui.util.SubGuiInterface;
|
||||
import noppes.npcs.controllers.QuestController;
|
||||
import noppes.npcs.controllers.data.PlayerData;
|
||||
import noppes.npcs.controllers.data.Quest;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public class ConditionQuestCompleted extends AbilityCondition {
|
||||
private int questId = -1;
|
||||
|
||||
public ConditionQuestCompleted() {
|
||||
this.typeId = "condition.cnpc.quest_completed";
|
||||
this.name = "condition.quest_completed";
|
||||
this.userType = UserType.PLAYER_ONLY;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected boolean checkEntity(EntityLivingBase entity) {
|
||||
if (!(entity instanceof EntityPlayer)) return false;
|
||||
if (questId < 0) return false;
|
||||
|
||||
EntityPlayer player = (EntityPlayer) entity;
|
||||
return PlayerData.get(player).questData.hasFinishedQuest(questId);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void getConditionDefinitions(List<FieldDef> defs) {
|
||||
defs.add(FieldDef.subGuiField("condition.select_quest",
|
||||
() -> new GuiQuestSelection(questId),
|
||||
(SubGuiInterface gui) -> {
|
||||
GuiQuestSelection sel = (GuiQuestSelection) gui;
|
||||
if (sel.selectedQuest != null) {
|
||||
questId = sel.selectedQuest.id;
|
||||
}
|
||||
})
|
||||
.buttonLabel(() -> {
|
||||
if (questId < 0) return "None";
|
||||
Quest q = QuestController.Instance.quests.get(questId);
|
||||
return q != null ? q.title : "ID:" + questId;
|
||||
})
|
||||
.clearable(() -> questId = -1));
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getConditionSummary() {
|
||||
String filterLabel = StatCollector.translateToLocal(getFilter().toString());
|
||||
String questName = "None";
|
||||
if (questId >= 0) {
|
||||
Quest q = QuestController.Instance.quests.get(questId);
|
||||
questName = q != null ? q.title : "ID:" + questId;
|
||||
}
|
||||
return "[" + filterLabel + "] Quest: " + questName;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void writeTypeNBT(NBTTagCompound nbt) {
|
||||
nbt.setInteger("questId", questId);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void readTypeNBT(NBTTagCompound nbt) {
|
||||
questId = nbt.getInteger("questId");
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isConfigured() {
|
||||
return questId >= 0;
|
||||
}
|
||||
|
||||
public int getQuestId() {
|
||||
return questId;
|
||||
}
|
||||
|
||||
public void setQuestId(int questId) {
|
||||
this.questId = questId;
|
||||
}
|
||||
}
|
||||
+171
@@ -0,0 +1,171 @@
|
||||
package kamkeel.npcs.controllers.data.ability.conditions;
|
||||
|
||||
import net.minecraft.entity.EntityLivingBase;
|
||||
import net.minecraft.nbt.NBTTagCompound;
|
||||
import net.minecraft.util.StatCollector;
|
||||
import noppes.npcs.client.gui.builder.FieldDef;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Abstract base for threshold-based conditions (HP, Ki, etc.).
|
||||
* Provides shared percent/flat toggle, ThresholdType enum, and FieldDef generation.
|
||||
*/
|
||||
public abstract class ConditionThreshold extends AbilityCondition {
|
||||
|
||||
public enum ThresholdType {
|
||||
ABOVE {
|
||||
@Override
|
||||
public boolean test(float value, float threshold) {
|
||||
return value >= threshold;
|
||||
}
|
||||
},
|
||||
BELOW {
|
||||
@Override
|
||||
public boolean test(float value, float threshold) {
|
||||
return value <= threshold;
|
||||
}
|
||||
},
|
||||
EQUAL {
|
||||
@Override
|
||||
public boolean test(float value, float threshold) {
|
||||
return value == threshold;
|
||||
}
|
||||
};
|
||||
|
||||
public abstract boolean test(float value, float threshold);
|
||||
|
||||
public static ThresholdType fromOrdinal(int ordinal) {
|
||||
ThresholdType[] values = values();
|
||||
if (ordinal >= 0 && ordinal < values.length) {
|
||||
return values[ordinal];
|
||||
}
|
||||
return ABOVE;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
switch (this) {
|
||||
case ABOVE:
|
||||
return "condition.above";
|
||||
case BELOW:
|
||||
return "condition.below";
|
||||
case EQUAL:
|
||||
return "condition.equal";
|
||||
default:
|
||||
return name();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
protected float thresholdFlat = 100f;
|
||||
protected float thresholdPercent = 0.5f;
|
||||
protected boolean percent = true;
|
||||
protected ThresholdType thresholdType = ThresholdType.ABOVE;
|
||||
|
||||
/**
|
||||
* Returns the raw stat value for the entity (e.g. current HP, current Ki).
|
||||
*/
|
||||
protected abstract float getEntityValue(EntityLivingBase entity);
|
||||
|
||||
/**
|
||||
* Returns the maximum stat value for the entity (e.g. max HP, max Ki).
|
||||
* Used to compute the percentage ratio.
|
||||
*/
|
||||
protected abstract float getEntityMaxValue(EntityLivingBase entity);
|
||||
|
||||
/**
|
||||
* Returns the display name for the stat being checked (e.g. "HP", "Ki").
|
||||
* Used in getConditionSummary().
|
||||
*/
|
||||
protected abstract String getStatName();
|
||||
|
||||
@Override
|
||||
protected boolean checkEntity(EntityLivingBase entity) {
|
||||
float value;
|
||||
float threshold;
|
||||
if (percent) {
|
||||
float max = getEntityMaxValue(entity);
|
||||
value = max > 0 ? getEntityValue(entity) / max : 0;
|
||||
threshold = thresholdPercent;
|
||||
} else {
|
||||
value = getEntityValue(entity);
|
||||
threshold = thresholdFlat;
|
||||
}
|
||||
return thresholdType.test(value, threshold);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void getConditionDefinitions(List<FieldDef> defs) {
|
||||
defs.add(FieldDef.floatField("condition.threshold_flat", this::getThresholdFlat, this::setThresholdFlat)
|
||||
.min(0).visibleWhen(() -> !isPercent()));
|
||||
defs.add(FieldDef.floatField("condition.threshold_percent", this::getThresholdPercent, this::setThresholdPercent)
|
||||
.min(0).max(1).visibleWhen(this::isPercent));
|
||||
defs.add(FieldDef.boolField("condition.percent", this::isPercent, this::setIsPercent));
|
||||
defs.add(FieldDef.enumField("condition.threshold_type", ThresholdType.class,
|
||||
this::getThresholdType, this::setThresholdType));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void writeTypeNBT(NBTTagCompound nbt) {
|
||||
nbt.setFloat("thresholdFlat", thresholdFlat);
|
||||
nbt.setFloat("thresholdPercent", thresholdPercent);
|
||||
nbt.setBoolean("percent", percent);
|
||||
nbt.setInteger("thresholdType", thresholdType.ordinal());
|
||||
}
|
||||
|
||||
@Override
|
||||
public void readTypeNBT(NBTTagCompound nbt) {
|
||||
thresholdFlat = nbt.getFloat("thresholdFlat");
|
||||
thresholdPercent = nbt.getFloat("thresholdPercent");
|
||||
percent = nbt.getBoolean("percent");
|
||||
thresholdType = ThresholdType.fromOrdinal(nbt.getInteger("thresholdType"));
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getConditionSummary() {
|
||||
String filterLabel = StatCollector.translateToLocal(getFilter().toString());
|
||||
String typeName = getStatName();
|
||||
String typeLabel = StatCollector.translateToLocal(thresholdType.toString());
|
||||
String value = percent
|
||||
? String.format("%.0f%%", thresholdPercent * 100)
|
||||
: String.format("%.0f", thresholdFlat);
|
||||
return "[" + filterLabel + "] " + typeName + " " + typeLabel + " " + value;
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
// GETTERS / SETTERS
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
|
||||
public float getThresholdFlat() {
|
||||
return thresholdFlat;
|
||||
}
|
||||
|
||||
public void setThresholdFlat(float value) {
|
||||
this.thresholdFlat = Math.max(0, value);
|
||||
}
|
||||
|
||||
public float getThresholdPercent() {
|
||||
return thresholdPercent;
|
||||
}
|
||||
|
||||
public void setThresholdPercent(float value) {
|
||||
this.thresholdPercent = Math.max(0, Math.min(1, value));
|
||||
}
|
||||
|
||||
public boolean isPercent() {
|
||||
return percent;
|
||||
}
|
||||
|
||||
public void setIsPercent(boolean percent) {
|
||||
this.percent = percent;
|
||||
}
|
||||
|
||||
public ThresholdType getThresholdType() {
|
||||
return thresholdType;
|
||||
}
|
||||
|
||||
public void setThresholdType(ThresholdType type) {
|
||||
this.thresholdType = type;
|
||||
}
|
||||
}
|
||||
@@ -8,10 +8,14 @@ import java.util.Map;
|
||||
/**
|
||||
* Groups barrier properties shared by energy barrier abilities (Dome, Wall, Shield).
|
||||
* Handles health/durability, duration, and per-projectile-type damage multipliers.
|
||||
*
|
||||
* Properties:
|
||||
* - Solid: Hard wall — entities cannot pass through the barrier boundary (either direction)
|
||||
* - Knockback: Repulsion field — entities near the surface get pushed away
|
||||
* - Absorbing: Caster's incoming damage is redirected to the barrier
|
||||
* - Allows Melee: Barrier can be hit by melee attacks (punching)
|
||||
*/
|
||||
public class EnergyBarrierData {
|
||||
// Knockback target display keys
|
||||
private static final String[] KNOCKBACK_TARGET_KEYS = {"gui.both", "gui.players", "gui.npcs"};
|
||||
|
||||
public float maxHealth = 100.0f;
|
||||
public boolean useHealth = true;
|
||||
@@ -19,15 +23,17 @@ public class EnergyBarrierData {
|
||||
public boolean useDuration = true;
|
||||
public float defaultMultiplier = 1.0f;
|
||||
|
||||
// Knockback settings
|
||||
// Solid: entities cannot pass through the barrier boundary
|
||||
public boolean solid = false;
|
||||
|
||||
// Knockback: repulsion field pushing entities away from surface
|
||||
public boolean knockbackEnabled = false;
|
||||
public float knockbackStrength = 1.0f;
|
||||
/**
|
||||
* 0=Both, 1=Player only, 2=NPC only
|
||||
*/
|
||||
public int knockbackTarget = 0;
|
||||
|
||||
// Melee settings
|
||||
// Absorbing: caster's damage is redirected to the barrier
|
||||
public boolean absorbing = false;
|
||||
|
||||
// Melee: barrier can be hit by melee attacks
|
||||
public boolean meleeEnabled = false;
|
||||
public float meleeDamageMultiplier = 1.0f;
|
||||
|
||||
@@ -113,24 +119,6 @@ public class EnergyBarrierData {
|
||||
this.defaultMultiplier = defaultMultiplier;
|
||||
}
|
||||
|
||||
// Knockback target key helpers
|
||||
public static String[] getKnockbackTargetKeys() {
|
||||
return KNOCKBACK_TARGET_KEYS;
|
||||
}
|
||||
|
||||
public String getKnockbackTargetKey() {
|
||||
return KNOCKBACK_TARGET_KEYS[Math.max(0, Math.min(knockbackTarget, 2))];
|
||||
}
|
||||
|
||||
public void setKnockbackTargetFromKey(String key) {
|
||||
for (int i = 0; i < KNOCKBACK_TARGET_KEYS.length; i++) {
|
||||
if (KNOCKBACK_TARGET_KEYS[i].equals(key)) {
|
||||
knockbackTarget = i;
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ==================== NBT ====================
|
||||
|
||||
public void writeNBT(NBTTagCompound nbt) {
|
||||
@@ -139,9 +127,10 @@ public class EnergyBarrierData {
|
||||
nbt.setInteger("barrierDuration", durationTicks);
|
||||
nbt.setBoolean("barrierUseDuration", useDuration);
|
||||
nbt.setFloat("barrierDefaultMult", defaultMultiplier);
|
||||
nbt.setBoolean("barrierSolid", solid);
|
||||
nbt.setBoolean("barrierKnockback", knockbackEnabled);
|
||||
nbt.setFloat("barrierKnockbackStr", knockbackStrength);
|
||||
nbt.setInteger("barrierKnockbackTarget", knockbackTarget);
|
||||
nbt.setBoolean("barrierAbsorbing", absorbing);
|
||||
nbt.setBoolean("barrierMelee", meleeEnabled);
|
||||
nbt.setFloat("barrierMeleeMult", meleeDamageMultiplier);
|
||||
|
||||
@@ -158,9 +147,10 @@ public class EnergyBarrierData {
|
||||
durationTicks = nbt.hasKey("barrierDuration") ? nbt.getInteger("barrierDuration") : 200;
|
||||
useDuration = !nbt.hasKey("barrierUseDuration") || nbt.getBoolean("barrierUseDuration");
|
||||
defaultMultiplier = nbt.hasKey("barrierDefaultMult") ? nbt.getFloat("barrierDefaultMult") : 1.0f;
|
||||
solid = nbt.hasKey("barrierSolid") && nbt.getBoolean("barrierSolid");
|
||||
knockbackEnabled = nbt.hasKey("barrierKnockback") && nbt.getBoolean("barrierKnockback");
|
||||
knockbackStrength = nbt.hasKey("barrierKnockbackStr") ? nbt.getFloat("barrierKnockbackStr") : 1.0f;
|
||||
knockbackTarget = nbt.hasKey("barrierKnockbackTarget") ? nbt.getInteger("barrierKnockbackTarget") : 0;
|
||||
absorbing = nbt.hasKey("barrierAbsorbing") && nbt.getBoolean("barrierAbsorbing");
|
||||
meleeEnabled = nbt.hasKey("barrierMelee") && nbt.getBoolean("barrierMelee");
|
||||
meleeDamageMultiplier = nbt.hasKey("barrierMeleeMult") ? nbt.getFloat("barrierMeleeMult") : 1.0f;
|
||||
|
||||
@@ -178,9 +168,10 @@ public class EnergyBarrierData {
|
||||
public EnergyBarrierData copy() {
|
||||
EnergyBarrierData copy = new EnergyBarrierData(maxHealth, useHealth, durationTicks, useDuration);
|
||||
copy.defaultMultiplier = defaultMultiplier;
|
||||
copy.solid = solid;
|
||||
copy.knockbackEnabled = knockbackEnabled;
|
||||
copy.knockbackStrength = knockbackStrength;
|
||||
copy.knockbackTarget = knockbackTarget;
|
||||
copy.absorbing = absorbing;
|
||||
copy.meleeEnabled = meleeEnabled;
|
||||
copy.meleeDamageMultiplier = meleeDamageMultiplier;
|
||||
copy.damageMultipliers = new HashMap<>(damageMultipliers);
|
||||
|
||||
@@ -0,0 +1,83 @@
|
||||
package kamkeel.npcs.controllers.data.ability.data;
|
||||
|
||||
import net.minecraft.nbt.NBTTagCompound;
|
||||
|
||||
public class EnergyChargingData {
|
||||
|
||||
public int chargeDuration = 60;
|
||||
public int chargeDelay = 0;
|
||||
public int maxCharge = 100;
|
||||
public boolean hasCharge = true;
|
||||
public boolean chargeWindUpSync = true;
|
||||
|
||||
public EnergyChargingData() {
|
||||
}
|
||||
|
||||
public EnergyChargingData(int chargeDuration, int chargeDelay, int maxCharge, boolean hasCharge, boolean chargeWindUpSync) {
|
||||
this.chargeDuration = chargeDuration;
|
||||
this.chargeDelay = chargeDelay;
|
||||
this.maxCharge = maxCharge;
|
||||
this.hasCharge = hasCharge;
|
||||
this.chargeWindUpSync = chargeWindUpSync;
|
||||
}
|
||||
|
||||
public boolean hasCharge() {
|
||||
return hasCharge;
|
||||
}
|
||||
|
||||
public void setHasCharge(boolean hasCharge) {
|
||||
this.hasCharge = hasCharge;
|
||||
}
|
||||
|
||||
public boolean isChargeWindUpSync() {
|
||||
return chargeWindUpSync;
|
||||
}
|
||||
|
||||
public void setChargeWindUpSync(boolean chargeWindUpSync) {
|
||||
this.chargeWindUpSync = chargeWindUpSync;
|
||||
}
|
||||
|
||||
public int getChargeDuration() {
|
||||
return chargeDuration;
|
||||
}
|
||||
|
||||
public void setChargeDuration(int chargeDuration) {
|
||||
this.chargeDuration = chargeDuration;
|
||||
}
|
||||
|
||||
public int getChargeDelay() {
|
||||
return chargeDelay;
|
||||
}
|
||||
|
||||
public void setChargeDelay(int chargeDelay) {
|
||||
this.chargeDelay = chargeDelay;
|
||||
}
|
||||
|
||||
public int getMaxCharge() {
|
||||
return maxCharge;
|
||||
}
|
||||
|
||||
public void setMaxCharge(int maxCharge) {
|
||||
this.maxCharge = Math.max(0, maxCharge);
|
||||
}
|
||||
|
||||
public void writeNBT(NBTTagCompound nbt) {
|
||||
nbt.setInteger("chargeDuration", chargeDuration);
|
||||
nbt.setInteger("chargeDelay", chargeDelay);
|
||||
nbt.setInteger("maxCharge", maxCharge);
|
||||
nbt.setBoolean("hasCharge", hasCharge);
|
||||
nbt.setBoolean("chargeWindUpSync", chargeWindUpSync);
|
||||
}
|
||||
|
||||
public void readNBT(NBTTagCompound nbt) {
|
||||
chargeDuration = nbt.hasKey("chargeDuration") ? nbt.getInteger("chargeDuration") : 60;
|
||||
chargeDelay = nbt.hasKey("chargeDelay") ? nbt.getInteger("chargeDelay") : 0;
|
||||
maxCharge = nbt.hasKey("maxCharge") ? nbt.getInteger("maxCharge") : 100;
|
||||
hasCharge = !nbt.hasKey("hasCharge") || nbt.getBoolean("hasCharge");
|
||||
chargeWindUpSync = !nbt.hasKey("chargeWindUpSync") || nbt.getBoolean("chargeWindUpSync");
|
||||
}
|
||||
|
||||
public EnergyChargingData copy() {
|
||||
return new EnergyChargingData(chargeDuration, chargeDelay, maxCharge, hasCharge, chargeWindUpSync);
|
||||
}
|
||||
}
|
||||
@@ -52,7 +52,7 @@ public class AbilityCharge extends AbilityMovement implements IAbilityCharge {
|
||||
this.windUpSound = "mob.zombie.wood";
|
||||
this.activeSound = "mob.zombie.attack";
|
||||
this.windUpAnimationName = "Ability_Charge_Windup";
|
||||
this.activeAnimationName = "Ability_Active_Windup";
|
||||
this.activeAnimationName = "Ability_Charge_Active";
|
||||
}
|
||||
|
||||
@Override
|
||||
@@ -66,26 +66,25 @@ public class AbilityCharge extends AbilityMovement implements IAbilityCharge {
|
||||
}
|
||||
|
||||
/**
|
||||
* Called on the first tick of windup - lock direction here so it matches telegraph.
|
||||
* During windup, NPCs face toward their target for animation purposes.
|
||||
* Players aim freely — the telegraph follows their look direction on the client,
|
||||
* and direction is locked at the end of windup in onExecute().
|
||||
*/
|
||||
@Override
|
||||
public void onWindUpTick(EntityLivingBase caster, EntityLivingBase target, int tick) {
|
||||
if (tick == 1) {
|
||||
lockDirection(caster, target);
|
||||
if (!isPlayerCaster(caster) && target != null) {
|
||||
lockDirectionToTarget(caster, target);
|
||||
enforceLockedRotation(caster);
|
||||
}
|
||||
enforceLockedRotation(caster);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onExecute(EntityLivingBase caster, EntityLivingBase target) {
|
||||
// Lock final direction at end of windup so it matches the telegraph
|
||||
lockDirection(caster, target);
|
||||
initMovement(caster, maxRange, chargeSpeed);
|
||||
hitEntities.clear();
|
||||
|
||||
// If direction wasn't set during windup (shouldn't happen), set it now
|
||||
if (movementDirection == null) {
|
||||
lockDirection(caster, target);
|
||||
}
|
||||
|
||||
enforceLockedRotation(caster);
|
||||
}
|
||||
|
||||
@@ -227,6 +226,11 @@ public class AbilityCharge extends AbilityMovement implements IAbilityCharge {
|
||||
// Telegraph follows caster during windup - allows caster to reposition
|
||||
instance.setEntityIdToFollow(caster.getEntityId());
|
||||
|
||||
// For player casters, track their rotation so telegraph follows look direction
|
||||
if (isPlayerCaster(caster)) {
|
||||
instance.setTrackFollowedEntityYaw(true);
|
||||
}
|
||||
|
||||
return instance;
|
||||
}
|
||||
|
||||
|
||||
@@ -134,6 +134,10 @@ public class AbilityCutter extends Ability implements IAbilityCutter {
|
||||
|
||||
if (target != null && !isRotationLockedDuringWindup()) {
|
||||
instance.setTargetEntityId(target.getEntityId());
|
||||
} else {
|
||||
// No target to track yaw from — track the caster's rotation instead
|
||||
// so the telegraph follows where the player/NPC is facing
|
||||
instance.setTrackFollowedEntityYaw(true);
|
||||
}
|
||||
|
||||
return instance;
|
||||
@@ -160,8 +164,9 @@ public class AbilityCutter extends Ability implements IAbilityCutter {
|
||||
currentRotation = -arcAngle / 2.0f;
|
||||
activeSoundPlayed = false;
|
||||
|
||||
// Lock sweep direction toward target at execute time to prevent
|
||||
// AI look-at jitter from misdirecting the sweep at close range
|
||||
// Compute sweep direction from caster/target at execution time.
|
||||
// Server-side telegraph instances are not ticked, so their yaw is stale
|
||||
// from windup start — use the caster's current rotation instead.
|
||||
if (target != null) {
|
||||
double dx = target.posX - caster.posX;
|
||||
double dz = target.posZ - caster.posZ;
|
||||
@@ -260,6 +265,10 @@ public class AbilityCutter extends Ability implements IAbilityCutter {
|
||||
if (dist < minDist || dist > maxDist) continue;
|
||||
if (!isInSweepRange(dx, dz, sweepBaseYaw, minAngle, maxAngle)) continue;
|
||||
|
||||
// Line-of-sight check: skip targets behind solid blocks or enemy barriers
|
||||
if (!hasLineOfSight(world, caster, entity)) continue;
|
||||
if (isBlockedByBarrier(world, caster, entity)) continue;
|
||||
|
||||
hitEntities.add(entity.getEntityId());
|
||||
|
||||
float distFactor = 1.0f - ((float) dist / maxDist) * 0.3f;
|
||||
|
||||
@@ -26,7 +26,8 @@ public class AbilityDash extends AbilityMovement implements IAbilityDash {
|
||||
*/
|
||||
public enum DashMode {
|
||||
AGGRESSIVE,
|
||||
DEFENSIVE;
|
||||
DEFENSIVE,
|
||||
DIRECTIONAL;
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
@@ -35,6 +36,8 @@ public class AbilityDash extends AbilityMovement implements IAbilityDash {
|
||||
return "ability.dash.aggressive";
|
||||
case DEFENSIVE:
|
||||
return "ability.dash.defensive";
|
||||
case DIRECTIONAL:
|
||||
return "ability.dash.directional";
|
||||
default:
|
||||
return name();
|
||||
}
|
||||
@@ -124,16 +127,22 @@ public class AbilityDash extends AbilityMovement implements IAbilityDash {
|
||||
public void onExecute(EntityLivingBase caster, EntityLivingBase target) {
|
||||
initMovement(caster, dashDistance, dashSpeed);
|
||||
|
||||
// Choose random direction based on mode
|
||||
DashDirection[] directions = dashMode == DashMode.AGGRESSIVE
|
||||
? AGGRESSIVE_DIRECTIONS
|
||||
: DEFENSIVE_DIRECTIONS;
|
||||
chosenDirection = directions[RANDOM.nextInt(directions.length)];
|
||||
if (dashMode == DashMode.DIRECTIONAL) {
|
||||
// Dash straight in the caster's look direction
|
||||
chosenDirection = DashDirection.FORWARD;
|
||||
setDirectionFromYaw(caster.rotationYaw);
|
||||
} else {
|
||||
// Choose random direction based on mode
|
||||
DashDirection[] directions = dashMode == DashMode.AGGRESSIVE
|
||||
? AGGRESSIVE_DIRECTIONS
|
||||
: DEFENSIVE_DIRECTIONS;
|
||||
chosenDirection = directions[RANDOM.nextInt(directions.length)];
|
||||
|
||||
// Calculate direction: base yaw (toward target or look dir) + direction offset
|
||||
float baseYaw = getBaseYaw(caster, target);
|
||||
float dashYaw = baseYaw + chosenDirection.getAngleOffset();
|
||||
setDirectionFromYaw(dashYaw);
|
||||
// Calculate direction: base yaw (toward target or look dir) + direction offset
|
||||
float baseYaw = getBaseYaw(caster, target);
|
||||
float dashYaw = baseYaw + chosenDirection.getAngleOffset();
|
||||
setDirectionFromYaw(dashYaw);
|
||||
}
|
||||
|
||||
// Small upward impulse for a skip/hop arc (gravity handles the descent)
|
||||
caster.motionY = 0.2;
|
||||
|
||||
@@ -131,7 +131,7 @@ public class AbilityEffect extends Ability implements IAbilityEffect {
|
||||
|
||||
if (instantHeal) {
|
||||
for (EntityLivingBase entity : getAffectedEntities()) {
|
||||
healEntity(entity);
|
||||
healEntity(caster, entity);
|
||||
applyAllEffects(caster, entity);
|
||||
spawnHealParticles(caster.worldObj, entity);
|
||||
}
|
||||
@@ -159,7 +159,9 @@ public class AbilityEffect extends Ability implements IAbilityEffect {
|
||||
}
|
||||
|
||||
if (totalTickHeal > 0) {
|
||||
entity.heal(totalTickHeal);
|
||||
if (!AbilityController.Instance.fireOnAbilityHeal(this, caster, entity, totalTickHeal)) {
|
||||
entity.heal(totalTickHeal);
|
||||
}
|
||||
}
|
||||
|
||||
if (tick % 20 == 0) {
|
||||
@@ -226,13 +228,15 @@ public class AbilityEffect extends Ability implements IAbilityEffect {
|
||||
}
|
||||
}
|
||||
|
||||
private void healEntity(EntityLivingBase entity) {
|
||||
private void healEntity(EntityLivingBase caster, EntityLivingBase entity) {
|
||||
float totalHeal = healAmount;
|
||||
if (healPercent > 0) {
|
||||
totalHeal += entity.getMaxHealth() * healPercent;
|
||||
}
|
||||
if (totalHeal > 0) {
|
||||
entity.heal(totalHeal);
|
||||
if (!AbilityController.Instance.fireOnAbilityHeal(this, caster, entity, totalHeal)) {
|
||||
entity.heal(totalHeal);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -66,6 +66,11 @@ public class AbilityGuard extends Ability implements IAbilityGuard {
|
||||
this.counterAnimationName = "Ability_Guard_Counter";
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean hasDamage() {
|
||||
return canCounter;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean allowBurst() {
|
||||
return false;
|
||||
|
||||
@@ -121,6 +121,10 @@ public class AbilityHeavyHit extends Ability implements IAbilityHeavyHit {
|
||||
double sideDist = dx * rightX + dz * rightZ;
|
||||
if (Math.abs(sideDist) > hitWidth) continue;
|
||||
|
||||
// Line-of-sight check: skip targets behind solid blocks or enemy barriers
|
||||
if (!hasLineOfSight(caster.worldObj, caster, livingTarget)) continue;
|
||||
if (isBlockedByBarrier(caster.worldObj, caster, livingTarget)) continue;
|
||||
|
||||
// Entity is within the rectangle - apply damage
|
||||
boolean wasHit = applyAbilityDamage(caster, livingTarget, damage, knockback);
|
||||
if (wasHit) {
|
||||
|
||||
@@ -2,6 +2,8 @@ package kamkeel.npcs.controllers.data.ability.type;
|
||||
|
||||
import kamkeel.npcs.controllers.data.ability.Ability;
|
||||
import net.minecraft.entity.EntityLivingBase;
|
||||
import net.minecraft.entity.player.EntityPlayerMP;
|
||||
import net.minecraft.network.play.server.S12PacketEntityVelocity;
|
||||
import net.minecraft.util.Vec3;
|
||||
|
||||
/**
|
||||
@@ -25,7 +27,7 @@ public abstract class AbilityMovement extends Ability {
|
||||
* Until the round trip completes, the server sees the old (stationary) position,
|
||||
* which would falsely trigger stall detection.
|
||||
*/
|
||||
private static final int PLAYER_STALL_GRACE_TICKS = 5;
|
||||
private static final int PLAYER_STALL_GRACE_TICKS = 8;
|
||||
private static final int NPC_STALL_GRACE_TICKS = 2;
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
@@ -213,6 +215,24 @@ public abstract class AbilityMovement extends Ability {
|
||||
// VELOCITY APPLICATION
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
|
||||
/**
|
||||
* Send an authoritative velocity packet to a player.
|
||||
* <p>
|
||||
* The ability tick runs BEFORE moveEntityWithHeading (at PlayerTickEvent.START).
|
||||
* If we use velocityChanged, the entity tracker sends S12 AFTER friction has
|
||||
* reduced the motion (~55% of set value). The client then moves at reduced speed,
|
||||
* reports a short position via C04, and the server resets to the client's position.
|
||||
* <p>
|
||||
* By sending S12 manually here — before friction — the client receives the full
|
||||
* velocity and moves at the correct speed.
|
||||
*/
|
||||
private void sendPlayerVelocity(EntityLivingBase caster) {
|
||||
if (caster instanceof EntityPlayerMP) {
|
||||
((EntityPlayerMP) caster).playerNetServerHandler.sendPacket(
|
||||
new S12PacketEntityVelocity(caster));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Apply movement velocity to the caster (horizontal only, Y unchanged).
|
||||
*/
|
||||
@@ -220,7 +240,11 @@ public abstract class AbilityMovement extends Ability {
|
||||
caster.motionX = movementDirection.xCoord * speed;
|
||||
caster.motionZ = movementDirection.zCoord * speed;
|
||||
if (!isPreview()) {
|
||||
caster.velocityChanged = true;
|
||||
if (caster instanceof EntityPlayerMP) {
|
||||
sendPlayerVelocity(caster);
|
||||
} else {
|
||||
caster.velocityChanged = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -233,7 +257,11 @@ public abstract class AbilityMovement extends Ability {
|
||||
caster.motionY = 0;
|
||||
caster.motionZ = movementDirection.zCoord * speed;
|
||||
if (!isPreview()) {
|
||||
caster.velocityChanged = true;
|
||||
if (caster instanceof EntityPlayerMP) {
|
||||
sendPlayerVelocity(caster);
|
||||
} else {
|
||||
caster.velocityChanged = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -244,7 +272,11 @@ public abstract class AbilityMovement extends Ability {
|
||||
caster.motionX = 0;
|
||||
caster.motionZ = 0;
|
||||
if (!isPreview()) {
|
||||
caster.velocityChanged = true;
|
||||
if (caster instanceof EntityPlayerMP) {
|
||||
sendPlayerVelocity(caster);
|
||||
} else {
|
||||
caster.velocityChanged = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -41,10 +41,24 @@ public class AbilitySlam extends Ability implements IAbilitySlam {
|
||||
private float leapSpeed = 1.0f;
|
||||
private float leapHeight = 4.0f;
|
||||
|
||||
/**
|
||||
* Grace period (in active ticks) before landing detection activates.
|
||||
* Players need more time because:
|
||||
* - Server sets motionY and sends S12 velocity packet to client
|
||||
* - Client receives S12 and starts moving upward
|
||||
* - Client sends C03 position packet back to server with onGround=false
|
||||
* Until the round trip completes, the server's player.onGround (from stale C03)
|
||||
* remains true, which would falsely trigger landing detection.
|
||||
*/
|
||||
private static final int PLAYER_LANDING_GRACE_TICKS = 10;
|
||||
private static final int NPC_LANDING_GRACE_TICKS = 3;
|
||||
|
||||
// Runtime state
|
||||
private transient double targetX, targetY, targetZ;
|
||||
private transient double startY; // Y position at launch for rise detection
|
||||
private transient boolean hasLaunched = false;
|
||||
private transient boolean hasLanded = false;
|
||||
private transient boolean hasRisen = false; // Whether entity has risen above launch position
|
||||
private transient int airTicks = 0;
|
||||
private transient int maxAirTicks = 60; // Timeout to prevent stuck in air
|
||||
|
||||
@@ -118,7 +132,9 @@ public class AbilitySlam extends Ability implements IAbilitySlam {
|
||||
public void onExecute(EntityLivingBase caster, EntityLivingBase target) {
|
||||
hasLaunched = false;
|
||||
hasLanded = false;
|
||||
hasRisen = false;
|
||||
airTicks = 0;
|
||||
startY = caster.posY;
|
||||
caster.fallDistance = 0;
|
||||
|
||||
if (isPlayerCaster(caster)) {
|
||||
@@ -297,9 +313,33 @@ public class AbilitySlam extends Ability implements IAbilitySlam {
|
||||
caster.fallDistance = 0;
|
||||
}
|
||||
|
||||
// Check for landing: hit the ground or hit a wall mid-flight
|
||||
if (airTicks > 3) {
|
||||
if (caster.onGround || caster.isCollidedHorizontally) {
|
||||
// Prevent NPC navigator from interfering with ballistic arc.
|
||||
// lockMovement=WINDUP means applyMovementControl() doesn't clear
|
||||
// the navigator during ACTIVE, so AI pathfinding could add motion.
|
||||
if (!isPreview() && caster instanceof EntityNPCInterface) {
|
||||
((EntityNPCInterface) caster).getNavigator().clearPathEntity();
|
||||
}
|
||||
|
||||
// Track if entity has risen above launch position.
|
||||
// This prevents premature landing detection for players, where
|
||||
// server-side caster.onGround remains true from stale C03 packets
|
||||
// until the velocity S12 round-trip completes (can take 4-8+ ticks).
|
||||
if (!hasRisen && caster.posY > startY + 0.5) {
|
||||
hasRisen = true;
|
||||
}
|
||||
|
||||
// Landing detection uses different grace periods for NPC vs Player.
|
||||
// NPCs: server physics is authoritative, onGround is accurate after 3 ticks.
|
||||
// Players: onGround depends on C03 packets, needs longer grace + rise confirmation.
|
||||
int graceTicks = isPlayerCaster(caster) ? PLAYER_LANDING_GRACE_TICKS : NPC_LANDING_GRACE_TICKS;
|
||||
if (airTicks > graceTicks) {
|
||||
if (hasRisen && (caster.onGround || caster.isCollidedHorizontally)) {
|
||||
onLanding(caster, caster.worldObj);
|
||||
return;
|
||||
}
|
||||
// Safety: if entity hasn't risen after triple the grace period,
|
||||
// the launch may have failed (blocked by ceiling, etc.) - force landing
|
||||
if (!hasRisen && airTicks > graceTicks * 3) {
|
||||
onLanding(caster, caster.worldObj);
|
||||
return;
|
||||
}
|
||||
@@ -424,6 +464,7 @@ public class AbilitySlam extends Ability implements IAbilitySlam {
|
||||
}
|
||||
hasLaunched = false;
|
||||
hasLanded = false;
|
||||
hasRisen = false;
|
||||
airTicks = 0;
|
||||
}
|
||||
|
||||
@@ -434,6 +475,15 @@ public class AbilitySlam extends Ability implements IAbilitySlam {
|
||||
}
|
||||
hasLaunched = false;
|
||||
hasLanded = false;
|
||||
hasRisen = false;
|
||||
airTicks = 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void cleanup() {
|
||||
hasLaunched = false;
|
||||
hasLanded = false;
|
||||
hasRisen = false;
|
||||
airTicks = 0;
|
||||
}
|
||||
|
||||
@@ -442,6 +492,7 @@ public class AbilitySlam extends Ability implements IAbilitySlam {
|
||||
super.reset();
|
||||
hasLaunched = false;
|
||||
hasLanded = false;
|
||||
hasRisen = false;
|
||||
airTicks = 0;
|
||||
}
|
||||
|
||||
|
||||
@@ -67,7 +67,7 @@ public abstract class AbilityZone extends Ability {
|
||||
this.maxRange = 20.0f;
|
||||
this.lockMovement = LockMovementType.WINDUP;
|
||||
this.cooldownTicks = 0;
|
||||
this.allowedBy = UserType.NPC_ONLY;
|
||||
this.allowedBy = UserType.BOTH;
|
||||
}
|
||||
|
||||
@Override
|
||||
@@ -75,6 +75,17 @@ public abstract class AbilityZone extends Ability {
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean allowFreeOnCast() {
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void detach() {
|
||||
activeEntities.clear();
|
||||
preCalculatedPositions.clear();
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isTargetingModeLocked() {
|
||||
return true;
|
||||
@@ -130,6 +141,12 @@ public abstract class AbilityZone extends Ability {
|
||||
|
||||
@Override
|
||||
public void onActiveTick(EntityLivingBase caster, EntityLivingBase target, int tick) {
|
||||
// Free on Cast: complete immediately — zones live independently
|
||||
if (isFreeOnCast()) {
|
||||
signalCompletion();
|
||||
return;
|
||||
}
|
||||
|
||||
Iterator<EntityAbilityZone> it = activeEntities.iterator();
|
||||
while (it.hasNext()) {
|
||||
EntityAbilityZone entity = it.next();
|
||||
|
||||
+54
-21
@@ -2,9 +2,10 @@ package kamkeel.npcs.controllers.data.ability.type.energy;
|
||||
|
||||
import cpw.mods.fml.relauncher.Side;
|
||||
import cpw.mods.fml.relauncher.SideOnly;
|
||||
import kamkeel.npcs.controllers.AbilityController;
|
||||
import kamkeel.npcs.controllers.data.ability.data.EnergyBarrierData;
|
||||
import kamkeel.npcs.controllers.data.ability.data.EnergyDisplayData;
|
||||
import kamkeel.npcs.entity.EntityEnergyBarrier;
|
||||
import kamkeel.npcs.entity.EntityAbilityBarrier;
|
||||
import net.minecraft.entity.EntityLivingBase;
|
||||
import net.minecraft.nbt.NBTTagCompound;
|
||||
import net.minecraft.util.DamageSource;
|
||||
@@ -16,14 +17,14 @@ import java.util.List;
|
||||
* Abstract base for energy barrier abilities (Dome, Wall, Shield).
|
||||
* Handles shared visual data, barrier configuration, and lifecycle management.
|
||||
*/
|
||||
public abstract class AbilityEnergyBarrier extends AbilityEnergy {
|
||||
public abstract class AbilityBarrier extends AbilityEnergy {
|
||||
|
||||
protected final EnergyBarrierData barrierData;
|
||||
|
||||
// Runtime entity tracking
|
||||
protected transient EntityEnergyBarrier barrierEntity;
|
||||
protected transient EntityAbilityBarrier barrierEntity;
|
||||
|
||||
protected AbilityEnergyBarrier(EnergyDisplayData displayData, EnergyBarrierData barrierData) {
|
||||
protected AbilityBarrier(EnergyDisplayData displayData, EnergyBarrierData barrierData) {
|
||||
super(displayData);
|
||||
this.barrierData = barrierData;
|
||||
}
|
||||
@@ -33,7 +34,7 @@ public abstract class AbilityEnergyBarrier extends AbilityEnergy {
|
||||
/**
|
||||
* Create and spawn the barrier entity during execution.
|
||||
*/
|
||||
protected abstract EntityEnergyBarrier createBarrierEntity(EntityLivingBase caster, EntityLivingBase target);
|
||||
protected abstract EntityAbilityBarrier createBarrierEntity(EntityLivingBase caster, EntityLivingBase target);
|
||||
|
||||
/**
|
||||
* Add type-specific GUI field definitions.
|
||||
@@ -63,6 +64,16 @@ public abstract class AbilityEnergyBarrier extends AbilityEnergy {
|
||||
return false; // Barriers are defensive
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean allowFreeOnCast() {
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void detach() {
|
||||
barrierEntity = null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onWindUpTick(EntityLivingBase caster, EntityLivingBase target, int tick) {
|
||||
if (caster.worldObj.isRemote) return;
|
||||
@@ -70,6 +81,7 @@ public abstract class AbilityEnergyBarrier extends AbilityEnergy {
|
||||
if (tick == 1) {
|
||||
barrierEntity = createBarrierEntity(caster, target);
|
||||
if (barrierEntity != null) {
|
||||
applyBarrierHealthModifiers(caster);
|
||||
barrierEntity.setupCharging(getWindUpTicks());
|
||||
spawnAbilityEntity(barrierEntity);
|
||||
}
|
||||
@@ -85,6 +97,7 @@ public abstract class AbilityEnergyBarrier extends AbilityEnergy {
|
||||
// No windup or entity died — create fresh
|
||||
barrierEntity = createBarrierEntity(caster, target);
|
||||
if (barrierEntity != null) {
|
||||
applyBarrierHealthModifiers(caster);
|
||||
spawnAbilityEntity(barrierEntity);
|
||||
}
|
||||
}
|
||||
@@ -97,6 +110,12 @@ public abstract class AbilityEnergyBarrier extends AbilityEnergy {
|
||||
return;
|
||||
}
|
||||
|
||||
// Free on Cast: complete immediately after barrier becomes active
|
||||
if (isFreeOnCast()) {
|
||||
signalCompletion();
|
||||
return;
|
||||
}
|
||||
|
||||
// Duration tracked by entity itself, but check here too as a failsafe
|
||||
if (barrierData.useDuration && tick >= barrierData.durationTicks) {
|
||||
cleanup();
|
||||
@@ -108,6 +127,16 @@ public abstract class AbilityEnergyBarrier extends AbilityEnergy {
|
||||
public void onComplete(EntityLivingBase caster, EntityLivingBase target) {
|
||||
}
|
||||
|
||||
/**
|
||||
* Allow extenders to modify the barrier's max health at spawn time.
|
||||
*/
|
||||
private void applyBarrierHealthModifiers(EntityLivingBase caster) {
|
||||
float modHealth = AbilityController.Instance.fireModifyBarrierHealth(this, caster, barrierData.maxHealth);
|
||||
if (modHealth != barrierData.maxHealth) {
|
||||
barrierEntity.setBarrierMaxHealth(modHealth);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onInterrupt(EntityLivingBase caster, DamageSource source, float damage) {
|
||||
cleanup();
|
||||
@@ -190,6 +219,15 @@ public abstract class AbilityEnergyBarrier extends AbilityEnergy {
|
||||
return barrierData.getMultiplier(typeId);
|
||||
}
|
||||
|
||||
// Solid data
|
||||
public boolean isSolid() {
|
||||
return barrierData.solid;
|
||||
}
|
||||
|
||||
public void setSolid(boolean solid) {
|
||||
barrierData.solid = solid;
|
||||
}
|
||||
|
||||
// Knockback data
|
||||
public boolean isKnockbackEnabled() {
|
||||
return barrierData.knockbackEnabled;
|
||||
@@ -207,12 +245,13 @@ public abstract class AbilityEnergyBarrier extends AbilityEnergy {
|
||||
barrierData.knockbackStrength = strength;
|
||||
}
|
||||
|
||||
public String getKnockbackTargetKey() {
|
||||
return barrierData.getKnockbackTargetKey();
|
||||
// Absorbing data
|
||||
public boolean isAbsorbing() {
|
||||
return barrierData.absorbing;
|
||||
}
|
||||
|
||||
public void setKnockbackTargetKey(String key) {
|
||||
barrierData.setKnockbackTargetFromKey(key);
|
||||
public void setAbsorbing(boolean absorbing) {
|
||||
barrierData.absorbing = absorbing;
|
||||
}
|
||||
|
||||
// Melee data
|
||||
@@ -250,19 +289,13 @@ public abstract class AbilityEnergyBarrier extends AbilityEnergy {
|
||||
.range(1, 12000).visibleWhen(this::isUseDuration));
|
||||
defs.add(FieldDef.floatField("ability.defaultMultiplier", this::getDefaultMultiplier, this::setDefaultMultiplier));
|
||||
|
||||
// Knockback section
|
||||
defs.add(FieldDef.section("ability.section.knockback"));
|
||||
// Properties section
|
||||
defs.add(FieldDef.section("ability.section.properties"));
|
||||
defs.add(FieldDef.boolField("ability.solid", this::isSolid, this::setSolid));
|
||||
defs.add(FieldDef.boolField("ability.knockbackEnabled", this::isKnockbackEnabled, this::setKnockbackEnabled));
|
||||
defs.add(FieldDef.row(
|
||||
FieldDef.floatField("ability.knockbackStrength", this::getKnockbackStrength, this::setKnockbackStrength)
|
||||
.range(0, 10).visibleWhen(this::isKnockbackEnabled),
|
||||
FieldDef.stringEnumField("ability.knockbackTarget", EnergyBarrierData.getKnockbackTargetKeys(),
|
||||
this::getKnockbackTargetKey, this::setKnockbackTargetKey)
|
||||
.visibleWhen(this::isKnockbackEnabled)
|
||||
));
|
||||
|
||||
// Melee section
|
||||
defs.add(FieldDef.section("ability.section.melee"));
|
||||
defs.add(FieldDef.floatField("ability.knockbackStrength", this::getKnockbackStrength, this::setKnockbackStrength)
|
||||
.range(0, 10).visibleWhen(this::isKnockbackEnabled));
|
||||
defs.add(FieldDef.boolField("ability.absorbing", this::isAbsorbing, this::setAbsorbing));
|
||||
defs.add(FieldDef.boolField("ability.meleeEnabled", this::isMeleeEnabled, this::setMeleeEnabled));
|
||||
defs.add(FieldDef.floatField("ability.meleeDamageMultiplier", this::getMeleeDamageMultiplier, this::setMeleeDamageMultiplier)
|
||||
.range(0, 10).visibleWhen(this::isMeleeEnabled));
|
||||
@@ -48,8 +48,8 @@ public class AbilityBeam extends AbilityEnergyProjectile<EntityAbilityBeam> impl
|
||||
this.cooldownTicks = 0;
|
||||
this.windUpTicks = 40;
|
||||
this.lockMovement = LockMovementType.WINDUP_AND_ACTIVE;
|
||||
this.rotationMode = RotationMode.TRACK;
|
||||
this.rotationPhase = LockMovementType.WINDUP_AND_ACTIVE;
|
||||
this.rotationMode = RotationMode.LOCKED;
|
||||
this.rotationPhase = LockMovementType.ACTIVE;
|
||||
this.telegraphType = TelegraphType.CIRCLE;
|
||||
this.showTelegraph = true;
|
||||
this.windUpAnimationName = "Ability_Beam_Windup";
|
||||
|
||||
@@ -8,8 +8,8 @@ import kamkeel.npcs.controllers.data.ability.TargetingMode;
|
||||
import kamkeel.npcs.controllers.data.ability.data.EnergyBarrierData;
|
||||
import kamkeel.npcs.controllers.data.ability.data.EnergyDisplayData;
|
||||
import kamkeel.npcs.controllers.data.telegraph.TelegraphType;
|
||||
import kamkeel.npcs.entity.EntityEnergyBarrier;
|
||||
import kamkeel.npcs.entity.EntityEnergyDome;
|
||||
import kamkeel.npcs.entity.EntityAbilityBarrier;
|
||||
import kamkeel.npcs.entity.EntityAbilityDome;
|
||||
import net.minecraft.entity.EntityLivingBase;
|
||||
import net.minecraft.nbt.NBTTagCompound;
|
||||
import noppes.npcs.client.gui.builder.FieldDef;
|
||||
@@ -22,7 +22,7 @@ import java.util.List;
|
||||
* Blocks incoming energy projectiles with configurable damage multipliers.
|
||||
* Duration and/or HP based.
|
||||
*/
|
||||
public class AbilityDome extends AbilityEnergyBarrier {
|
||||
public class AbilityDome extends AbilityBarrier {
|
||||
|
||||
private float domeRadius = 5.0f;
|
||||
private boolean followCaster = false;
|
||||
@@ -47,8 +47,8 @@ public class AbilityDome extends AbilityEnergyBarrier {
|
||||
// ==================== ABSTRACT IMPLEMENTATIONS ====================
|
||||
|
||||
@Override
|
||||
protected EntityEnergyBarrier createBarrierEntity(EntityLivingBase caster, EntityLivingBase target) {
|
||||
EntityEnergyDome dome = new EntityEnergyDome(
|
||||
protected EntityAbilityBarrier createBarrierEntity(EntityLivingBase caster, EntityLivingBase target) {
|
||||
EntityAbilityDome dome = new EntityAbilityDome(
|
||||
caster.worldObj, caster,
|
||||
caster.posX, caster.posY, caster.posZ,
|
||||
domeRadius, displayData.copy(), lightningData.copy(), barrierData.copy()
|
||||
|
||||
+19
@@ -244,6 +244,16 @@ public abstract class AbilityEnergyProjectile<E extends EntityEnergyProjectile>
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean allowFreeOnCast() {
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void detach() {
|
||||
entities = null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isReadyForBurstCompletion(int activeTick) {
|
||||
return fireDelay <= 0 || activeTick >= fireDelay * (projectileCount - 1);
|
||||
@@ -338,6 +348,15 @@ public abstract class AbilityEnergyProjectile<E extends EntityEnergyProjectile>
|
||||
}
|
||||
}
|
||||
|
||||
// Free on Cast: complete once all projectiles have been fired
|
||||
if (isFreeOnCast()) {
|
||||
int lastFireTick = fireDelay > 0 ? fireDelay * (projectileCount - 1) : 0;
|
||||
if (tick >= lastFireTick) {
|
||||
signalCompletion();
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// Check if all entities are dead or unreachable
|
||||
boolean allDead = true;
|
||||
for (E entity : entities) {
|
||||
|
||||
@@ -115,6 +115,9 @@ public class AbilityOrb extends AbilityEnergyProjectile<EntityAbilityOrb> implem
|
||||
orb.setDamage(4.0f);
|
||||
orb.setKnockback(0.0f);
|
||||
orb.setKnockbackUp(0.0f);
|
||||
orb.setProjectileCount(2);
|
||||
orb.setFireDelay(2);
|
||||
a.setLockMovement(LockMovementType.WINDUP_AND_ACTIVE);
|
||||
a.setMaxRange(75.0f);
|
||||
a.setBurstEnabled(true);
|
||||
a.setBurstAmount(15);
|
||||
|
||||
@@ -10,8 +10,8 @@ import kamkeel.npcs.controllers.data.ability.data.EnergyBarrierData;
|
||||
import kamkeel.npcs.controllers.data.ability.data.EnergyDisplayData;
|
||||
import kamkeel.npcs.controllers.data.ability.data.EnergyPanelData;
|
||||
import kamkeel.npcs.controllers.data.telegraph.TelegraphType;
|
||||
import kamkeel.npcs.entity.EntityEnergyBarrier;
|
||||
import kamkeel.npcs.entity.EntityEnergyPanel;
|
||||
import kamkeel.npcs.entity.EntityAbilityBarrier;
|
||||
import kamkeel.npcs.entity.EntityAbilityPanel;
|
||||
import net.minecraft.entity.EntityLivingBase;
|
||||
import net.minecraft.nbt.NBTTagCompound;
|
||||
import noppes.npcs.client.gui.builder.FieldDef;
|
||||
@@ -24,7 +24,7 @@ import java.util.List;
|
||||
* The shield follows the caster's position and rotates with their look direction.
|
||||
* Cannot be placed — it's always held.
|
||||
*/
|
||||
public class AbilityShield extends AbilityEnergyBarrier {
|
||||
public class AbilityShield extends AbilityBarrier {
|
||||
|
||||
private float shieldWidth = 2.5f;
|
||||
private float shieldHeight = 2.5f;
|
||||
@@ -50,7 +50,7 @@ public class AbilityShield extends AbilityEnergyBarrier {
|
||||
// ==================== ABSTRACT IMPLEMENTATIONS ====================
|
||||
|
||||
@Override
|
||||
protected EntityEnergyBarrier createBarrierEntity(EntityLivingBase caster, EntityLivingBase target) {
|
||||
protected EntityAbilityBarrier createBarrierEntity(EntityLivingBase caster, EntityLivingBase target) {
|
||||
EnergyPanelData panelData = new EnergyPanelData(shieldWidth, shieldHeight, 0.0f);
|
||||
|
||||
float frontDist = 1.5f;
|
||||
@@ -59,10 +59,10 @@ public class AbilityShield extends AbilityEnergyBarrier {
|
||||
double spawnY = caster.posY + (caster.height * 0.5f);
|
||||
double spawnZ = caster.posZ + (Math.cos(yawRad) * frontDist);
|
||||
|
||||
EntityEnergyPanel panel = new EntityEnergyPanel(
|
||||
EntityAbilityPanel panel = new EntityAbilityPanel(
|
||||
caster.worldObj, caster,
|
||||
spawnX, spawnY, spawnZ, caster.rotationYaw,
|
||||
EntityEnergyPanel.PanelMode.HELD,
|
||||
EntityAbilityPanel.PanelMode.HELD,
|
||||
displayData.copy(), lightningData.copy(), barrierData.copy(), panelData
|
||||
);
|
||||
panel.setSourceAbility(this);
|
||||
|
||||
+22
-1
@@ -31,7 +31,7 @@ public class AbilitySweeper extends AbilityEnergy implements IAbilitySweeper {
|
||||
// Type-specific parameters
|
||||
private float beamLength = 10.0f;
|
||||
private float beamWidth = 0.3f; // Thin like beam trail
|
||||
private float beamHeight = 0.5f; // Height above ground (low enough to jump over)
|
||||
private float beamHeight = 1.0f; // Beam vertical size in blocks (1 block tall, jumpable)
|
||||
private float damage = 5.0f;
|
||||
private int damageInterval = 5;
|
||||
private boolean piercing = true;
|
||||
@@ -62,6 +62,21 @@ public class AbilitySweeper extends AbilityEnergy implements IAbilitySweeper {
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isConcurrentCapable() {
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean allowFreeOnCast() {
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void detach() {
|
||||
activeEntity = null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isTargetingModeLocked() {
|
||||
return true;
|
||||
@@ -97,6 +112,12 @@ public class AbilitySweeper extends AbilityEnergy implements IAbilitySweeper {
|
||||
if (activeEntity == null || activeEntity.isDead) {
|
||||
activeEntity = null;
|
||||
signalCompletion();
|
||||
return;
|
||||
}
|
||||
|
||||
// Free on Cast: complete immediately — sweeper lives independently
|
||||
if (isFreeOnCast()) {
|
||||
signalCompletion();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -9,8 +9,8 @@ import kamkeel.npcs.controllers.data.ability.data.EnergyBarrierData;
|
||||
import kamkeel.npcs.controllers.data.ability.data.EnergyDisplayData;
|
||||
import kamkeel.npcs.controllers.data.ability.data.EnergyPanelData;
|
||||
import kamkeel.npcs.controllers.data.telegraph.TelegraphType;
|
||||
import kamkeel.npcs.entity.EntityEnergyBarrier;
|
||||
import kamkeel.npcs.entity.EntityEnergyPanel;
|
||||
import kamkeel.npcs.entity.EntityAbilityBarrier;
|
||||
import kamkeel.npcs.entity.EntityAbilityPanel;
|
||||
import net.minecraft.entity.EntityLivingBase;
|
||||
import net.minecraft.nbt.NBTTagCompound;
|
||||
import noppes.npcs.client.gui.builder.FieldDef;
|
||||
@@ -23,7 +23,7 @@ import java.util.List;
|
||||
* Can float above ground (configurable height offset).
|
||||
* Optional launching mode fires the wall forward with damage/knockback.
|
||||
*/
|
||||
public class AbilityWall extends AbilityEnergyBarrier {
|
||||
public class AbilityWall extends AbilityBarrier {
|
||||
|
||||
private final EnergyPanelData panelData;
|
||||
|
||||
@@ -55,7 +55,7 @@ public class AbilityWall extends AbilityEnergyBarrier {
|
||||
// ==================== ABSTRACT IMPLEMENTATIONS ====================
|
||||
|
||||
@Override
|
||||
protected EntityEnergyBarrier createBarrierEntity(EntityLivingBase caster, EntityLivingBase target) {
|
||||
protected EntityAbilityBarrier createBarrierEntity(EntityLivingBase caster, EntityLivingBase target) {
|
||||
// Place wall between caster and target
|
||||
double placeX, placeY, placeZ;
|
||||
float yaw;
|
||||
@@ -87,11 +87,11 @@ public class AbilityWall extends AbilityEnergyBarrier {
|
||||
yaw = caster.rotationYaw;
|
||||
}
|
||||
|
||||
EntityEnergyPanel.PanelMode mode = panelData.launching
|
||||
? EntityEnergyPanel.PanelMode.LAUNCHED
|
||||
: EntityEnergyPanel.PanelMode.PLACED;
|
||||
EntityAbilityPanel.PanelMode mode = panelData.launching
|
||||
? EntityAbilityPanel.PanelMode.LAUNCHED
|
||||
: EntityAbilityPanel.PanelMode.PLACED;
|
||||
|
||||
EntityEnergyPanel panel = new EntityEnergyPanel(
|
||||
EntityAbilityPanel panel = new EntityAbilityPanel(
|
||||
caster.worldObj, caster,
|
||||
placeX, placeY, placeZ, yaw, mode,
|
||||
displayData.copy(), lightningData.copy(), barrierData.copy(), panelData.copy()
|
||||
|
||||
@@ -33,6 +33,7 @@ public class TelegraphInstance {
|
||||
private int entityIdToFollow = -1;
|
||||
private int casterEntityId = -1;
|
||||
private int targetEntityId = -1; // For LINE telegraphs: entity to face (yaw tracking)
|
||||
private boolean trackFollowedEntityYaw = false; // Track followed entity's rotationYaw when no targetEntity
|
||||
|
||||
// Timing
|
||||
private int remainingTicks;
|
||||
@@ -96,6 +97,11 @@ public class TelegraphInstance {
|
||||
this.z = entity.posZ;
|
||||
// Find ground level below the entity for proper telegraph placement
|
||||
this.y = Ability.findGroundLevel(world, entity.posX, entity.posY, entity.posZ);
|
||||
|
||||
// Track followed entity's yaw for directional telegraphs (player casters)
|
||||
if (trackFollowedEntityYaw && targetEntityId < 0) {
|
||||
this.yaw = entity.rotationYaw;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -218,6 +224,7 @@ public class TelegraphInstance {
|
||||
nbt.setInteger("entityIdToFollow", entityIdToFollow);
|
||||
nbt.setInteger("casterEntityId", casterEntityId);
|
||||
nbt.setInteger("targetEntityId", targetEntityId);
|
||||
nbt.setBoolean("trackFollowedYaw", trackFollowedEntityYaw);
|
||||
|
||||
nbt.setInteger("remainingTicks", remainingTicks);
|
||||
nbt.setInteger("totalTicks", totalTicks);
|
||||
@@ -243,6 +250,7 @@ public class TelegraphInstance {
|
||||
this.entityIdToFollow = nbt.getInteger("entityIdToFollow");
|
||||
this.casterEntityId = nbt.getInteger("casterEntityId");
|
||||
this.targetEntityId = nbt.getInteger("targetEntityId");
|
||||
this.trackFollowedEntityYaw = nbt.hasKey("trackFollowedYaw") && nbt.getBoolean("trackFollowedYaw");
|
||||
|
||||
this.remainingTicks = nbt.getInteger("remainingTicks");
|
||||
this.totalTicks = nbt.getInteger("totalTicks");
|
||||
@@ -335,6 +343,14 @@ public class TelegraphInstance {
|
||||
this.targetEntityId = targetEntityId;
|
||||
}
|
||||
|
||||
public boolean isTrackFollowedEntityYaw() {
|
||||
return trackFollowedEntityYaw;
|
||||
}
|
||||
|
||||
public void setTrackFollowedEntityYaw(boolean track) {
|
||||
this.trackFollowedEntityYaw = track;
|
||||
}
|
||||
|
||||
public int getRemainingTicks() {
|
||||
return remainingTicks;
|
||||
}
|
||||
|
||||
+198
-14
@@ -1,22 +1,57 @@
|
||||
package kamkeel.npcs.entity;
|
||||
|
||||
import kamkeel.npcs.controllers.data.ability.AbilityTargetHelper;
|
||||
import kamkeel.npcs.controllers.data.ability.data.EnergyBarrierData;
|
||||
import net.minecraft.entity.Entity;
|
||||
import net.minecraft.entity.EntityLivingBase;
|
||||
import net.minecraft.entity.player.EntityPlayer;
|
||||
import net.minecraft.entity.player.EntityPlayerMP;
|
||||
import net.minecraft.nbt.NBTTagCompound;
|
||||
import net.minecraft.util.DamageSource;
|
||||
import net.minecraft.world.World;
|
||||
import noppes.npcs.EventHooks;
|
||||
import noppes.npcs.entity.EntityNPCInterface;
|
||||
|
||||
import java.lang.ref.WeakReference;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Iterator;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Base class for energy barrier entities (Dome, Panel).
|
||||
* Provides shared health, damage, hit flash, knockback target,
|
||||
* and barrier lifecycle management.
|
||||
* Extends EntityEnergyAbility for shared visual/owner/charging state.
|
||||
*/
|
||||
public abstract class EntityEnergyBarrier extends EntityEnergyAbility {
|
||||
public abstract class EntityAbilityBarrier extends EntityEnergyAbility {
|
||||
|
||||
// ==================== ACTIVE BARRIER REGISTRY ====================
|
||||
private static final List<WeakReference<EntityAbilityBarrier>> activeBarriers = new ArrayList<>();
|
||||
private boolean tracked = false;
|
||||
|
||||
public static void trackBarrier(EntityAbilityBarrier barrier) {
|
||||
activeBarriers.add(new WeakReference<>(barrier));
|
||||
}
|
||||
|
||||
/**
|
||||
* Get all living barriers in the given world. Auto-cleans dead refs.
|
||||
*/
|
||||
public static List<EntityAbilityBarrier> getActiveBarriers(World world) {
|
||||
List<EntityAbilityBarrier> result = new ArrayList<>();
|
||||
Iterator<WeakReference<EntityAbilityBarrier>> it = activeBarriers.iterator();
|
||||
while (it.hasNext()) {
|
||||
EntityAbilityBarrier b = it.next().get();
|
||||
if (b == null || b.isDead) {
|
||||
it.remove();
|
||||
} else if (b.worldObj == world) {
|
||||
result.add(b);
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
public static void clearAllBarriers() {
|
||||
activeBarriers.clear();
|
||||
}
|
||||
|
||||
// ==================== BARRIER PROPERTIES ====================
|
||||
protected EnergyBarrierData barrierData = new EnergyBarrierData();
|
||||
@@ -27,7 +62,7 @@ public abstract class EntityEnergyBarrier extends EntityEnergyAbility {
|
||||
protected static final int DW_HEALTH_PERCENT = 21;
|
||||
protected static final int DW_HIT_FLASH = 22;
|
||||
|
||||
public EntityEnergyBarrier(World world) {
|
||||
public EntityAbilityBarrier(World world) {
|
||||
super(world);
|
||||
this.noClip = true;
|
||||
}
|
||||
@@ -58,9 +93,69 @@ public abstract class EntityEnergyBarrier extends EntityEnergyAbility {
|
||||
public abstract void finishCharging();
|
||||
|
||||
/**
|
||||
* Push entities away from the barrier surface.
|
||||
* Process entity physics for this barrier.
|
||||
* Handles solid wall (entity repositioning) and knockback (repulsion force).
|
||||
*/
|
||||
protected abstract void knockbackEntities();
|
||||
protected abstract void processEntityPhysics();
|
||||
|
||||
/**
|
||||
* Get the maximum extent of this barrier for distance pre-filtering.
|
||||
* Dome returns radius, Panel returns max(width, height) / 2.
|
||||
*/
|
||||
public abstract float getMaxExtent();
|
||||
|
||||
/**
|
||||
* Check if a generic (non-CNPC+) projectile is incoming toward this barrier.
|
||||
* Uses the same geometric logic as isIncomingProjectile but with raw position data.
|
||||
*
|
||||
* @param posX, posY, posZ Current (or predicted) position of the projectile
|
||||
* @param motionX, motionY, motionZ Current velocity of the projectile
|
||||
* @param prevPosX, prevPosY, prevPosZ Previous position of the projectile
|
||||
* @param ownerEntityId Entity ID of the projectile's shooter
|
||||
*/
|
||||
public abstract boolean isIncomingGenericProjectile(
|
||||
double posX, double posY, double posZ,
|
||||
double motionX, double motionY, double motionZ,
|
||||
double prevPosX, double prevPosY, double prevPosZ,
|
||||
int ownerEntityId);
|
||||
|
||||
// ==================== GENERIC PROJECTILE HIT ====================
|
||||
|
||||
/**
|
||||
* Apply damage from a generic (non-CNPC+) projectile to this barrier.
|
||||
* Uses the typeId for damage multiplier lookup (e.g. "dbc.ki_attack").
|
||||
*
|
||||
* @param projectileEntity The entity that hit the barrier (for context)
|
||||
* @param damage Base damage to apply
|
||||
* @param typeId Type identifier for damage multiplier lookup
|
||||
* @return true if the barrier absorbed the hit (projectile should be destroyed)
|
||||
*/
|
||||
public boolean onGenericProjectileHit(Entity projectileEntity, float damage, String typeId) {
|
||||
float multiplier = barrierData.getMultiplier(typeId);
|
||||
float finalDamage = damage * multiplier;
|
||||
|
||||
if (!worldObj.isRemote) {
|
||||
float eventDamage = EventHooks.onEnergyBarrierHit(this, ownerEntityId, null, finalDamage);
|
||||
if (eventDamage < 0) return false;
|
||||
finalDamage = eventDamage;
|
||||
}
|
||||
|
||||
triggerHitFlash();
|
||||
|
||||
if (!barrierData.useHealth) {
|
||||
return true;
|
||||
}
|
||||
|
||||
currentHealth -= finalDamage;
|
||||
syncHealthPercent();
|
||||
|
||||
if (currentHealth <= 0) {
|
||||
onBarrierDestroyed();
|
||||
this.setDead();
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
// ==================== PROJECTILE HIT ====================
|
||||
|
||||
@@ -108,6 +203,16 @@ public abstract class EntityEnergyBarrier extends EntityEnergyAbility {
|
||||
return barrierData.meleeEnabled;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isEntityInsideOpaqueBlock() {
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected boolean func_145771_j(double x, double y, double z) {
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean attackEntityFrom(DamageSource source, float amount) {
|
||||
if (worldObj.isRemote || !barrierData.meleeEnabled) return false;
|
||||
@@ -145,8 +250,12 @@ public abstract class EntityEnergyBarrier extends EntityEnergyAbility {
|
||||
*/
|
||||
protected boolean updateBarrierTick() {
|
||||
if (!worldObj.isRemote) {
|
||||
// Fire spawned event on first tick
|
||||
// Track barrier and fire spawned event on first tick
|
||||
if (ticksAlive == 1) {
|
||||
if (!tracked) {
|
||||
trackBarrier(this);
|
||||
tracked = true;
|
||||
}
|
||||
EventHooks.onEnergyBarrierSpawned(this, ownerEntityId);
|
||||
}
|
||||
|
||||
@@ -225,14 +334,79 @@ public abstract class EntityEnergyBarrier extends EntityEnergyAbility {
|
||||
return this.dataWatcher.getWatchableObjectFloat(DW_HEALTH_PERCENT);
|
||||
}
|
||||
|
||||
protected boolean isKnockbackTarget(EntityLivingBase entity) {
|
||||
switch (barrierData.knockbackTarget) {
|
||||
case 1:
|
||||
return entity instanceof EntityPlayer;
|
||||
case 2:
|
||||
return entity instanceof EntityNPCInterface;
|
||||
default:
|
||||
return entity instanceof EntityPlayer || entity instanceof EntityNPCInterface;
|
||||
/**
|
||||
* Check if an entity is an ally of this barrier's owner.
|
||||
* Allies are not affected by barrier physics.
|
||||
*/
|
||||
protected boolean isAllyOfOwner(EntityLivingBase entity) {
|
||||
Entity owner = getOwnerEntity();
|
||||
if (owner == null || !(owner instanceof EntityLivingBase)) return false;
|
||||
return AbilityTargetHelper.isAlly((EntityLivingBase) owner, entity);
|
||||
}
|
||||
|
||||
// ==================== CONTAINMENT & ABSORBING ====================
|
||||
|
||||
/**
|
||||
* Check if an entity is geometrically inside this barrier's protected zone.
|
||||
* Override in subclasses (dome checks sphere containment).
|
||||
*/
|
||||
public boolean isEntityInside(Entity entity) {
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Find a barrier that would absorb damage for the given entity (its caster).
|
||||
* Returns the barrier if: absorbing is enabled AND entity is the barrier's owner.
|
||||
*/
|
||||
public static EntityAbilityBarrier getAbsorbingBarrier(Entity entity) {
|
||||
if (entity == null || entity.worldObj == null) return null;
|
||||
List<EntityAbilityBarrier> barriers = getActiveBarriers(entity.worldObj);
|
||||
for (EntityAbilityBarrier barrier : barriers) {
|
||||
if (barrier.isDead) continue;
|
||||
if (!barrier.barrierData.absorbing) continue;
|
||||
if (barrier.ownerEntityId == entity.getEntityId()) {
|
||||
return barrier;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Absorb damage from an external source. Reduces barrier health directly.
|
||||
* Used by damage protection to redirect attacks on inside entities to the barrier.
|
||||
*
|
||||
* @param amount The damage amount to absorb
|
||||
* @return true if damage was absorbed (barrier still alive or just destroyed)
|
||||
*/
|
||||
public boolean absorbDamage(float amount) {
|
||||
if (worldObj.isRemote) return false;
|
||||
|
||||
triggerHitFlash();
|
||||
|
||||
if (!barrierData.useHealth) {
|
||||
return true; // Duration-only: absorb but no health loss
|
||||
}
|
||||
|
||||
currentHealth -= amount;
|
||||
syncHealthPercent();
|
||||
|
||||
if (currentHealth <= 0) {
|
||||
onBarrierDestroyed();
|
||||
this.setDead();
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Teleport an entity to a position. Uses network handler for players
|
||||
* to ensure reliable client synchronization.
|
||||
*/
|
||||
protected void teleportEntity(EntityLivingBase ent, double x, double y, double z) {
|
||||
if (ent instanceof EntityPlayerMP) {
|
||||
EntityPlayerMP player = (EntityPlayerMP) ent;
|
||||
player.playerNetServerHandler.setPlayerLocation(x, y, z, player.rotationYaw, player.rotationPitch);
|
||||
} else {
|
||||
ent.setPosition(x, y, z);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -251,6 +425,16 @@ public abstract class EntityEnergyBarrier extends EntityEnergyAbility {
|
||||
syncHealthPercent();
|
||||
}
|
||||
|
||||
/**
|
||||
* Override the barrier's max health and set current health to match.
|
||||
* Used by extenders (e.g., DBC scaling) to dynamically set barrier HP at spawn time.
|
||||
*/
|
||||
public void setBarrierMaxHealth(float maxHealth) {
|
||||
this.barrierData.setMaxHealth(maxHealth);
|
||||
this.currentHealth = maxHealth;
|
||||
syncHealthPercent();
|
||||
}
|
||||
|
||||
public int getTicksAlive() {
|
||||
return ticksAlive;
|
||||
}
|
||||
@@ -0,0 +1,625 @@
|
||||
package kamkeel.npcs.entity;
|
||||
|
||||
import cpw.mods.fml.relauncher.Side;
|
||||
import cpw.mods.fml.relauncher.SideOnly;
|
||||
import kamkeel.npcs.controllers.data.ability.data.EnergyBarrierData;
|
||||
import kamkeel.npcs.controllers.data.ability.data.EnergyDisplayData;
|
||||
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.util.AxisAlignedBB;
|
||||
import net.minecraft.util.DamageSource;
|
||||
import net.minecraft.util.Vec3;
|
||||
import net.minecraft.world.World;
|
||||
import noppes.npcs.CustomNpcs;
|
||||
|
||||
import java.util.HashSet;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Energy Dome entity - a spherical barrier that blocks incoming energy projectiles.
|
||||
* Centered on the caster's position at time of casting.
|
||||
* Only blocks incoming attacks (not outgoing from allies inside).
|
||||
* Extends EntityAbilityBarrier for shared barrier logic.
|
||||
*/
|
||||
public class EntityAbilityDome extends EntityAbilityBarrier {
|
||||
|
||||
// ==================== DOME-SPECIFIC PROPERTIES ====================
|
||||
protected float domeRadius = 5.0f;
|
||||
protected float targetDomeRadius = 5.0f;
|
||||
protected boolean followCaster = false;
|
||||
|
||||
// Server-side melee detection state
|
||||
private boolean inTickMelee = false;
|
||||
private final HashSet<Integer> processedMeleeSwings = new HashSet<>();
|
||||
|
||||
public EntityAbilityDome(World world) {
|
||||
super(world);
|
||||
this.noClip = true;
|
||||
this.stepHeight = 0.0F;
|
||||
this.setSize(1.0f, 1.0f);
|
||||
}
|
||||
|
||||
public EntityAbilityDome(World world, EntityLivingBase owner, double x, double y, double z,
|
||||
float domeRadius, EnergyDisplayData display, EnergyLightningData lightning,
|
||||
EnergyBarrierData barrier) {
|
||||
this(world);
|
||||
this.noClip = true;
|
||||
this.stepHeight = 0.0F;
|
||||
this.ownerEntityId = owner.getEntityId();
|
||||
this.setDomeRadius(domeRadius);
|
||||
this.displayData = display;
|
||||
this.lightningData = lightning;
|
||||
this.barrierData = barrier;
|
||||
this.currentHealth = barrier.maxHealth;
|
||||
this.setPosition(x, y, z);
|
||||
}
|
||||
|
||||
// ==================== POSITION / BOUNDING BOX ====================
|
||||
|
||||
@Override
|
||||
protected void setSize(float width, float height) {
|
||||
super.setSize(width, height);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void applyEntityCollision(Entity entityIn) {
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onUpdate() {
|
||||
this.prevPosX = this.posX;
|
||||
this.prevPosY = this.posY;
|
||||
this.prevPosZ = this.posZ;
|
||||
|
||||
super.onUpdate();
|
||||
|
||||
// Follow caster: both sides for smooth interpolated rendering
|
||||
if (followCaster) {
|
||||
Entity owner = ownerEntityId >= 0 ? worldObj.getEntityByID(ownerEntityId) : null;
|
||||
if (owner != null) {
|
||||
this.setPosition(owner.posX, owner.posY, owner.posZ);
|
||||
// Sync prevPos with owner's prevPos for smooth interpolation
|
||||
this.prevPosX = owner.prevPosX;
|
||||
this.prevPosY = owner.prevPosY;
|
||||
this.prevPosZ = owner.prevPosZ;
|
||||
}
|
||||
}
|
||||
|
||||
// Handle charging animation (both sides for smooth rendering)
|
||||
if (isCharging()) {
|
||||
chargeTick++;
|
||||
float progress = getChargeProgress();
|
||||
this.setDomeRadius(targetDomeRadius * progress);
|
||||
// Refresh BB for current charge radius
|
||||
this.setPosition(posX, posY, posZ);
|
||||
return; // Don't tick duration/death during charging
|
||||
}
|
||||
|
||||
ticksAlive++;
|
||||
|
||||
if (updateBarrierTick()) return;
|
||||
|
||||
// Server-side: detect and apply melee hits from nearby players.
|
||||
// Bypasses MC's processUseEntity reach check (which uses center-to-center
|
||||
// distance and fails for domes with radius > 5).
|
||||
if (!worldObj.isRemote && barrierData.meleeEnabled) {
|
||||
processMeleeHits();
|
||||
}
|
||||
|
||||
// Process entity physics every tick
|
||||
// Server: solid + knockback for all entities
|
||||
// Client: solid prediction for local player only (smooth movement blocking)
|
||||
if (barrierData.solid || barrierData.knockbackEnabled) {
|
||||
processEntityPhysics();
|
||||
}
|
||||
|
||||
// Client-side: adjust BB for accurate melee targeting at all approach angles.
|
||||
// Must run AFTER all position/BB updates and BEFORE getMouseOver() in the render phase.
|
||||
if (worldObj.isRemote && barrierData.meleeEnabled && !isCharging()) {
|
||||
adjustMeleeBoundingBox();
|
||||
}
|
||||
}
|
||||
|
||||
// ==================== INCOMING CHECK ====================
|
||||
|
||||
/**
|
||||
* Swept ray-sphere intersection test.
|
||||
* Tests if the line segment from prevPos to currPos crosses the dome sphere boundary
|
||||
* from outside. Handles fast projectiles that skip through in a single tick.
|
||||
*
|
||||
* @return true if the segment enters the sphere from outside
|
||||
*/
|
||||
private boolean isIncomingRay(
|
||||
double currX, double currY, double currZ,
|
||||
double prevX, double prevY, double prevZ,
|
||||
int projOwnerEntityId)
|
||||
{
|
||||
if (isCharging()) return false;
|
||||
if (projOwnerEntityId == this.ownerEntityId) return false;
|
||||
|
||||
// Ray: P(t) = prev + t * (curr - prev), t in [0, 1]
|
||||
double rayDirX = currX - prevX;
|
||||
double rayDirY = currY - prevY;
|
||||
double rayDirZ = currZ - prevZ;
|
||||
|
||||
// Vector from dome center to ray origin (prevPos)
|
||||
double ocX = prevX - this.posX;
|
||||
double ocY = prevY - this.posY;
|
||||
double ocZ = prevZ - this.posZ;
|
||||
|
||||
double r = domeRadius;
|
||||
|
||||
// Quadratic: a*t^2 + b*t + c = 0
|
||||
double a = rayDirX * rayDirX + rayDirY * rayDirY + rayDirZ * rayDirZ;
|
||||
double b = 2.0 * (ocX * rayDirX + ocY * rayDirY + ocZ * rayDirZ);
|
||||
double c = (ocX * ocX + ocY * ocY + ocZ * ocZ) - r * r;
|
||||
|
||||
// c > 0: prevPos is outside sphere; c <= 0: inside (don't block)
|
||||
if (c <= 0) return false;
|
||||
|
||||
if (a < 1e-10) return false; // No movement
|
||||
|
||||
double discriminant = b * b - 4.0 * a * c;
|
||||
if (discriminant < 0) return false; // Ray misses sphere entirely
|
||||
|
||||
double sqrtDisc = Math.sqrt(discriminant);
|
||||
double t1 = (-b - sqrtDisc) / (2.0 * a); // Entry point (first intersection)
|
||||
|
||||
// Entry must be within this tick's movement segment [0, 1]
|
||||
return t1 >= 0.0 && t1 <= 1.0;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isIncomingProjectile(EntityEnergyProjectile projectile) {
|
||||
// Faction check: don't block same-faction NPC projectiles
|
||||
Entity owner = getOwnerEntity();
|
||||
Entity projOwner = projectile.getOwnerEntity();
|
||||
if (owner instanceof noppes.npcs.entity.EntityNPCInterface && projOwner instanceof noppes.npcs.entity.EntityNPCInterface) {
|
||||
if (((noppes.npcs.entity.EntityNPCInterface) owner).faction.id == ((noppes.npcs.entity.EntityNPCInterface) projOwner).faction.id) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
double prevX = projectile.posX - projectile.motionX;
|
||||
double prevY = projectile.posY - projectile.motionY;
|
||||
double prevZ = projectile.posZ - projectile.motionZ;
|
||||
|
||||
return isIncomingRay(
|
||||
projectile.posX, projectile.posY, projectile.posZ,
|
||||
prevX, prevY, prevZ,
|
||||
projectile.getOwnerEntityId());
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isIncomingGenericProjectile(
|
||||
double posX, double posY, double posZ,
|
||||
double motionX, double motionY, double motionZ,
|
||||
double prevPosX, double prevPosY, double prevPosZ,
|
||||
int ownerEntityId)
|
||||
{
|
||||
return isIncomingRay(posX, posY, posZ, prevPosX, prevPosY, prevPosZ, ownerEntityId);
|
||||
}
|
||||
|
||||
@Override
|
||||
public float getMaxExtent() {
|
||||
return domeRadius;
|
||||
}
|
||||
|
||||
// ==================== CHARGING ====================
|
||||
|
||||
@Override
|
||||
public void setupCharging(int duration) {
|
||||
this.targetDomeRadius = this.domeRadius;
|
||||
this.setDomeRadius(0.01f);
|
||||
this.chargeDuration = duration;
|
||||
this.chargeTick = 0;
|
||||
setCharging(true);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void finishCharging() {
|
||||
this.setDomeRadius(this.targetDomeRadius);
|
||||
setCharging(false);
|
||||
}
|
||||
|
||||
// ==================== ENTITY PHYSICS (Solid + Knockback) ====================
|
||||
|
||||
/**
|
||||
* Processes entity physics for the dome barrier. Two independent systems:
|
||||
* <p>
|
||||
* SOLID: Hard wall — entities cannot cross the dome boundary in either direction.
|
||||
* Uses reactive crossing detection: compares current position to previous tick
|
||||
* to detect boundary crossings, then teleports back and applies velocity correction.
|
||||
* Also preemptively cancels inward velocity when near the surface.
|
||||
* <p>
|
||||
* KNOCKBACK: Repulsion force — entities near the dome surface get pushed away.
|
||||
* This is a push effect only; entities can still pass through with enough effort.
|
||||
* Does NOT prevent passthrough — use solid for that.
|
||||
* <p>
|
||||
* For moving domes (followCaster), dome velocity is accounted for by using
|
||||
* the dome's previous position for previous-tick distance calculations.
|
||||
*/
|
||||
@Override
|
||||
@SuppressWarnings("unchecked")
|
||||
protected void processEntityPhysics() {
|
||||
float r = domeRadius;
|
||||
boolean solid = barrierData.solid;
|
||||
boolean knockback = barrierData.knockbackEnabled;
|
||||
float strength = barrierData.knockbackStrength;
|
||||
|
||||
float solidMargin = 1.5f; // Zone around surface for preemptive velocity correction
|
||||
float knockbackMargin = 2.0f; // Zone around surface for knockback push
|
||||
|
||||
AxisAlignedBB searchBox = AxisAlignedBB.getBoundingBox(
|
||||
posX - r - knockbackMargin, posY - r - knockbackMargin, posZ - r - knockbackMargin,
|
||||
posX + r + knockbackMargin, posY + r + knockbackMargin, posZ + r + knockbackMargin
|
||||
);
|
||||
|
||||
// On client, identify local player for client-side solid prediction
|
||||
EntityPlayer localPlayer = worldObj.isRemote ? CustomNpcs.proxy.getPlayer() : null;
|
||||
|
||||
List<EntityLivingBase> entities = worldObj.getEntitiesWithinAABB(EntityLivingBase.class, searchBox);
|
||||
for (EntityLivingBase ent : entities) {
|
||||
if (ent.getEntityId() == ownerEntityId) continue;
|
||||
if (isAllyOfOwner(ent)) continue;
|
||||
|
||||
// Client-side: only process local player for solid prediction
|
||||
if (worldObj.isRemote && (localPlayer == null || ent != localPlayer)) continue;
|
||||
|
||||
// Current position relative to dome center
|
||||
double dx = ent.posX - posX;
|
||||
double dy = (ent.posY + ent.height * 0.5) - posY;
|
||||
double dz = ent.posZ - posZ;
|
||||
double dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
|
||||
if (dist < 0.01) continue;
|
||||
|
||||
// Normalized direction from dome center toward entity (outward)
|
||||
double nx = dx / dist;
|
||||
double ny = dy / dist;
|
||||
double nz = dz / dist;
|
||||
|
||||
boolean isInside = dist < r;
|
||||
|
||||
// --- SOLID: hard wall preventing boundary crossing ---
|
||||
if (solid) {
|
||||
// Previous tick: entity position relative to dome's previous position
|
||||
double prevDx = ent.prevPosX - prevPosX;
|
||||
double prevDy = (ent.prevPosY + ent.height * 0.5) - prevPosY;
|
||||
double prevDz = ent.prevPosZ - prevPosZ;
|
||||
double prevDist = Math.sqrt(prevDx * prevDx + prevDy * prevDy + prevDz * prevDz);
|
||||
boolean wasInside = prevDist < r;
|
||||
|
||||
// Radial velocity (positive = moving outward from dome center)
|
||||
double radialVel = ent.motionX * nx + ent.motionY * ny + ent.motionZ * nz;
|
||||
|
||||
if (wasInside != isInside) {
|
||||
// Entity crossed the boundary this tick — push back to original side
|
||||
double pushDist = wasInside ? (r - 0.3) : (r + 0.3);
|
||||
double surfaceX = posX + nx * pushDist;
|
||||
double surfaceY = posY + ny * pushDist - ent.height * 0.5;
|
||||
double surfaceZ = posZ + nz * pushDist;
|
||||
teleportEntity(ent, surfaceX, surfaceY, surfaceZ);
|
||||
|
||||
// Cancel radial velocity and add corrective push
|
||||
ent.motionX -= radialVel * nx;
|
||||
ent.motionY -= radialVel * ny;
|
||||
ent.motionZ -= radialVel * nz;
|
||||
double pushForce = wasInside ? -0.15 : 0.15;
|
||||
ent.motionX += nx * pushForce;
|
||||
ent.motionZ += nz * pushForce;
|
||||
ent.velocityChanged = true;
|
||||
} else {
|
||||
// Preemptive: near surface and moving toward it — cancel radial velocity
|
||||
double surfaceDist = Math.abs(dist - r);
|
||||
if (surfaceDist < solidMargin) {
|
||||
boolean movingTowardSurface = (!isInside && radialVel < -0.01)
|
||||
|| (isInside && radialVel > 0.01);
|
||||
if (movingTowardSurface) {
|
||||
ent.motionX -= radialVel * nx;
|
||||
ent.motionY -= radialVel * ny;
|
||||
ent.motionZ -= radialVel * nz;
|
||||
double pushForce = isInside ? -0.05 : 0.05;
|
||||
ent.motionX += nx * pushForce;
|
||||
ent.motionZ += nz * pushForce;
|
||||
ent.velocityChanged = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// --- KNOCKBACK: repulsion push (server only, synced via velocityChanged) ---
|
||||
if (!worldObj.isRemote && knockback) {
|
||||
double surfaceDist = Math.abs(dist - r);
|
||||
if (surfaceDist < knockbackMargin) {
|
||||
double proximity = 1.0 - (surfaceDist / knockbackMargin);
|
||||
double force = proximity * strength * 0.06;
|
||||
|
||||
if (isInside) {
|
||||
// Push toward center (away from surface)
|
||||
ent.motionX += -nx * force;
|
||||
ent.motionY += -ny * force * 0.5;
|
||||
ent.motionZ += -nz * force;
|
||||
} else {
|
||||
// Push outward (away from surface)
|
||||
ent.motionX += nx * force;
|
||||
ent.motionY += ny * force * 0.5;
|
||||
ent.motionZ += nz * force;
|
||||
}
|
||||
ent.velocityChanged = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ==================== CONTAINMENT CHECK ====================
|
||||
|
||||
@Override
|
||||
public boolean isEntityInside(Entity entity) {
|
||||
if (entity == null) return false;
|
||||
double dx = entity.posX - posX;
|
||||
double dy = (entity.posY + entity.height * 0.5) - posY;
|
||||
double dz = entity.posZ - posZ;
|
||||
return dx * dx + dy * dy + dz * dz < domeRadius * domeRadius;
|
||||
}
|
||||
|
||||
// ==================== MELEE (spherical check) ====================
|
||||
|
||||
/**
|
||||
* Controls whether MC's entity picking (crosshair raycast) can target this dome.
|
||||
* Returns false when melee is disabled or the dome is still charging.
|
||||
* <p>
|
||||
* Inside players CAN target the dome because adjustMeleeBoundingBox places a small BB
|
||||
* at the nearest surface point, allowing mobs in other directions to still be targeted.
|
||||
*/
|
||||
@Override
|
||||
public boolean canBeCollidedWith() {
|
||||
if (!barrierData.meleeEnabled) return false;
|
||||
if (isCharging()) return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Client-side: Repositions the bounding box to a small cube at the nearest sphere surface
|
||||
* point toward the player. This fixes melee targeting at diagonal approach angles where the
|
||||
* player would otherwise be inside the dome-sized cubic BB but outside the actual sphere,
|
||||
* causing MC's AABB raycast to return the far exit point (beyond reach distance).
|
||||
* <p>
|
||||
* With a small BB (2x2x2) at the surface point, even if the player is inside it at close
|
||||
* range, the exit point is at most ~1.7 blocks away — well within melee reach.
|
||||
*/
|
||||
private void adjustMeleeBoundingBox() {
|
||||
EntityPlayer player = CustomNpcs.proxy.getPlayer();
|
||||
if (player == null) {
|
||||
updateBoundingBox();
|
||||
return;
|
||||
}
|
||||
|
||||
double dx = player.posX - posX;
|
||||
double dy = (player.posY + player.getEyeHeight()) - posY;
|
||||
double dz = player.posZ - posZ;
|
||||
double dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
|
||||
|
||||
// Only adjust when player is within reasonable melee range of dome surface
|
||||
if (dist < 0.01 || dist > domeRadius + 6.0) {
|
||||
updateBoundingBox();
|
||||
return;
|
||||
}
|
||||
|
||||
// Nearest point on sphere surface toward player
|
||||
double nx = dx / dist;
|
||||
double ny = dy / dist;
|
||||
double nz = dz / dist;
|
||||
double surfX = posX + nx * domeRadius;
|
||||
double surfY = posY + ny * domeRadius;
|
||||
double surfZ = posZ + nz * domeRadius;
|
||||
|
||||
float s = 1.0f;
|
||||
this.boundingBox.setBounds(
|
||||
surfX - s, surfY - s, surfZ - s,
|
||||
surfX + s, surfY + s, surfZ + s
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Player melee is handled by processMeleeHits (server-side tick detection) to bypass
|
||||
* MC's processUseEntity reach check which uses center-to-center distance.
|
||||
* Direct player melee ("player" damage type) is rejected unless inTickMelee is set,
|
||||
* preventing double-hits when both the C02 path and tick detection fire.
|
||||
* Non-player melee (mobs) and all other damage sources pass through with sphere validation.
|
||||
*/
|
||||
@Override
|
||||
public boolean attackEntityFrom(DamageSource source, float amount) {
|
||||
// Player melee: only allow from tick-based detection
|
||||
if (!inTickMelee && "player".equals(source.damageType)) {
|
||||
return false;
|
||||
}
|
||||
if (source.getEntity() != null) {
|
||||
Entity attacker = source.getEntity();
|
||||
double dx = attacker.posX - this.posX;
|
||||
double dy = (attacker.posY + attacker.height * 0.5) - this.posY;
|
||||
double dz = attacker.posZ - this.posZ;
|
||||
double dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
|
||||
double surfaceDist = Math.abs(dist - domeRadius);
|
||||
if (surfaceDist > 5.0) return false;
|
||||
}
|
||||
return super.attackEntityFrom(source, amount);
|
||||
}
|
||||
|
||||
/**
|
||||
* Server-side melee detection. Each tick, finds players near the dome surface who are
|
||||
* swinging and looking at the dome, then applies the attack via attackTargetEntityWithCurrentItem
|
||||
* (preserving enchantments, crits, fire aspect, etc.). This bypasses MC's processUseEntity
|
||||
* reach check which uses center-to-center distance and fails for large domes.
|
||||
*/
|
||||
@SuppressWarnings("unchecked")
|
||||
private void processMeleeHits() {
|
||||
float r = domeRadius;
|
||||
float maxReach = 6.0f;
|
||||
|
||||
AxisAlignedBB searchBox = AxisAlignedBB.getBoundingBox(
|
||||
posX - r - maxReach, posY - r - maxReach, posZ - r - maxReach,
|
||||
posX + r + maxReach, posY + r + maxReach, posZ + r + maxReach
|
||||
);
|
||||
|
||||
List<EntityPlayer> players = worldObj.getEntitiesWithinAABB(EntityPlayer.class, searchBox);
|
||||
for (EntityPlayer player : players) {
|
||||
if (player.getEntityId() == ownerEntityId) continue;
|
||||
if (isAllyOfOwner(player)) continue;
|
||||
|
||||
int playerId = player.getEntityId();
|
||||
|
||||
if (!player.isSwingInProgress) {
|
||||
processedMeleeSwings.remove(playerId);
|
||||
continue;
|
||||
}
|
||||
|
||||
if (processedMeleeSwings.contains(playerId)) continue;
|
||||
|
||||
// Check surface distance
|
||||
double dx = player.posX - posX;
|
||||
double dy = (player.posY + 1.62) - posY;
|
||||
double dz = player.posZ - posZ;
|
||||
double distSq = dx * dx + dy * dy + dz * dz;
|
||||
double dist = Math.sqrt(distSq);
|
||||
double surfaceDist = Math.abs(dist - r);
|
||||
if (surfaceDist > maxReach) continue;
|
||||
|
||||
// Ray-sphere intersection: check if look direction hits the dome
|
||||
Vec3 look = player.getLook(1.0f);
|
||||
double b = 2.0 * (dx * look.xCoord + dy * look.yCoord + dz * look.zCoord);
|
||||
double c = distSq - (double)(r * r);
|
||||
double discriminant = b * b - 4.0 * c;
|
||||
if (discriminant < 0) continue;
|
||||
|
||||
double sqrtDisc = Math.sqrt(discriminant);
|
||||
double t1 = (-b - sqrtDisc) / 2.0;
|
||||
double t2 = (-b + sqrtDisc) / 2.0;
|
||||
|
||||
// Outside: t1 is entry distance. Inside: t1 < 0, t2 is exit distance.
|
||||
double hitDist = t1 >= 0 ? t1 : t2;
|
||||
if (hitDist < 0 || hitDist > maxReach) continue;
|
||||
|
||||
// Apply the attack with full MC damage calculation
|
||||
processedMeleeSwings.add(playerId);
|
||||
inTickMelee = true;
|
||||
player.attackTargetEntityWithCurrentItem(this);
|
||||
inTickMelee = false;
|
||||
}
|
||||
}
|
||||
|
||||
// ==================== BOUNDING BOX ====================
|
||||
|
||||
/**
|
||||
* No expansion needed — the bounding box is already dome-sized.
|
||||
* Returning 0 ensures players outside the dome sphere are also outside the
|
||||
* ray-testing BB, so MC's raycast returns the near-face hit (within reach)
|
||||
* rather than the far exit point (beyond reach).
|
||||
*/
|
||||
@Override
|
||||
public float getCollisionBorderSize() {
|
||||
return 0.0f;
|
||||
}
|
||||
|
||||
@Override
|
||||
@SideOnly(Side.CLIENT)
|
||||
public boolean isInRangeToRenderDist(double distance) {
|
||||
double d = domeRadius * 8.0D;
|
||||
d *= 64.0D;
|
||||
return distance < d * d;
|
||||
}
|
||||
|
||||
// ==================== DISTANCE (for render sorting) ====================
|
||||
|
||||
/**
|
||||
* Returns squared distance from the given point to the nearest point on the dome sphere surface.
|
||||
* Uses absolute distance to surface: |centerDist - radius|.
|
||||
* <p>
|
||||
* Inside: nearest surface is (radius - centerDist) away.
|
||||
* Outside: nearest surface is (centerDist - radius) away.
|
||||
* This ensures entities inside the dome sort correctly relative to the dome shell.
|
||||
*/
|
||||
@Override
|
||||
public double getDistanceSq(double x, double y, double z) {
|
||||
double dx = this.posX - x;
|
||||
double dy = this.posY - y;
|
||||
double dz = this.posZ - z;
|
||||
double centerDist = Math.sqrt(dx * dx + dy * dy + dz * dz);
|
||||
|
||||
double surfaceDist = Math.abs(centerDist - domeRadius);
|
||||
return surfaceDist * surfaceDist;
|
||||
}
|
||||
|
||||
// ==================== GETTERS ====================
|
||||
|
||||
public float getDomeRadius() {
|
||||
return domeRadius;
|
||||
}
|
||||
|
||||
public void setDomeRadius(float radius) {
|
||||
this.domeRadius = Math.max(0.1f, radius);
|
||||
this.setPosition(this.posX, this.posY, this.posZ);
|
||||
}
|
||||
|
||||
public boolean isFollowCaster() {
|
||||
return followCaster;
|
||||
}
|
||||
|
||||
public void setFollowCaster(boolean follow) {
|
||||
this.followCaster = follow;
|
||||
}
|
||||
|
||||
@Override
|
||||
@SideOnly(Side.CLIENT)
|
||||
public void setPositionAndRotation2(double x, double y, double z, float yaw, float pitch, int increments) {
|
||||
// Don't do the vanilla "push up out of blocks" logic.
|
||||
this.setPosition(x, y, z);
|
||||
this.setRotation(yaw, pitch);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setPosition(double x, double y, double z) {
|
||||
this.posX = x;
|
||||
this.posY = y;
|
||||
this.posZ = z;
|
||||
updateBoundingBox();
|
||||
}
|
||||
|
||||
protected void updateBoundingBox() {
|
||||
float r = this.domeRadius;
|
||||
this.boundingBox.setBounds(
|
||||
this.posX - r, this.posY - r, this.posZ - r,
|
||||
this.posX + r, this.posY + r, this.posZ + r
|
||||
);
|
||||
}
|
||||
|
||||
// ==================== NBT ====================
|
||||
|
||||
@Override
|
||||
protected void readEntityFromNBT(NBTTagCompound nbt) {
|
||||
// Intentionally empty — ability entities are transient (not saved to world)
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void writeEntityToNBT(NBTTagCompound nbt) {
|
||||
// Intentionally empty — ability entities are transient (not saved to world)
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void writeSpawnNBT(NBTTagCompound nbt) {
|
||||
writeBarrierBaseNBT(nbt);
|
||||
nbt.setFloat("DomeRadius", domeRadius);
|
||||
nbt.setFloat("TargetDomeRadius", targetDomeRadius);
|
||||
nbt.setBoolean("FollowCaster", followCaster);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void readSpawnNBT(NBTTagCompound nbt) {
|
||||
readBarrierBaseNBT(nbt);
|
||||
this.setDomeRadius(sanitize(nbt.getFloat("DomeRadius"), 5.0f, MAX_ENTITY_RADIUS));
|
||||
this.targetDomeRadius = sanitize(nbt.hasKey("TargetDomeRadius") ? nbt.getFloat("TargetDomeRadius") : domeRadius, 5.0f, MAX_ENTITY_RADIUS);
|
||||
this.followCaster = nbt.hasKey("FollowCaster") && nbt.getBoolean("FollowCaster");
|
||||
}
|
||||
}
|
||||
@@ -14,6 +14,7 @@ import net.minecraft.util.MovingObjectPosition;
|
||||
import net.minecraft.util.Vec3;
|
||||
import net.minecraft.world.World;
|
||||
import noppes.npcs.EventHooks;
|
||||
import noppes.npcs.entity.EntityNPCInterface;
|
||||
|
||||
import java.util.HashSet;
|
||||
import java.util.List;
|
||||
@@ -369,6 +370,99 @@ public class EntityAbilityLaser extends EntityEnergyProjectile {
|
||||
return true;
|
||||
}
|
||||
|
||||
// ==================== BARRIER COLLISION ====================
|
||||
|
||||
/**
|
||||
* Override barrier collision for lasers. The base class uses projectile position/velocity
|
||||
* which doesn't work for lasers (posX/Y/Z stays at origin, motionX/Y/Z is zero).
|
||||
* Instead, performs line-sphere intersection against domes.
|
||||
*/
|
||||
@Override
|
||||
@SuppressWarnings("unchecked")
|
||||
protected boolean checkBarrierCollision() {
|
||||
if (currentLength <= 0 || fullyExtended) return false;
|
||||
|
||||
List<EntityAbilityBarrier> barriers = EntityAbilityBarrier.getActiveBarriers(worldObj);
|
||||
for (EntityAbilityBarrier barrier : barriers) {
|
||||
if (barrier.isDead || barrier.isCharging()) continue;
|
||||
if (barrier.getOwnerEntityId() == this.ownerEntityId) continue;
|
||||
|
||||
// Same-faction NPC check
|
||||
Entity bOwner = barrier.getOwnerEntity();
|
||||
Entity lOwner = this.getOwnerEntity();
|
||||
if (bOwner instanceof EntityNPCInterface && lOwner instanceof EntityNPCInterface) {
|
||||
if (((EntityNPCInterface) bOwner).faction.id == ((EntityNPCInterface) lOwner).faction.id) {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
if (barrier instanceof EntityAbilityDome) {
|
||||
EntityAbilityDome dome = (EntityAbilityDome) barrier;
|
||||
float intersectDist = getLineSphereIntersection(dome);
|
||||
if (intersectDist >= 0) {
|
||||
// Truncate laser at dome surface
|
||||
currentLength = intersectDist;
|
||||
endX = startX + dirX * currentLength;
|
||||
endY = startY + dirY * currentLength;
|
||||
endZ = startZ + dirZ * currentLength;
|
||||
fullyExtended = true;
|
||||
|
||||
float damage = getModifiedDamage();
|
||||
dome.onProjectileHit(this, damage);
|
||||
return false; // Don't kill laser — it's truncated and will linger
|
||||
}
|
||||
} else {
|
||||
// Non-dome barriers: fall through to standard check
|
||||
if (barrier.isIncomingProjectile(this)) {
|
||||
float damage = getModifiedDamage();
|
||||
if (barrier.onProjectileHit(this, damage)) {
|
||||
hasHit = true;
|
||||
this.setDead();
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Line-sphere intersection between the laser line segment and a dome.
|
||||
* Returns the distance along the laser direction to the first entry point,
|
||||
* or -1 if no intersection from outside.
|
||||
*/
|
||||
private float getLineSphereIntersection(EntityAbilityDome dome) {
|
||||
double cx = dome.posX;
|
||||
double cy = dome.posY;
|
||||
double cz = dome.posZ;
|
||||
float radius = dome.getDomeRadius();
|
||||
|
||||
// If laser origin is inside the dome, don't block (outgoing)
|
||||
double ocX = startX - cx;
|
||||
double ocY = startY - cy;
|
||||
double ocZ = startZ - cz;
|
||||
double originDistSq = ocX * ocX + ocY * ocY + ocZ * ocZ;
|
||||
if (originDistSq < (double) radius * radius) return -1;
|
||||
|
||||
// Solve: |start + t*dir - C|^2 = R^2
|
||||
// a*t^2 + b*t + c = 0
|
||||
double a = dirX * dirX + dirY * dirY + dirZ * dirZ;
|
||||
double b = 2.0 * (dirX * ocX + dirY * ocY + dirZ * ocZ);
|
||||
double c = originDistSq - (double) radius * radius;
|
||||
|
||||
double discriminant = b * b - 4.0 * a * c;
|
||||
if (discriminant < 0) return -1;
|
||||
|
||||
double sqrtD = Math.sqrt(discriminant);
|
||||
double t1 = (-b - sqrtD) / (2.0 * a); // Entry point
|
||||
|
||||
if (t1 >= 0 && t1 <= currentLength) {
|
||||
return (float) t1;
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
// ==================== GETTERS FOR RENDERER ====================
|
||||
|
||||
public void setLockVerticalDirection(boolean lock) {
|
||||
|
||||
+260
-90
@@ -13,6 +13,7 @@ import net.minecraft.nbt.NBTTagCompound;
|
||||
import net.minecraft.util.AxisAlignedBB;
|
||||
import net.minecraft.util.DamageSource;
|
||||
import net.minecraft.world.World;
|
||||
import noppes.npcs.CustomNpcs;
|
||||
import noppes.npcs.NpcDamageSource;
|
||||
import noppes.npcs.entity.EntityNPCInterface;
|
||||
|
||||
@@ -21,9 +22,9 @@ import java.util.List;
|
||||
/**
|
||||
* Energy Panel entity - a flat rectangular barrier used by Wall and Shield abilities.
|
||||
* Supports three modes: PLACED (stationary), HELD (tracks caster), LAUNCHED (moves forward).
|
||||
* Extends EntityEnergyBarrier for shared barrier logic.
|
||||
* Extends EntityAbilityBarrier for shared barrier logic.
|
||||
*/
|
||||
public class EntityEnergyPanel extends EntityEnergyBarrier {
|
||||
public class EntityAbilityPanel extends EntityAbilityBarrier {
|
||||
|
||||
public enum PanelMode {
|
||||
PLACED, // Stationary wall
|
||||
@@ -35,24 +36,26 @@ public class EntityEnergyPanel extends EntityEnergyBarrier {
|
||||
protected EnergyPanelData panelData = new EnergyPanelData();
|
||||
protected PanelMode mode = PanelMode.PLACED;
|
||||
protected float panelYaw = 0.0f; // Rotation of the panel face (degrees)
|
||||
protected float prevPanelYaw = 0.0f; // Previous tick yaw for smooth interpolation
|
||||
|
||||
// ==================== CHARGING (panel-specific targets) ====================
|
||||
protected float targetPanelWidth;
|
||||
protected float targetPanelHeight;
|
||||
|
||||
public EntityEnergyPanel(World world) {
|
||||
public EntityAbilityPanel(World world) {
|
||||
super(world);
|
||||
this.setSize(0.5f, 0.5f);
|
||||
}
|
||||
|
||||
public EntityEnergyPanel(World world, EntityLivingBase owner, double x, double y, double z,
|
||||
float yaw, PanelMode mode,
|
||||
EnergyDisplayData display, EnergyLightningData lightning,
|
||||
EnergyBarrierData barrier, EnergyPanelData panel) {
|
||||
public EntityAbilityPanel(World world, EntityLivingBase owner, double x, double y, double z,
|
||||
float yaw, PanelMode mode,
|
||||
EnergyDisplayData display, EnergyLightningData lightning,
|
||||
EnergyBarrierData barrier, EnergyPanelData panel) {
|
||||
this(world);
|
||||
this.setPosition(x, y + panel.heightOffset, z);
|
||||
this.ownerEntityId = owner.getEntityId();
|
||||
this.panelYaw = yaw;
|
||||
this.prevPanelYaw = yaw;
|
||||
this.mode = mode;
|
||||
this.displayData = display;
|
||||
this.lightningData = lightning;
|
||||
@@ -69,11 +72,36 @@ public class EntityEnergyPanel extends EntityEnergyBarrier {
|
||||
}
|
||||
}
|
||||
|
||||
// ==================== POSITION / BOUNDING BOX ====================
|
||||
|
||||
/**
|
||||
* Override setPosition to maintain panel-sized bounding box.
|
||||
* MC's default setPosition() resets BB based on width/height fields.
|
||||
* Network sync calls setPosition(), which would shrink the BB.
|
||||
* This ensures melee targeting always works against the full panel surface.
|
||||
*/
|
||||
@Override
|
||||
public void setPosition(double x, double y, double z) {
|
||||
this.posX = x;
|
||||
this.posY = y;
|
||||
this.posZ = z;
|
||||
if (panelData != null) {
|
||||
float halfW = panelData.panelWidth * 0.5f;
|
||||
float halfH = panelData.panelHeight * 0.5f;
|
||||
float extent = Math.max(halfW, 0.5f);
|
||||
this.boundingBox.setBounds(x - extent, y - halfH, z - extent, x + extent, y + halfH, z + extent);
|
||||
} else {
|
||||
float f = this.width / 2.0F;
|
||||
this.boundingBox.setBounds(x - f, y, z - f, x + f, y + this.height, z + f);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onUpdate() {
|
||||
this.prevPosX = this.posX;
|
||||
this.prevPosY = this.posY;
|
||||
this.prevPosZ = this.posZ;
|
||||
this.prevPanelYaw = this.panelYaw;
|
||||
|
||||
super.onUpdate();
|
||||
|
||||
@@ -95,9 +123,11 @@ public class EntityEnergyPanel extends EntityEnergyBarrier {
|
||||
|
||||
if (updateBarrierTick()) return;
|
||||
|
||||
// Knockback (not during launched mode)
|
||||
if (!worldObj.isRemote && barrierData.knockbackEnabled && mode != PanelMode.LAUNCHED) {
|
||||
knockbackEntities();
|
||||
// Process entity physics every tick (not during launched mode)
|
||||
// Server: solid + knockback for all entities
|
||||
// Client: solid prediction for local player only (smooth movement blocking)
|
||||
if ((barrierData.solid || barrierData.knockbackEnabled) && mode != PanelMode.LAUNCHED) {
|
||||
processEntityPhysics();
|
||||
}
|
||||
|
||||
// Mode-specific updates
|
||||
@@ -130,6 +160,12 @@ public class EntityEnergyPanel extends EntityEnergyBarrier {
|
||||
double newZ = owner.posZ + (Math.cos(yawRad) * frontDist);
|
||||
|
||||
this.setPosition(newX, newY, newZ);
|
||||
|
||||
// Sync prevPos with owner's prevPos for smooth interpolation
|
||||
float prevYawRad = (float) Math.toRadians(owner.prevRotationYaw);
|
||||
this.prevPosX = owner.prevPosX + (-Math.sin(prevYawRad) * frontDist);
|
||||
this.prevPosY = owner.prevPosY + panelData.heightOffset + (owner.height * 0.5f);
|
||||
this.prevPosZ = owner.prevPosZ + (Math.cos(prevYawRad) * frontDist);
|
||||
}
|
||||
|
||||
private void updateLaunched() {
|
||||
@@ -199,16 +235,89 @@ public class EntityEnergyPanel extends EntityEnergyBarrier {
|
||||
// ==================== INCOMING CHECK ====================
|
||||
|
||||
/**
|
||||
* Check if a projectile hits this panel surface.
|
||||
* Only blocks incoming projectiles (not from the panel's owner).
|
||||
* Swept ray-plane intersection test for the panel.
|
||||
* Tests if the line segment from prevPos to currPos crosses the panel plane
|
||||
* within its width/height bounds. Handles fast projectiles that skip through
|
||||
* the thin panel in a single tick.
|
||||
*
|
||||
* @return true if the segment crosses the panel from either side
|
||||
*/
|
||||
private boolean isIncomingRay(
|
||||
double currX, double currY, double currZ,
|
||||
double prevX, double prevY, double prevZ,
|
||||
int projOwnerEntityId)
|
||||
{
|
||||
if (isCharging()) return false;
|
||||
if (projOwnerEntityId == this.ownerEntityId) return false;
|
||||
|
||||
float halfW = panelData.panelWidth * 0.5f;
|
||||
float halfH = panelData.panelHeight * 0.5f;
|
||||
float panelThickness = 0.5f;
|
||||
|
||||
float yawRad = (float) Math.toRadians(panelYaw);
|
||||
double normalX = -Math.sin(yawRad);
|
||||
double normalZ = Math.cos(yawRad);
|
||||
double cos = Math.cos(yawRad);
|
||||
double sin = Math.sin(yawRad);
|
||||
|
||||
// Signed distance from prevPos and currPos to panel plane
|
||||
double relPrevX = prevX - this.posX;
|
||||
double relPrevY = prevY - this.posY;
|
||||
double relPrevZ = prevZ - this.posZ;
|
||||
double prevDist = relPrevX * normalX + relPrevZ * normalZ;
|
||||
|
||||
double relCurrX = currX - this.posX;
|
||||
double relCurrY = currY - this.posY;
|
||||
double relCurrZ = currZ - this.posZ;
|
||||
double currDist = relCurrX * normalX + relCurrZ * normalZ;
|
||||
|
||||
// Check if segment crosses the plane (sign change)
|
||||
if (prevDist * currDist > 0) {
|
||||
// Both on same side — check if within thickness (slow projectile fallback)
|
||||
if (Math.abs(currDist) <= panelThickness) {
|
||||
double localRight = relCurrX * cos + relCurrZ * sin;
|
||||
if (Math.abs(localRight) > halfW) return false;
|
||||
if (Math.abs(relCurrY) > halfH) return false;
|
||||
// Check incoming direction
|
||||
double motX = currX - prevX;
|
||||
double motZ = currZ - prevZ;
|
||||
double dot = motX * normalX + motZ * normalZ;
|
||||
if (currDist > 0 && dot >= 0) return false;
|
||||
if (currDist < 0 && dot <= 0) return false;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
// Segment crosses plane — compute intersection parameter t
|
||||
double rayDirX = currX - prevX;
|
||||
double rayDirZ = currZ - prevZ;
|
||||
double denom = rayDirX * normalX + rayDirZ * normalZ;
|
||||
if (Math.abs(denom) < 1e-10) return false; // Parallel to plane
|
||||
|
||||
double t = -prevDist / denom;
|
||||
if (t < 0.0 || t > 1.0) return false;
|
||||
|
||||
// Compute intersection point
|
||||
double hitX = prevX + (currX - prevX) * t;
|
||||
double hitY = prevY + (currY - prevY) * t;
|
||||
double hitZ = prevZ + (currZ - prevZ) * t;
|
||||
|
||||
// Transform hit point to panel-local space and check bounds
|
||||
double relHitX = hitX - this.posX;
|
||||
double relHitY = hitY - this.posY;
|
||||
double relHitZ = hitZ - this.posZ;
|
||||
|
||||
double localRight = relHitX * cos + relHitZ * sin;
|
||||
if (Math.abs(localRight) > halfW) return false;
|
||||
if (Math.abs(relHitY) > halfH) return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isIncomingProjectile(EntityEnergyProjectile projectile) {
|
||||
// Don't block during charging phase
|
||||
if (isCharging()) return false;
|
||||
if (projectile.getOwnerEntityId() == this.ownerEntityId) return false;
|
||||
|
||||
// Faction check
|
||||
// Faction check: don't block same-faction NPC projectiles
|
||||
Entity owner = getOwnerEntity();
|
||||
Entity projOwner = projectile.getOwnerEntity();
|
||||
if (owner instanceof EntityNPCInterface && projOwner instanceof EntityNPCInterface) {
|
||||
@@ -217,38 +326,29 @@ public class EntityEnergyPanel extends EntityEnergyBarrier {
|
||||
}
|
||||
}
|
||||
|
||||
// Check if projectile is within panel bounds
|
||||
float halfW = panelData.panelWidth * 0.5f;
|
||||
float halfH = panelData.panelHeight * 0.5f;
|
||||
float panelThickness = 0.5f; // Collision thickness
|
||||
double prevX = projectile.posX - projectile.motionX;
|
||||
double prevY = projectile.posY - projectile.motionY;
|
||||
double prevZ = projectile.posZ - projectile.motionZ;
|
||||
|
||||
// Transform projectile position to panel-local space
|
||||
float yawRad = (float) Math.toRadians(panelYaw);
|
||||
double relX = projectile.posX - this.posX;
|
||||
double relY = projectile.posY - this.posY;
|
||||
double relZ = projectile.posZ - this.posZ;
|
||||
return isIncomingRay(
|
||||
projectile.posX, projectile.posY, projectile.posZ,
|
||||
prevX, prevY, prevZ,
|
||||
projectile.getOwnerEntityId());
|
||||
}
|
||||
|
||||
// Rotate into panel space (panel faces along -sin(yaw), cos(yaw))
|
||||
double cos = Math.cos(yawRad);
|
||||
double sin = Math.sin(yawRad);
|
||||
double localForward = relX * (-sin) + relZ * cos; // Distance along panel normal
|
||||
double localRight = relX * cos + relZ * sin; // Distance along panel width
|
||||
@Override
|
||||
public boolean isIncomingGenericProjectile(
|
||||
double posX, double posY, double posZ,
|
||||
double motionX, double motionY, double motionZ,
|
||||
double prevPosX, double prevPosY, double prevPosZ,
|
||||
int ownerEntityId)
|
||||
{
|
||||
return isIncomingRay(posX, posY, posZ, prevPosX, prevPosY, prevPosZ, ownerEntityId);
|
||||
}
|
||||
|
||||
// Check bounds
|
||||
if (Math.abs(localForward) > panelThickness) return false;
|
||||
if (Math.abs(localRight) > halfW) return false;
|
||||
if (Math.abs(relY) > halfH) return false;
|
||||
|
||||
// Check incoming direction via dot product with panel normal
|
||||
double normalX = -Math.sin(yawRad);
|
||||
double normalZ = Math.cos(yawRad);
|
||||
double dot = projectile.motionX * normalX + projectile.motionZ * normalZ;
|
||||
|
||||
// Determine which side of the panel the projectile is on
|
||||
if (localForward > 0 && dot >= 0) return false; // Moving away from front side
|
||||
if (localForward < 0 && dot <= 0) return false; // Moving away from back side
|
||||
|
||||
return true;
|
||||
@Override
|
||||
public float getMaxExtent() {
|
||||
return Math.max(panelData.panelWidth, panelData.panelHeight) * 0.5f + 1.0f;
|
||||
}
|
||||
|
||||
// ==================== CHARGING ====================
|
||||
@@ -271,23 +371,38 @@ public class EntityEnergyPanel extends EntityEnergyBarrier {
|
||||
setCharging(false);
|
||||
}
|
||||
|
||||
// ==================== KNOCKBACK ====================
|
||||
// ==================== ENTITY PHYSICS (Solid + Knockback) ====================
|
||||
|
||||
/**
|
||||
* Push entities away from the panel surface.
|
||||
* Processes entity physics for the panel barrier. Two independent systems:
|
||||
* <p>
|
||||
* SOLID: Hard wall — entities cannot cross the panel plane within its bounds.
|
||||
* Uses reactive crossing detection: compares current side to previous tick
|
||||
* to detect plane crossings, then teleports back and applies velocity correction.
|
||||
* Also preemptively cancels normal velocity when near the plane.
|
||||
* <p>
|
||||
* KNOCKBACK: Repulsion force — entities near the panel surface get pushed away.
|
||||
* This is a push effect only; entities can still pass through with enough effort.
|
||||
* Does NOT prevent passthrough — use solid for that.
|
||||
*/
|
||||
@Override
|
||||
@SuppressWarnings("unchecked")
|
||||
protected void knockbackEntities() {
|
||||
protected void processEntityPhysics() {
|
||||
float halfW = panelData.panelWidth * 0.5f;
|
||||
float halfH = panelData.panelHeight * 0.5f;
|
||||
float margin = 1.0f;
|
||||
float searchExtension = 3.0f;
|
||||
boolean solid = barrierData.solid;
|
||||
boolean knockback = barrierData.knockbackEnabled;
|
||||
float strength = barrierData.knockbackStrength;
|
||||
|
||||
AxisAlignedBB searchBox = AxisAlignedBB.getBoundingBox(
|
||||
posX - halfW - margin, posY - halfH - margin, posZ - halfW - margin,
|
||||
posX + halfW + margin, posY + halfH + margin, posZ + halfW + margin
|
||||
posX - halfW - searchExtension, posY - halfH - searchExtension, posZ - halfW - searchExtension,
|
||||
posX + halfW + searchExtension, posY + halfH + searchExtension, posZ + halfW + searchExtension
|
||||
);
|
||||
|
||||
// On client, identify local player for client-side solid prediction
|
||||
EntityPlayer localPlayer = worldObj.isRemote ? CustomNpcs.proxy.getPlayer() : null;
|
||||
|
||||
List<EntityLivingBase> entities = worldObj.getEntitiesWithinAABB(EntityLivingBase.class, searchBox);
|
||||
float yawRad = (float) Math.toRadians(panelYaw);
|
||||
float normalX = -(float) Math.sin(yawRad);
|
||||
@@ -295,46 +410,87 @@ public class EntityEnergyPanel extends EntityEnergyBarrier {
|
||||
|
||||
for (EntityLivingBase ent : entities) {
|
||||
if (ent.getEntityId() == ownerEntityId) continue;
|
||||
if (!isKnockbackTarget(ent)) continue;
|
||||
if (isAllyOfOwner(ent)) continue;
|
||||
|
||||
// Transform entity position to panel-local space
|
||||
// Client-side: only process local player for solid prediction
|
||||
if (worldObj.isRemote && (localPlayer == null || ent != localPlayer)) continue;
|
||||
|
||||
// Current position relative to panel center
|
||||
double dx = ent.posX - posX;
|
||||
double dy = (ent.posY + ent.height * 0.5) - posY;
|
||||
double dz = ent.posZ - posZ;
|
||||
|
||||
// Check proximity to panel surface
|
||||
// Panel-local coordinates
|
||||
float localForward = (float) (dx * normalX + dz * normalZ);
|
||||
float localRight = (float) (dx * (-normalZ) + dz * normalX);
|
||||
|
||||
if (Math.abs(localForward) < margin && Math.abs(localRight) < halfW + margin && Math.abs(dy) < halfH + margin) {
|
||||
// Push entity away from the panel face
|
||||
float pushDir = localForward >= 0 ? 1.0f : -1.0f;
|
||||
double pushStrength = barrierData.knockbackStrength * 0.5;
|
||||
ent.addVelocity(
|
||||
normalX * pushDir * pushStrength,
|
||||
0.1,
|
||||
normalZ * pushDir * pushStrength
|
||||
);
|
||||
ent.velocityChanged = true;
|
||||
// Skip if outside panel bounds (with margin)
|
||||
if (Math.abs(localRight) > halfW + 1.0f) continue;
|
||||
if (Math.abs(dy) > halfH + 1.0f) continue;
|
||||
if (Math.abs(localForward) > searchExtension) continue;
|
||||
|
||||
// Determine which side the entity is on
|
||||
float side = localForward >= 0 ? 1.0f : -1.0f;
|
||||
|
||||
// Check if within panel width/height bounds
|
||||
boolean inBounds = Math.abs(localRight) <= halfW && Math.abs(dy) <= halfH;
|
||||
|
||||
// --- SOLID: hard wall preventing plane crossing ---
|
||||
if (solid && inBounds) {
|
||||
// Previous tick: entity position relative to panel
|
||||
double prevDx = ent.prevPosX - prevPosX;
|
||||
double prevDz = ent.prevPosZ - prevPosZ;
|
||||
float prevLocalForward = (float) (prevDx * normalX + prevDz * normalZ);
|
||||
float prevSide = prevLocalForward >= 0 ? 1.0f : -1.0f;
|
||||
|
||||
// Normal velocity component (positive = moving in normal direction)
|
||||
double normalVel = ent.motionX * normalX + ent.motionZ * normalZ;
|
||||
|
||||
if (prevSide != side) {
|
||||
// Entity crossed the panel plane this tick — push back to original side
|
||||
double pushDist = 0.3;
|
||||
double newX = posX + normalX * prevSide * pushDist + (localRight * (-normalZ));
|
||||
double newZ = posZ + normalZ * prevSide * pushDist + (localRight * normalX);
|
||||
teleportEntity(ent, newX, ent.posY, newZ);
|
||||
|
||||
// Cancel normal velocity and add corrective push
|
||||
ent.motionX -= normalVel * normalX;
|
||||
ent.motionZ -= normalVel * normalZ;
|
||||
ent.motionX += normalX * prevSide * 0.15;
|
||||
ent.motionZ += normalZ * prevSide * 0.15;
|
||||
ent.velocityChanged = true;
|
||||
} else {
|
||||
// Preemptive: near the plane and moving toward it — cancel normal velocity
|
||||
double absDist = Math.abs(localForward);
|
||||
if (absDist < 1.5) {
|
||||
boolean movingToward = (side > 0 && normalVel < -0.01)
|
||||
|| (side < 0 && normalVel > 0.01);
|
||||
if (movingToward) {
|
||||
ent.motionX -= normalVel * normalX;
|
||||
ent.motionZ -= normalVel * normalZ;
|
||||
ent.motionX += normalX * side * 0.05;
|
||||
ent.motionZ += normalZ * side * 0.05;
|
||||
ent.velocityChanged = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// --- KNOCKBACK: repulsion push (server only, synced via velocityChanged) ---
|
||||
if (!worldObj.isRemote && knockback && inBounds) {
|
||||
double absDist = Math.abs(localForward);
|
||||
if (absDist < searchExtension) {
|
||||
double proximity = 1.0 - (absDist / searchExtension);
|
||||
double force = proximity * strength * 0.06;
|
||||
ent.motionX += normalX * side * force;
|
||||
ent.motionZ += normalZ * side * force;
|
||||
ent.velocityChanged = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ==================== BOUNDING BOX ====================
|
||||
|
||||
@Override
|
||||
public AxisAlignedBB getBoundingBox() {
|
||||
if (barrierData.meleeEnabled) {
|
||||
float halfW = panelData.panelWidth * 0.5f;
|
||||
float halfH = panelData.panelHeight * 0.5f;
|
||||
float extent = Math.max(halfW, 0.5f);
|
||||
return AxisAlignedBB.getBoundingBox(
|
||||
posX - extent, posY - halfH, posZ - extent,
|
||||
posX + extent, posY + halfH, posZ + extent
|
||||
);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
// ==================== RENDER ====================
|
||||
|
||||
@Override
|
||||
@SideOnly(Side.CLIENT)
|
||||
@@ -395,6 +551,10 @@ public class EntityEnergyPanel extends EntityEnergyBarrier {
|
||||
return panelYaw;
|
||||
}
|
||||
|
||||
public float getPrevPanelYaw() {
|
||||
return prevPanelYaw;
|
||||
}
|
||||
|
||||
public EnergyPanelData getPanelData() {
|
||||
return panelData;
|
||||
}
|
||||
@@ -403,6 +563,26 @@ public class EntityEnergyPanel extends EntityEnergyBarrier {
|
||||
|
||||
@Override
|
||||
protected void readEntityFromNBT(NBTTagCompound nbt) {
|
||||
// Intentionally empty — ability entities are transient (not saved to world)
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void writeEntityToNBT(NBTTagCompound nbt) {
|
||||
// Intentionally empty — ability entities are transient (not saved to world)
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void writeSpawnNBT(NBTTagCompound nbt) {
|
||||
writeBarrierBaseNBT(nbt);
|
||||
nbt.setFloat("PanelYaw", panelYaw);
|
||||
nbt.setInteger("PanelMode", mode.ordinal());
|
||||
nbt.setFloat("TargetPanelWidth", targetPanelWidth);
|
||||
nbt.setFloat("TargetPanelHeight", targetPanelHeight);
|
||||
panelData.writeNBT(nbt);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void readSpawnNBT(NBTTagCompound nbt) {
|
||||
readBarrierBaseNBT(nbt);
|
||||
this.panelYaw = nbt.getFloat("PanelYaw");
|
||||
int modeOrdinal = nbt.getInteger("PanelMode");
|
||||
@@ -414,14 +594,4 @@ public class EntityEnergyPanel extends EntityEnergyBarrier {
|
||||
this.targetPanelWidth = sanitize(nbt.hasKey("TargetPanelWidth") ? nbt.getFloat("TargetPanelWidth") : panelData.panelWidth, 3.0f, MAX_ENTITY_SIZE);
|
||||
this.targetPanelHeight = sanitize(nbt.hasKey("TargetPanelHeight") ? nbt.getFloat("TargetPanelHeight") : panelData.panelHeight, 3.0f, MAX_ENTITY_SIZE);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void writeEntityToNBT(NBTTagCompound nbt) {
|
||||
writeBarrierBaseNBT(nbt);
|
||||
nbt.setFloat("PanelYaw", panelYaw);
|
||||
nbt.setInteger("PanelMode", mode.ordinal());
|
||||
nbt.setFloat("TargetPanelWidth", targetPanelWidth);
|
||||
nbt.setFloat("TargetPanelHeight", targetPanelHeight);
|
||||
panelData.writeNBT(nbt);
|
||||
}
|
||||
}
|
||||
@@ -34,7 +34,7 @@ public class EntityAbilitySweeper extends EntityEnergyAbility {
|
||||
// Beam properties
|
||||
private float beamLength = 10.0f;
|
||||
private float beamWidth = 0.3f; // Thin like beam trail
|
||||
private float beamHeight = 0.8f;
|
||||
private float beamHeight = 1.0f;
|
||||
|
||||
// Combat properties
|
||||
private float damage = 5.0f;
|
||||
@@ -100,8 +100,8 @@ public class EntityAbilitySweeper extends EntityEnergyAbility {
|
||||
this.baseYaw = owner.rotationYaw;
|
||||
}
|
||||
|
||||
// Position at owner
|
||||
this.setPosition(owner.posX, owner.posY + beamHeight, owner.posZ);
|
||||
// Position at beam center (bottom at feet, top at feet + beamHeight)
|
||||
this.setPosition(owner.posX, owner.posY + beamHeight / 2.0, owner.posZ);
|
||||
|
||||
// Ready to deal damage immediately
|
||||
this.ticksSinceDamage = damageInterval;
|
||||
@@ -149,7 +149,7 @@ public class EntityAbilitySweeper extends EntityEnergyAbility {
|
||||
}
|
||||
|
||||
if (owner != null) {
|
||||
this.setPosition(owner.posX, owner.posY + beamHeight, owner.posZ);
|
||||
this.setPosition(owner.posX, owner.posY + beamHeight / 2.0, owner.posZ);
|
||||
}
|
||||
|
||||
// Check if sweep is done
|
||||
@@ -204,10 +204,10 @@ public class EntityAbilitySweeper extends EntityEnergyAbility {
|
||||
double checkY = startY;
|
||||
double checkZ = startZ + dirZ * beamLength * progress;
|
||||
|
||||
// Narrow hitbox for thin beam
|
||||
// Hitbox: beam center ± half-height vertically, generous width for thin beams
|
||||
AxisAlignedBB checkBox = AxisAlignedBB.getBoundingBox(
|
||||
checkX - beamWidth * 2, checkY - 0.5, checkZ - beamWidth * 2,
|
||||
checkX + beamWidth * 2, checkY + 1.0, checkZ + beamWidth * 2
|
||||
checkX - beamWidth * 2, checkY - beamHeight / 2.0, checkZ - beamWidth * 2,
|
||||
checkX + beamWidth * 2, checkY + beamHeight / 2.0, checkZ + beamWidth * 2
|
||||
);
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
@@ -259,11 +259,14 @@ public class EntityAbilitySweeper extends EntityEnergyAbility {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Height check - entity's feet must be below beam top (allows jumping over)
|
||||
// Height check - entity must overlap beam vertically
|
||||
double beamTopY = startY + beamHeight / 2.0;
|
||||
double beamBottomY = startY - beamHeight / 2.0;
|
||||
double entityFeetY = entity.posY;
|
||||
double beamTopY = startY + 0.5;
|
||||
double entityTopY = entity.posY + entity.height;
|
||||
|
||||
return entityFeetY < beamTopY;
|
||||
// Entity feet must be below beam top AND entity top must be above beam bottom
|
||||
return entityFeetY < beamTopY && entityTopY > beamBottomY;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -363,10 +366,40 @@ public class EntityAbilitySweeper extends EntityEnergyAbility {
|
||||
|
||||
@Override
|
||||
protected void readEntityFromNBT(NBTTagCompound nbt) {
|
||||
// Intentionally empty — ability entities are transient (not saved to world)
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void writeEntityToNBT(NBTTagCompound nbt) {
|
||||
// Intentionally empty — ability entities are transient (not saved to world)
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void writeSpawnNBT(NBTTagCompound nbt) {
|
||||
writeEnergyBaseNBT(nbt);
|
||||
nbt.setFloat("BeamLength", beamLength);
|
||||
nbt.setFloat("BeamWidth", beamWidth);
|
||||
nbt.setFloat("BeamHeight", beamHeight);
|
||||
nbt.setFloat("SweepSpeed", sweepSpeed);
|
||||
nbt.setInteger("NumRotations", numberOfRotations);
|
||||
nbt.setInteger("CompletedRotations", completedRotations);
|
||||
nbt.setInteger("MaxTicks", maxTicks);
|
||||
nbt.setInteger("TargetId", targetEntityId);
|
||||
nbt.setFloat("CurrentAngle", currentAngle);
|
||||
nbt.setFloat("BaseYaw", baseYaw);
|
||||
nbt.setLong("DeathWorldTime", deathWorldTime);
|
||||
nbt.setFloat("Damage", damage);
|
||||
nbt.setInteger("DamageInterval", damageInterval);
|
||||
nbt.setBoolean("Piercing", piercing);
|
||||
nbt.setBoolean("LockOnTarget", lockOnTarget);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void readSpawnNBT(NBTTagCompound nbt) {
|
||||
readEnergyBaseNBT(nbt);
|
||||
this.beamLength = sanitize(nbt.getFloat("BeamLength"), 10.0f, MAX_ENTITY_SIZE);
|
||||
this.beamWidth = sanitize(nbt.getFloat("BeamWidth"), 0.3f, MAX_ENTITY_SIZE);
|
||||
this.beamHeight = sanitize(nbt.getFloat("BeamHeight"), 0.8f, MAX_ENTITY_SIZE);
|
||||
this.beamHeight = sanitize(nbt.getFloat("BeamHeight"), 1.0f, MAX_ENTITY_SIZE);
|
||||
this.sweepSpeed = nbt.hasKey("SweepSpeed") ? nbt.getFloat("SweepSpeed") : 3.0f;
|
||||
if (Float.isNaN(sweepSpeed) || Float.isInfinite(sweepSpeed) || sweepSpeed <= 0) sweepSpeed = 3.0f;
|
||||
this.numberOfRotations = nbt.hasKey("NumRotations") ? nbt.getInteger("NumRotations") : 2;
|
||||
@@ -386,24 +419,4 @@ public class EntityAbilitySweeper extends EntityEnergyAbility {
|
||||
this.piercing = !nbt.hasKey("Piercing") || nbt.getBoolean("Piercing");
|
||||
this.lockOnTarget = nbt.getBoolean("LockOnTarget");
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void writeEntityToNBT(NBTTagCompound nbt) {
|
||||
writeEnergyBaseNBT(nbt);
|
||||
nbt.setFloat("BeamLength", beamLength);
|
||||
nbt.setFloat("BeamWidth", beamWidth);
|
||||
nbt.setFloat("BeamHeight", beamHeight);
|
||||
nbt.setFloat("SweepSpeed", sweepSpeed);
|
||||
nbt.setInteger("NumRotations", numberOfRotations);
|
||||
nbt.setInteger("CompletedRotations", completedRotations);
|
||||
nbt.setInteger("MaxTicks", maxTicks);
|
||||
nbt.setInteger("TargetId", targetEntityId);
|
||||
nbt.setFloat("CurrentAngle", currentAngle);
|
||||
nbt.setFloat("BaseYaw", baseYaw);
|
||||
nbt.setLong("DeathWorldTime", deathWorldTime);
|
||||
nbt.setFloat("Damage", damage);
|
||||
nbt.setInteger("DamageInterval", damageInterval);
|
||||
nbt.setBoolean("Piercing", piercing);
|
||||
nbt.setBoolean("LockOnTarget", lockOnTarget);
|
||||
}
|
||||
}
|
||||
@@ -1,6 +1,6 @@
|
||||
package kamkeel.npcs.entity;
|
||||
|
||||
import cpw.mods.fml.common.network.ByteBufUtils;
|
||||
import kamkeel.npcs.util.ByteBufUtils;
|
||||
import cpw.mods.fml.common.registry.IEntityAdditionalSpawnData;
|
||||
import cpw.mods.fml.relauncher.Side;
|
||||
import cpw.mods.fml.relauncher.SideOnly;
|
||||
@@ -716,130 +716,12 @@ public class EntityAbilityZone extends Entity implements IEntityAdditionalSpawnD
|
||||
|
||||
@Override
|
||||
protected void readEntityFromNBT(NBTTagCompound nbt) {
|
||||
int zoneTypeOrd = nbt.getInteger("ZoneType");
|
||||
this.zoneType = (zoneTypeOrd >= 0 && zoneTypeOrd < ZoneType.values().length) ? ZoneType.values()[zoneTypeOrd] : ZoneType.TRAP;
|
||||
try {
|
||||
this.shape = ZoneShape.valueOf(nbt.getString("ShapeName"));
|
||||
} catch (Exception e) {
|
||||
this.shape = ZoneShape.CIRCLE;
|
||||
}
|
||||
|
||||
this.ownerEntityId = nbt.getInteger("OwnerId");
|
||||
this.radius = nbt.hasKey("Radius") ? nbt.getFloat("Radius") : 4.0f;
|
||||
this.durationTicks = nbt.hasKey("Duration") ? nbt.getInteger("Duration") : 200;
|
||||
this.maxTicks = nbt.hasKey("MaxTicks") ? nbt.getInteger("MaxTicks") : 200;
|
||||
this.innerColor = nbt.hasKey("InnerColor") ? nbt.getInteger("InnerColor") : 0xFF6600;
|
||||
this.outerColor = nbt.hasKey("OuterColor") ? nbt.getInteger("OuterColor") : 0xFF0000;
|
||||
this.outerColorEnabled = !nbt.hasKey("OuterColorEnabled") || nbt.getBoolean("OuterColorEnabled");
|
||||
this.zoneHeight = nbt.hasKey("ZoneHeight") ? nbt.getFloat("ZoneHeight") : 2.0f;
|
||||
this.particleDensity = nbt.hasKey("ParticleDensity") ? nbt.getFloat("ParticleDensity") : 1.0f;
|
||||
this.particleScale = nbt.hasKey("ParticleScale") ? nbt.getFloat("ParticleScale") : 1.0f;
|
||||
this.animSpeed = nbt.hasKey("AnimSpeed") ? nbt.getFloat("AnimSpeed") : 1.0f;
|
||||
this.lightningDensity = nbt.hasKey("LightningDensity") ? nbt.getFloat("LightningDensity") : 1.0f;
|
||||
this.deathWorldTime = nbt.getLong("DeathWorldTime");
|
||||
|
||||
// Visual layer fields
|
||||
this.groundFill = nbt.getBoolean("GroundFill");
|
||||
this.groundAlpha = nbt.getFloat("GroundAlpha");
|
||||
this.rings = nbt.getBoolean("Rings");
|
||||
this.ringCount = nbt.getInteger("RingCount");
|
||||
this.border = nbt.getBoolean("Border");
|
||||
this.borderSpeed = nbt.getFloat("BorderSpeed");
|
||||
this.accents = nbt.getBoolean("Accents");
|
||||
this.accentStyle = nbt.getInteger("AccentStyle");
|
||||
this.lightning = nbt.getBoolean("Lightning");
|
||||
this.particles = nbt.getBoolean("Particles");
|
||||
this.particleMotion = nbt.getInteger("ParticleMotion");
|
||||
this.particleDir = nbt.getString("ParticleDir");
|
||||
this.particleSize = nbt.getInteger("ParticleSize");
|
||||
this.particleGlow = nbt.getBoolean("ParticleGlow");
|
||||
|
||||
// Trap
|
||||
this.armTime = nbt.getInteger("ArmTime");
|
||||
this.triggerRadius = nbt.getFloat("TriggerRadius");
|
||||
this.maxTriggers = nbt.getInteger("MaxTriggers");
|
||||
this.triggerCooldown = nbt.getInteger("TriggerCooldown");
|
||||
this.damage = nbt.getFloat("Damage");
|
||||
this.damageRadius = nbt.getFloat("DamageRadius");
|
||||
this.knockback = nbt.getFloat("Knockback");
|
||||
this.visible = nbt.getBoolean("Visible");
|
||||
|
||||
// Hazard
|
||||
this.damagePerSecond = nbt.hasKey("DamagePerSecond") ? nbt.getFloat("DamagePerSecond") : 1.0f;
|
||||
this.damageInterval = nbt.hasKey("DamageInterval") ? nbt.getInteger("DamageInterval") : 20;
|
||||
if (damageInterval <= 0) damageInterval = 1;
|
||||
this.ignoreInvulnFrames = nbt.getBoolean("IgnoreInvuln");
|
||||
this.affectsCaster = nbt.getBoolean("AffectsCaster");
|
||||
|
||||
// Effects
|
||||
effects.clear();
|
||||
if (nbt.hasKey("Effects")) {
|
||||
NBTTagList effectList = nbt.getTagList("Effects", 10);
|
||||
for (int i = 0; i < effectList.tagCount(); i++) {
|
||||
AbilityPotionEffect effect = AbilityPotionEffect.fromNBT(effectList.getCompoundTagAt(i));
|
||||
if (effect != null && effect.isValid()) {
|
||||
effects.add(effect);
|
||||
}
|
||||
}
|
||||
}
|
||||
// Intentionally empty — ability entities are transient (not saved to world)
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void writeEntityToNBT(NBTTagCompound nbt) {
|
||||
nbt.setInteger("ZoneType", zoneType.ordinal());
|
||||
nbt.setString("ShapeName", shape.name());
|
||||
nbt.setInteger("OwnerId", ownerEntityId);
|
||||
nbt.setFloat("Radius", radius);
|
||||
nbt.setInteger("Duration", durationTicks);
|
||||
nbt.setInteger("MaxTicks", maxTicks);
|
||||
nbt.setInteger("InnerColor", innerColor);
|
||||
nbt.setInteger("OuterColor", outerColor);
|
||||
nbt.setBoolean("OuterColorEnabled", outerColorEnabled);
|
||||
nbt.setFloat("ZoneHeight", zoneHeight);
|
||||
nbt.setFloat("ParticleDensity", particleDensity);
|
||||
nbt.setFloat("ParticleScale", particleScale);
|
||||
nbt.setFloat("AnimSpeed", animSpeed);
|
||||
nbt.setFloat("LightningDensity", lightningDensity);
|
||||
nbt.setLong("DeathWorldTime", deathWorldTime);
|
||||
|
||||
// Visual layer fields
|
||||
nbt.setBoolean("GroundFill", groundFill);
|
||||
nbt.setFloat("GroundAlpha", groundAlpha);
|
||||
nbt.setBoolean("Rings", rings);
|
||||
nbt.setInteger("RingCount", ringCount);
|
||||
nbt.setBoolean("Border", border);
|
||||
nbt.setFloat("BorderSpeed", borderSpeed);
|
||||
nbt.setBoolean("Accents", accents);
|
||||
nbt.setInteger("AccentStyle", accentStyle);
|
||||
nbt.setBoolean("Lightning", lightning);
|
||||
nbt.setBoolean("Particles", particles);
|
||||
nbt.setInteger("ParticleMotion", particleMotion);
|
||||
nbt.setString("ParticleDir", particleDir);
|
||||
nbt.setInteger("ParticleSize", particleSize);
|
||||
nbt.setBoolean("ParticleGlow", particleGlow);
|
||||
|
||||
// Trap
|
||||
nbt.setInteger("ArmTime", armTime);
|
||||
nbt.setFloat("TriggerRadius", triggerRadius);
|
||||
nbt.setInteger("MaxTriggers", maxTriggers);
|
||||
nbt.setInteger("TriggerCooldown", triggerCooldown);
|
||||
nbt.setFloat("Damage", damage);
|
||||
nbt.setFloat("DamageRadius", damageRadius);
|
||||
nbt.setFloat("Knockback", knockback);
|
||||
nbt.setBoolean("Visible", visible);
|
||||
|
||||
// Hazard
|
||||
nbt.setFloat("DamagePerSecond", damagePerSecond);
|
||||
nbt.setInteger("DamageInterval", damageInterval);
|
||||
nbt.setBoolean("IgnoreInvuln", ignoreInvulnFrames);
|
||||
nbt.setBoolean("AffectsCaster", affectsCaster);
|
||||
|
||||
// Effects
|
||||
NBTTagList effectList = new NBTTagList();
|
||||
for (AbilityPotionEffect effect : effects) {
|
||||
effectList.appendTag(effect.writeNBT());
|
||||
}
|
||||
nbt.setTag("Effects", effectList);
|
||||
// Intentionally empty — ability entities are transient (not saved to world)
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
@@ -849,7 +731,7 @@ public class EntityAbilityZone extends Entity implements IEntityAdditionalSpawnD
|
||||
@Override
|
||||
public void writeSpawnData(ByteBuf buffer) {
|
||||
buffer.writeInt(zoneType.ordinal());
|
||||
ByteBufUtils.writeUTF8String(buffer, shape.name());
|
||||
ByteBufUtils.writeString(buffer, shape.name());
|
||||
buffer.writeInt(ownerEntityId);
|
||||
buffer.writeFloat(radius);
|
||||
buffer.writeInt(durationTicks);
|
||||
@@ -875,7 +757,7 @@ public class EntityAbilityZone extends Entity implements IEntityAdditionalSpawnD
|
||||
buffer.writeBoolean(lightning);
|
||||
buffer.writeBoolean(particles);
|
||||
buffer.writeInt(particleMotion);
|
||||
ByteBufUtils.writeUTF8String(buffer, particleDir);
|
||||
ByteBufUtils.writeString(buffer, particleDir);
|
||||
buffer.writeInt(particleSize);
|
||||
buffer.writeBoolean(particleGlow);
|
||||
|
||||
@@ -890,14 +772,18 @@ public class EntityAbilityZone extends Entity implements IEntityAdditionalSpawnD
|
||||
effectList.appendTag(effect.writeNBT());
|
||||
}
|
||||
effectsNbt.setTag("Effects", effectList);
|
||||
ByteBufUtils.writeTag(buffer, effectsNbt);
|
||||
try {
|
||||
ByteBufUtils.writeNBT(buffer, effectsNbt);
|
||||
} catch (java.io.IOException e) {
|
||||
noppes.npcs.LogWriter.error("Error writing zone effects spawn data", e);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void readSpawnData(ByteBuf buffer) {
|
||||
int zoneTypeOrd = buffer.readInt();
|
||||
this.zoneType = (zoneTypeOrd >= 0 && zoneTypeOrd < ZoneType.values().length) ? ZoneType.values()[zoneTypeOrd] : ZoneType.TRAP;
|
||||
String shapeName = ByteBufUtils.readUTF8String(buffer);
|
||||
String shapeName = ByteBufUtils.readString(buffer);
|
||||
try {
|
||||
this.shape = ZoneShape.valueOf(shapeName);
|
||||
} catch (Exception e) {
|
||||
@@ -928,7 +814,7 @@ public class EntityAbilityZone extends Entity implements IEntityAdditionalSpawnD
|
||||
this.lightning = buffer.readBoolean();
|
||||
this.particles = buffer.readBoolean();
|
||||
this.particleMotion = buffer.readInt();
|
||||
this.particleDir = ByteBufUtils.readUTF8String(buffer);
|
||||
this.particleDir = ByteBufUtils.readString(buffer);
|
||||
this.particleSize = buffer.readInt();
|
||||
this.particleGlow = buffer.readBoolean();
|
||||
|
||||
@@ -936,7 +822,12 @@ public class EntityAbilityZone extends Entity implements IEntityAdditionalSpawnD
|
||||
this.visible = buffer.readBoolean();
|
||||
|
||||
// Effects
|
||||
NBTTagCompound effectsNbt = ByteBufUtils.readTag(buffer);
|
||||
NBTTagCompound effectsNbt = null;
|
||||
try {
|
||||
effectsNbt = ByteBufUtils.readNBT(buffer);
|
||||
} catch (java.io.IOException e) {
|
||||
noppes.npcs.LogWriter.error("Error reading zone effects spawn data", e);
|
||||
}
|
||||
effects.clear();
|
||||
if (effectsNbt != null && effectsNbt.hasKey("Effects")) {
|
||||
NBTTagList effectList = effectsNbt.getTagList("Effects", 10);
|
||||
|
||||
@@ -7,6 +7,7 @@ import io.netty.buffer.ByteBuf;
|
||||
import kamkeel.npcs.controllers.data.ability.Ability;
|
||||
import kamkeel.npcs.controllers.data.ability.data.EnergyDisplayData;
|
||||
import kamkeel.npcs.controllers.data.ability.data.EnergyLightningData;
|
||||
import kamkeel.npcs.util.ByteBufUtils;
|
||||
import net.minecraft.entity.Entity;
|
||||
import net.minecraft.entity.EntityLivingBase;
|
||||
import net.minecraft.nbt.NBTTagCompound;
|
||||
@@ -314,12 +315,30 @@ public abstract class EntityEnergyAbility extends Entity implements IEntityAddit
|
||||
|
||||
// ==================== SPAWN DATA ====================
|
||||
|
||||
/**
|
||||
* Write entity data for client sync. Subclasses override this
|
||||
* to serialize their fields. Separate from writeEntityToNBT
|
||||
* which is intentionally empty (entities are transient, not saved to world).
|
||||
*/
|
||||
protected void writeSpawnNBT(NBTTagCompound nbt) {
|
||||
writeEnergyBaseNBT(nbt);
|
||||
}
|
||||
|
||||
/**
|
||||
* Read entity data from client sync. Subclasses override this
|
||||
* to deserialize their fields. Separate from readEntityFromNBT
|
||||
* which is intentionally empty (entities are transient, not saved to world).
|
||||
*/
|
||||
protected void readSpawnNBT(NBTTagCompound nbt) {
|
||||
readEnergyBaseNBT(nbt);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void writeSpawnData(ByteBuf buffer) {
|
||||
try {
|
||||
NBTTagCompound compound = new NBTTagCompound();
|
||||
this.writeEntityToNBT(compound);
|
||||
cpw.mods.fml.common.network.ByteBufUtils.writeTag(buffer, compound);
|
||||
this.writeSpawnNBT(compound);
|
||||
ByteBufUtils.writeNBT(buffer, compound);
|
||||
} catch (Exception e) {
|
||||
noppes.npcs.LogWriter.error("Error writing energy ability spawn data", e);
|
||||
}
|
||||
@@ -328,9 +347,9 @@ public abstract class EntityEnergyAbility extends Entity implements IEntityAddit
|
||||
@Override
|
||||
public void readSpawnData(ByteBuf buffer) {
|
||||
try {
|
||||
NBTTagCompound compound = cpw.mods.fml.common.network.ByteBufUtils.readTag(buffer);
|
||||
NBTTagCompound compound = ByteBufUtils.readNBT(buffer);
|
||||
if (compound != null) {
|
||||
this.readEntityFromNBT(compound);
|
||||
this.readSpawnNBT(compound);
|
||||
}
|
||||
} catch (Exception e) {
|
||||
noppes.npcs.LogWriter.error("Error reading energy ability spawn data", e);
|
||||
|
||||
@@ -1,284 +0,0 @@
|
||||
package kamkeel.npcs.entity;
|
||||
|
||||
import cpw.mods.fml.relauncher.Side;
|
||||
import cpw.mods.fml.relauncher.SideOnly;
|
||||
import kamkeel.npcs.controllers.data.ability.data.EnergyBarrierData;
|
||||
import kamkeel.npcs.controllers.data.ability.data.EnergyDisplayData;
|
||||
import kamkeel.npcs.controllers.data.ability.data.EnergyLightningData;
|
||||
import net.minecraft.entity.Entity;
|
||||
import net.minecraft.entity.EntityLivingBase;
|
||||
import net.minecraft.nbt.NBTTagCompound;
|
||||
import net.minecraft.util.AxisAlignedBB;
|
||||
import net.minecraft.util.DamageSource;
|
||||
import net.minecraft.world.World;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Energy Dome entity - a spherical barrier that blocks incoming energy projectiles.
|
||||
* Centered on the caster's position at time of casting.
|
||||
* Only blocks incoming attacks (not outgoing from allies inside).
|
||||
* Extends EntityEnergyBarrier for shared barrier logic.
|
||||
*/
|
||||
public class EntityEnergyDome extends EntityEnergyBarrier {
|
||||
|
||||
// ==================== DOME-SPECIFIC PROPERTIES ====================
|
||||
protected float domeRadius = 5.0f;
|
||||
protected float targetDomeRadius = 5.0f;
|
||||
protected boolean followCaster = false;
|
||||
|
||||
public EntityEnergyDome(World world) {
|
||||
super(world);
|
||||
this.setSize(1.0f, 1.0f);
|
||||
}
|
||||
|
||||
public EntityEnergyDome(World world, EntityLivingBase owner, double x, double y, double z,
|
||||
float domeRadius, EnergyDisplayData display, EnergyLightningData lightning,
|
||||
EnergyBarrierData barrier) {
|
||||
this(world);
|
||||
this.ownerEntityId = owner.getEntityId();
|
||||
this.domeRadius = domeRadius;
|
||||
this.displayData = display;
|
||||
this.lightningData = lightning;
|
||||
this.barrierData = barrier;
|
||||
this.currentHealth = barrier.maxHealth;
|
||||
this.setPosition(x, y, z);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onUpdate() {
|
||||
this.prevPosX = this.posX;
|
||||
this.prevPosY = this.posY;
|
||||
this.prevPosZ = this.posZ;
|
||||
|
||||
super.onUpdate();
|
||||
|
||||
// Follow caster: both sides for smooth interpolated rendering
|
||||
if (followCaster) {
|
||||
Entity owner = ownerEntityId >= 0 ? worldObj.getEntityByID(ownerEntityId) : null;
|
||||
if (owner != null) {
|
||||
this.setPosition(owner.posX, owner.posY, owner.posZ);
|
||||
}
|
||||
}
|
||||
|
||||
// Handle charging animation (both sides for smooth rendering)
|
||||
if (isCharging()) {
|
||||
chargeTick++;
|
||||
float progress = getChargeProgress();
|
||||
this.domeRadius = targetDomeRadius * progress;
|
||||
return; // Don't tick duration/death during charging
|
||||
}
|
||||
|
||||
ticksAlive++;
|
||||
|
||||
if (updateBarrierTick()) return;
|
||||
|
||||
// Knockback entities inside the dome
|
||||
if (!worldObj.isRemote && barrierData.knockbackEnabled) {
|
||||
knockbackEntities();
|
||||
}
|
||||
}
|
||||
|
||||
// ==================== INCOMING CHECK ====================
|
||||
|
||||
/**
|
||||
* Check if a projectile at the given position is entering this dome from outside.
|
||||
* Only blocks incoming projectiles (dot product check).
|
||||
*/
|
||||
@Override
|
||||
public boolean isIncomingProjectile(EntityEnergyProjectile projectile) {
|
||||
// Don't block during charging phase
|
||||
if (isCharging()) return false;
|
||||
// Don't block projectiles from the dome's owner
|
||||
if (projectile.getOwnerEntityId() == this.ownerEntityId) return false;
|
||||
|
||||
// Don't block projectiles from same-faction NPCs
|
||||
Entity owner = getOwnerEntity();
|
||||
Entity projOwner = projectile.getOwnerEntity();
|
||||
if (owner instanceof noppes.npcs.entity.EntityNPCInterface && projOwner instanceof noppes.npcs.entity.EntityNPCInterface) {
|
||||
if (((noppes.npcs.entity.EntityNPCInterface) owner).faction.id == ((noppes.npcs.entity.EntityNPCInterface) projOwner).faction.id) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
double dx = projectile.posX - this.posX;
|
||||
double dy = projectile.posY - this.posY;
|
||||
double dz = projectile.posZ - this.posZ;
|
||||
double dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
|
||||
|
||||
// Check if projectile is outside dome radius
|
||||
if (dist > domeRadius) return false;
|
||||
|
||||
// Approximate the projectile's position before last tick's movement.
|
||||
// checkBarrierCollision runs BEFORE updateProjectile, so posX is post-last-movement.
|
||||
// posX - motionX gives the pre-movement position (works for moveEntity and setPosition).
|
||||
double prevDx = (projectile.posX - projectile.motionX) - this.posX;
|
||||
double prevDy = (projectile.posY - projectile.motionY) - this.posY;
|
||||
double prevDz = (projectile.posZ - projectile.motionZ) - this.posZ;
|
||||
double prevDist = Math.sqrt(prevDx * prevDx + prevDy * prevDy + prevDz * prevDz);
|
||||
|
||||
// Only block projectiles that crossed the dome boundary from outside.
|
||||
// Projectiles spawned inside (prevDist < radius) pass through freely.
|
||||
if (prevDist < domeRadius) return false;
|
||||
|
||||
// Projectile entered from outside — check it's still moving inward
|
||||
double dot = dx * projectile.motionX + dy * projectile.motionY + dz * projectile.motionZ;
|
||||
return dot < 0;
|
||||
}
|
||||
|
||||
// ==================== CHARGING ====================
|
||||
|
||||
@Override
|
||||
public void setupCharging(int duration) {
|
||||
this.targetDomeRadius = this.domeRadius;
|
||||
this.domeRadius = 0.01f;
|
||||
this.chargeDuration = duration;
|
||||
this.chargeTick = 0;
|
||||
setCharging(true);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void finishCharging() {
|
||||
this.domeRadius = targetDomeRadius;
|
||||
setCharging(false);
|
||||
}
|
||||
|
||||
// ==================== KNOCKBACK ====================
|
||||
|
||||
/**
|
||||
* Push entities away from the dome surface.
|
||||
* Entities outside are pushed outward, entities inside are pushed inward (containment).
|
||||
*/
|
||||
@Override
|
||||
@SuppressWarnings("unchecked")
|
||||
protected void knockbackEntities() {
|
||||
float margin = 1.0f;
|
||||
AxisAlignedBB searchBox = AxisAlignedBB.getBoundingBox(
|
||||
posX - domeRadius - margin, posY - domeRadius - margin, posZ - domeRadius - margin,
|
||||
posX + domeRadius + margin, posY + domeRadius + margin, posZ + domeRadius + margin
|
||||
);
|
||||
|
||||
List<EntityLivingBase> entities = worldObj.getEntitiesWithinAABB(EntityLivingBase.class, searchBox);
|
||||
for (EntityLivingBase ent : entities) {
|
||||
if (ent.getEntityId() == ownerEntityId) continue;
|
||||
if (!isKnockbackTarget(ent)) continue;
|
||||
|
||||
double dx = ent.posX - posX;
|
||||
double dy = (ent.posY + ent.height * 0.5) - posY;
|
||||
double dz = ent.posZ - posZ;
|
||||
double dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
|
||||
|
||||
if (dist < 0.01) continue;
|
||||
|
||||
// Only affect entities near the dome surface
|
||||
if (dist < domeRadius + margin && dist > domeRadius - margin) {
|
||||
double pushStrength = barrierData.knockbackStrength * 0.5;
|
||||
double pushDir = dist >= domeRadius ? 1.0 : -1.0; // Outside = outward, Inside = inward
|
||||
ent.addVelocity(
|
||||
(dx / dist) * pushStrength * pushDir,
|
||||
0.05 * pushDir,
|
||||
(dz / dist) * pushStrength * pushDir
|
||||
);
|
||||
ent.velocityChanged = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ==================== MELEE (spherical check) ====================
|
||||
|
||||
/**
|
||||
* Reject melee hits that land on the cubic bounding box but are outside the actual sphere.
|
||||
*/
|
||||
@Override
|
||||
public boolean attackEntityFrom(DamageSource source, float amount) {
|
||||
if (source.getEntity() != null) {
|
||||
Entity attacker = source.getEntity();
|
||||
double dx = attacker.posX - this.posX;
|
||||
double dy = (attacker.posY + attacker.height * 0.5) - this.posY;
|
||||
double dz = attacker.posZ - this.posZ;
|
||||
double distSq = dx * dx + dy * dy + dz * dz;
|
||||
// Allow hit only if attacker is within sphere + melee reach margin
|
||||
double maxDist = domeRadius + 5.0;
|
||||
if (distSq > maxDist * maxDist) return false;
|
||||
}
|
||||
return super.attackEntityFrom(source, amount);
|
||||
}
|
||||
|
||||
// ==================== BOUNDING BOX ====================
|
||||
|
||||
/**
|
||||
* Expands the ray-trace targeting area so players can melee-hit the dome
|
||||
* from anywhere near its surface, not just the tiny 1x1 center.
|
||||
* This is used by EntityRenderer.getMouseOver() to expand the entity BB
|
||||
* for crosshair targeting without modifying the actual bounding box.
|
||||
*/
|
||||
@Override
|
||||
public float getCollisionBorderSize() {
|
||||
return domeRadius;
|
||||
}
|
||||
|
||||
@Override
|
||||
@SideOnly(Side.CLIENT)
|
||||
public boolean isInRangeToRenderDist(double distance) {
|
||||
double d = domeRadius * 8.0D;
|
||||
d *= 64.0D;
|
||||
return distance < d * d;
|
||||
}
|
||||
|
||||
// ==================== DISTANCE (for render sorting) ====================
|
||||
|
||||
/**
|
||||
* Returns squared distance from the given point to the nearest point on the dome sphere surface.
|
||||
* Uses absolute distance to surface: |centerDist - radius|.
|
||||
* <p>
|
||||
* Inside: nearest surface is (radius - centerDist) away.
|
||||
* Outside: nearest surface is (centerDist - radius) away.
|
||||
* This ensures entities inside the dome sort correctly relative to the dome shell.
|
||||
*/
|
||||
@Override
|
||||
public double getDistanceSq(double x, double y, double z) {
|
||||
double dx = this.posX - x;
|
||||
double dy = this.posY - y;
|
||||
double dz = this.posZ - z;
|
||||
double centerDist = Math.sqrt(dx * dx + dy * dy + dz * dz);
|
||||
|
||||
double surfaceDist = Math.abs(centerDist - domeRadius);
|
||||
return surfaceDist * surfaceDist;
|
||||
}
|
||||
|
||||
// ==================== GETTERS ====================
|
||||
|
||||
public float getDomeRadius() {
|
||||
return domeRadius;
|
||||
}
|
||||
|
||||
public void setDomeRadius(float radius) {
|
||||
this.domeRadius = Math.max(0.1f, radius);
|
||||
}
|
||||
|
||||
public boolean isFollowCaster() {
|
||||
return followCaster;
|
||||
}
|
||||
|
||||
public void setFollowCaster(boolean follow) {
|
||||
this.followCaster = follow;
|
||||
}
|
||||
|
||||
// ==================== NBT ====================
|
||||
|
||||
@Override
|
||||
protected void readEntityFromNBT(NBTTagCompound nbt) {
|
||||
readBarrierBaseNBT(nbt);
|
||||
this.domeRadius = sanitize(nbt.getFloat("DomeRadius"), 5.0f, MAX_ENTITY_RADIUS);
|
||||
this.targetDomeRadius = sanitize(nbt.hasKey("TargetDomeRadius") ? nbt.getFloat("TargetDomeRadius") : domeRadius, 5.0f, MAX_ENTITY_RADIUS);
|
||||
this.followCaster = nbt.hasKey("FollowCaster") && nbt.getBoolean("FollowCaster");
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void writeEntityToNBT(NBTTagCompound nbt) {
|
||||
writeBarrierBaseNBT(nbt);
|
||||
nbt.setFloat("DomeRadius", domeRadius);
|
||||
nbt.setFloat("TargetDomeRadius", targetDomeRadius);
|
||||
nbt.setBoolean("FollowCaster", followCaster);
|
||||
}
|
||||
}
|
||||
@@ -318,19 +318,21 @@ public abstract class EntityEnergyProjectile extends EntityEnergyAbility {
|
||||
* @return true if projectile was absorbed (caller should stop processing)
|
||||
*/
|
||||
protected boolean checkBarrierCollision() {
|
||||
// Search range must cover the largest possible barrier (dome radius up to MAX_ENTITY_RADIUS)
|
||||
double searchRange = MAX_ENTITY_RADIUS + 5;
|
||||
AxisAlignedBB searchBox = AxisAlignedBB.getBoundingBox(
|
||||
posX - searchRange, posY - searchRange, posZ - searchRange,
|
||||
posX + searchRange, posY + searchRange, posZ + searchRange
|
||||
);
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
List<EntityEnergyBarrier> barriers = worldObj.getEntitiesWithinAABB(EntityEnergyBarrier.class, searchBox);
|
||||
for (EntityEnergyBarrier barrier : barriers) {
|
||||
List<EntityAbilityBarrier> barriers = EntityAbilityBarrier.getActiveBarriers(worldObj);
|
||||
for (EntityAbilityBarrier barrier : barriers) {
|
||||
if (barrier.isDead) continue;
|
||||
|
||||
// Quick distance pre-filter
|
||||
double dx = barrier.posX - this.posX;
|
||||
double dy = barrier.posY - this.posY;
|
||||
double dz = barrier.posZ - this.posZ;
|
||||
double distSq = dx * dx + dy * dy + dz * dz;
|
||||
double maxRange = barrier.getMaxExtent() + 5.0;
|
||||
if (distSq > maxRange * maxRange) continue;
|
||||
|
||||
if (barrier.isIncomingProjectile(this)) {
|
||||
if (barrier.onProjectileHit(this, getDamage())) {
|
||||
float damage = getModifiedDamage();
|
||||
if (barrier.onProjectileHit(this, damage)) {
|
||||
hasHit = true;
|
||||
this.setDead();
|
||||
return true;
|
||||
@@ -341,6 +343,22 @@ public abstract class EntityEnergyProjectile extends EntityEnergyAbility {
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the projectile damage modified by extenders (e.g. DBC damage scaling).
|
||||
* Falls back to base getDamage() when no sourceAbility or no extenders modify it.
|
||||
*/
|
||||
protected float getModifiedDamage() {
|
||||
float damage = getDamage();
|
||||
if (sourceAbility != null) {
|
||||
Entity owner = getOwnerEntity();
|
||||
if (owner instanceof EntityLivingBase) {
|
||||
damage = AbilityController.Instance.fireModifyProjectileDamage(
|
||||
sourceAbility, (EntityLivingBase) owner, damage);
|
||||
}
|
||||
}
|
||||
return damage;
|
||||
}
|
||||
|
||||
// ==================== POSITION INTERPOLATION ====================
|
||||
|
||||
@Override
|
||||
@@ -908,16 +926,26 @@ public abstract class EntityEnergyProjectile extends EntityEnergyAbility {
|
||||
|
||||
@Override
|
||||
protected void readEntityFromNBT(NBTTagCompound nbt) {
|
||||
readBaseNBT(nbt);
|
||||
readProjectileNBT(nbt);
|
||||
// Intentionally empty — ability entities are transient (not saved to world)
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void writeEntityToNBT(NBTTagCompound nbt) {
|
||||
// Intentionally empty — ability entities are transient (not saved to world)
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void writeSpawnNBT(NBTTagCompound nbt) {
|
||||
writeBaseNBT(nbt);
|
||||
writeProjectileNBT(nbt);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void readSpawnNBT(NBTTagCompound nbt) {
|
||||
readBaseNBT(nbt);
|
||||
readProjectileNBT(nbt);
|
||||
}
|
||||
|
||||
/**
|
||||
* Read base projectile properties from NBT.
|
||||
*/
|
||||
|
||||
@@ -8,24 +8,9 @@ import cpw.mods.fml.common.network.internal.FMLProxyPacket;
|
||||
import cpw.mods.fml.relauncher.Side;
|
||||
import io.netty.buffer.ByteBuf;
|
||||
import kamkeel.npcs.network.enums.EnumChannelType;
|
||||
import kamkeel.npcs.network.packets.data.AchievementPacket;
|
||||
import kamkeel.npcs.network.packets.data.ChatAlertPacket;
|
||||
import kamkeel.npcs.network.packets.data.ChatBubblePacket;
|
||||
import kamkeel.npcs.network.packets.data.ClonerPacket;
|
||||
import kamkeel.npcs.network.packets.data.ConfigCommandPacket;
|
||||
import kamkeel.npcs.network.packets.data.DisableMouseInputPacket;
|
||||
import kamkeel.npcs.network.packets.data.LoginPacket;
|
||||
import kamkeel.npcs.network.packets.data.MarkDataPacket;
|
||||
import kamkeel.npcs.network.packets.data.OverlayQuestTrackingPacket;
|
||||
import kamkeel.npcs.network.packets.data.ParticlePacket;
|
||||
import kamkeel.npcs.network.packets.data.PlayerDataInfoPacket;
|
||||
import kamkeel.npcs.network.packets.data.PlayerUpdateSkinOverlaysPacket;
|
||||
import kamkeel.npcs.network.packets.data.QuestCompletionPacket;
|
||||
import kamkeel.npcs.network.packets.data.ScrollSelectedPacket;
|
||||
import kamkeel.npcs.network.packets.data.SoundManagementPacket;
|
||||
import kamkeel.npcs.network.packets.data.SwingPlayerArmPacket;
|
||||
import kamkeel.npcs.network.packets.data.UpdateAnimationsPacket;
|
||||
import kamkeel.npcs.network.packets.data.VillagerListPacket;
|
||||
import kamkeel.npcs.network.packets.data.*;
|
||||
import kamkeel.npcs.network.packets.data.ability.AbilityCooldownSyncPacket;
|
||||
import kamkeel.npcs.network.packets.data.ability.AbilityHotbarSyncPacket;
|
||||
import kamkeel.npcs.network.packets.data.ability.PlayerAbilityStatePacket;
|
||||
import kamkeel.npcs.network.packets.data.ability.PlayerAbilitySyncPacket;
|
||||
import kamkeel.npcs.network.packets.data.gui.GuiClosePacket;
|
||||
@@ -54,6 +39,9 @@ import kamkeel.npcs.network.packets.data.script.ScriptedParticlePacket;
|
||||
import kamkeel.npcs.network.packets.data.telegraph.TelegraphRemovePacket;
|
||||
import kamkeel.npcs.network.packets.data.telegraph.TelegraphSpawnPacket;
|
||||
import kamkeel.npcs.network.packets.player.AuctionActionPacket;
|
||||
import kamkeel.npcs.network.packets.player.ability.AbilityHotbarSavePacket;
|
||||
import kamkeel.npcs.network.packets.player.ability.AbilityHotbarSelectPacket;
|
||||
import kamkeel.npcs.network.packets.player.ability.AbilityTogglePacket;
|
||||
import kamkeel.npcs.network.packets.player.BankActionPacket;
|
||||
import kamkeel.npcs.network.packets.player.CheckPlayerValue;
|
||||
import kamkeel.npcs.network.packets.player.CompanionActionPacket;
|
||||
@@ -578,6 +566,7 @@ public class PacketHandler {
|
||||
DATA_PACKET.registerPacket(new DialogPacket());
|
||||
DATA_PACKET.registerPacket(new RolePacket());
|
||||
DATA_PACKET.registerPacket(new WeaponNpcPacket());
|
||||
DATA_PACKET.registerPacket(new RequestProperSpawnData());
|
||||
|
||||
// Data | Script Packets
|
||||
DATA_PACKET.registerPacket(new ScriptedParticlePacket());
|
||||
@@ -598,6 +587,8 @@ public class PacketHandler {
|
||||
DATA_PACKET.registerPacket(new TelegraphRemovePacket());
|
||||
DATA_PACKET.registerPacket(new PlayerAbilitySyncPacket());
|
||||
DATA_PACKET.registerPacket(new PlayerAbilityStatePacket());
|
||||
DATA_PACKET.registerPacket(new AbilityHotbarSyncPacket());
|
||||
DATA_PACKET.registerPacket(new AbilityCooldownSyncPacket());
|
||||
}
|
||||
|
||||
public void registerPlayerPackets() {
|
||||
@@ -663,6 +654,11 @@ public class PacketHandler {
|
||||
PLAYER_PACKET.registerPacket(new PartyAcceptInvitePacket());
|
||||
PLAYER_PACKET.registerPacket(new PartyIgnoreInvitePacket());
|
||||
PLAYER_PACKET.registerPacket(new PartyLogToServerPacket());
|
||||
|
||||
// Ability Hotbar Packets
|
||||
PLAYER_PACKET.registerPacket(new AbilityHotbarSavePacket());
|
||||
PLAYER_PACKET.registerPacket(new AbilityHotbarSelectPacket());
|
||||
PLAYER_PACKET.registerPacket(new AbilityTogglePacket());
|
||||
}
|
||||
|
||||
public void registerChannels() {
|
||||
|
||||
@@ -23,6 +23,7 @@ public enum EnumDataPacket {
|
||||
DELETE_NPC,
|
||||
CLONE_NPC,
|
||||
WEAPON_NPC,
|
||||
REQUEST_SPAWN_DATA,
|
||||
|
||||
// Data
|
||||
SCROLL_LIST,
|
||||
@@ -64,6 +65,8 @@ public enum EnumDataPacket {
|
||||
TELEGRAPH_REMOVE,
|
||||
PLAYER_ABILITY_SYNC,
|
||||
PLAYER_ABILITY_STATE,
|
||||
ABILITY_HOTBAR_SYNC,
|
||||
ABILITY_COOLDOWN_SYNC,
|
||||
|
||||
// Auction System
|
||||
AUCTION_DATA,
|
||||
|
||||
@@ -37,4 +37,9 @@ public enum EnumPlayerPacket {
|
||||
|
||||
// Auction
|
||||
AuctionAction,
|
||||
|
||||
// Ability Hotbar
|
||||
AbilityHotbarSave,
|
||||
AbilityHotbarSelect,
|
||||
AbilityToggle,
|
||||
}
|
||||
@@ -0,0 +1,119 @@
|
||||
package kamkeel.npcs.network.packets.data;
|
||||
|
||||
import cpw.mods.fml.common.FMLCommonHandler;
|
||||
import cpw.mods.fml.relauncher.Side;
|
||||
import cpw.mods.fml.relauncher.SideOnly;
|
||||
import io.netty.buffer.ByteBuf;
|
||||
import kamkeel.npcs.network.AbstractPacket;
|
||||
import kamkeel.npcs.network.PacketChannel;
|
||||
import kamkeel.npcs.network.PacketClient;
|
||||
import kamkeel.npcs.network.PacketHandler;
|
||||
import kamkeel.npcs.network.enums.EnumDataPacket;
|
||||
import kamkeel.npcs.network.packets.data.npc.UpdateNpcPacket;
|
||||
import net.minecraft.client.Minecraft;
|
||||
import net.minecraft.entity.Entity;
|
||||
import net.minecraft.entity.player.EntityPlayer;
|
||||
import net.minecraft.entity.player.EntityPlayerMP;
|
||||
import net.minecraft.nbt.NBTTagCompound;
|
||||
import noppes.npcs.LogWriter;
|
||||
import noppes.npcs.entity.EntityNPCInterface;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.util.HashSet;
|
||||
import java.util.Iterator;
|
||||
import java.util.Set;
|
||||
|
||||
public class RequestProperSpawnData extends AbstractPacket {
|
||||
public static final String packetName = "Data|SpawnData";
|
||||
private static final int BATCH_LIMIT = 5;
|
||||
|
||||
@SideOnly(Side.CLIENT)
|
||||
private static final Set<Integer> entitiesToFix = new HashSet<>();
|
||||
@SideOnly(Side.CLIENT)
|
||||
private static long lastBatchAttemptMillis = 0;
|
||||
|
||||
private int entityId;
|
||||
|
||||
public RequestProperSpawnData() {}
|
||||
|
||||
@SideOnly(Side.CLIENT)
|
||||
public RequestProperSpawnData(int entityId) {
|
||||
this.entityId = entityId;
|
||||
}
|
||||
|
||||
public static void clear() {
|
||||
entitiesToFix.clear();
|
||||
}
|
||||
|
||||
@Override
|
||||
public Enum getType() {
|
||||
return EnumDataPacket.REQUEST_SPAWN_DATA;
|
||||
}
|
||||
|
||||
@Override
|
||||
public PacketChannel getChannel() {
|
||||
return PacketHandler.DATA_PACKET;
|
||||
}
|
||||
|
||||
@Override
|
||||
@SideOnly(Side.CLIENT)
|
||||
public void sendData(ByteBuf out) throws IOException {
|
||||
out.writeInt(this.entityId);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void receiveData(ByteBuf in, EntityPlayer player) throws IOException {
|
||||
if (FMLCommonHandler.instance().getEffectiveSide().isClient())
|
||||
return;
|
||||
|
||||
int entityId = in.readInt();
|
||||
Entity entity = Minecraft.getMinecraft().theWorld.getEntityByID(entityId);
|
||||
if (entity instanceof EntityNPCInterface) {
|
||||
EntityNPCInterface npc = (EntityNPCInterface) entity;
|
||||
NBTTagCompound compound = npc.writeSpawnData();
|
||||
compound.setInteger("EntityId", npc.getEntityId());
|
||||
PacketHandler.Instance.sendToPlayer(new UpdateNpcPacket(compound), (EntityPlayerMP) player);
|
||||
}
|
||||
}
|
||||
|
||||
@SideOnly(Side.CLIENT)
|
||||
public static void reportMissingData(EntityNPCInterface npc) {
|
||||
int entityID = npc.getEntityId();
|
||||
|
||||
if (npc.immediateSpawnDataFixAttempts++ < 3) {
|
||||
PacketClient.sendClient(new RequestProperSpawnData(entityID));
|
||||
} else {
|
||||
entitiesToFix.add(entityID);
|
||||
}
|
||||
}
|
||||
|
||||
@SideOnly(Side.CLIENT)
|
||||
public static boolean canDoBatchUpdate() {
|
||||
return System.currentTimeMillis() - lastBatchAttemptMillis >= 5000;
|
||||
}
|
||||
|
||||
@SideOnly(Side.CLIENT)
|
||||
public static void handleBacklog() {
|
||||
Minecraft mc = Minecraft.getMinecraft();
|
||||
if (mc == null || mc.theWorld == null || mc.thePlayer == null)
|
||||
return;
|
||||
|
||||
if (entitiesToFix.isEmpty())
|
||||
return;
|
||||
// Remove entity checks if they're no longer loaded
|
||||
entitiesToFix.removeIf( value -> !(Minecraft.getMinecraft().theWorld.getEntityByID(value) instanceof EntityNPCInterface) );
|
||||
|
||||
Iterator<Integer> it = entitiesToFix.iterator();
|
||||
int count = 0;
|
||||
|
||||
while (it.hasNext() && count < BATCH_LIMIT) {
|
||||
PacketClient.sendClient(new RequestProperSpawnData(it.next()));
|
||||
it.remove();
|
||||
count++;
|
||||
}
|
||||
|
||||
if (count != 0) {
|
||||
lastBatchAttemptMillis = System.currentTimeMillis();
|
||||
}
|
||||
}
|
||||
}
|
||||
+109
@@ -0,0 +1,109 @@
|
||||
package kamkeel.npcs.network.packets.data.ability;
|
||||
|
||||
import cpw.mods.fml.relauncher.Side;
|
||||
import cpw.mods.fml.relauncher.SideOnly;
|
||||
import io.netty.buffer.ByteBuf;
|
||||
import kamkeel.npcs.network.AbstractPacket;
|
||||
import kamkeel.npcs.network.PacketChannel;
|
||||
import kamkeel.npcs.network.PacketHandler;
|
||||
import kamkeel.npcs.network.enums.EnumDataPacket;
|
||||
import kamkeel.npcs.util.ByteBufUtils;
|
||||
import net.minecraft.entity.player.EntityPlayer;
|
||||
import net.minecraft.entity.player.EntityPlayerMP;
|
||||
import noppes.npcs.controllers.PlayerDataController;
|
||||
import noppes.npcs.controllers.data.PlayerData;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
|
||||
/**
|
||||
* Lightweight packet that syncs cooldown state (global + per-ability) to the client.
|
||||
* Sent when cooldowns are rolled, reset, or on login.
|
||||
*/
|
||||
public final class AbilityCooldownSyncPacket extends AbstractPacket {
|
||||
public static final String packetName = "Data|AbilityCooldownSync";
|
||||
|
||||
private long globalCooldownEndTime;
|
||||
private int globalCooldownDuration;
|
||||
private HashMap<String, Long> perAbilityCooldownEndTimes;
|
||||
private HashMap<String, Integer> perAbilityCooldownDurations;
|
||||
|
||||
public AbilityCooldownSyncPacket() {
|
||||
}
|
||||
|
||||
public AbilityCooldownSyncPacket(long globalEndTime, int globalDuration,
|
||||
HashMap<String, Long> perEndTimes,
|
||||
HashMap<String, Integer> perDurations) {
|
||||
this.globalCooldownEndTime = globalEndTime;
|
||||
this.globalCooldownDuration = globalDuration;
|
||||
this.perAbilityCooldownEndTimes = perEndTimes;
|
||||
this.perAbilityCooldownDurations = perDurations;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Enum getType() {
|
||||
return EnumDataPacket.ABILITY_COOLDOWN_SYNC;
|
||||
}
|
||||
|
||||
@Override
|
||||
public PacketChannel getChannel() {
|
||||
return PacketHandler.DATA_PACKET;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void sendData(ByteBuf out) throws IOException {
|
||||
out.writeLong(globalCooldownEndTime);
|
||||
out.writeInt(globalCooldownDuration);
|
||||
|
||||
// Write per-ability cooldowns
|
||||
int count = perAbilityCooldownEndTimes != null ? perAbilityCooldownEndTimes.size() : 0;
|
||||
out.writeInt(count);
|
||||
if (count > 0) {
|
||||
for (Map.Entry<String, Long> entry : perAbilityCooldownEndTimes.entrySet()) {
|
||||
ByteBufUtils.writeUTF8String(out, entry.getKey());
|
||||
out.writeLong(entry.getValue());
|
||||
Integer dur = perAbilityCooldownDurations.get(entry.getKey());
|
||||
out.writeInt(dur != null ? dur : 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@SideOnly(Side.CLIENT)
|
||||
@Override
|
||||
public void receiveData(ByteBuf in, EntityPlayer player) throws IOException {
|
||||
long globalEndTime = in.readLong();
|
||||
int globalDuration = in.readInt();
|
||||
|
||||
int count = in.readInt();
|
||||
HashMap<String, Long> perEndTimes = new HashMap<>();
|
||||
HashMap<String, Integer> perDurations = new HashMap<>();
|
||||
for (int i = 0; i < count; i++) {
|
||||
String key = ByteBufUtils.readUTF8String(in);
|
||||
long endTime = in.readLong();
|
||||
int duration = in.readInt();
|
||||
perEndTimes.put(key, endTime);
|
||||
perDurations.put(key, duration);
|
||||
}
|
||||
|
||||
PlayerData data = PlayerData.get(player);
|
||||
if (data != null && data.abilityData != null) {
|
||||
data.abilityData.applyCooldownSync(globalEndTime, globalDuration, perEndTimes, perDurations);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Send the player's current cooldown state to their client.
|
||||
*/
|
||||
public static void sendToPlayer(EntityPlayerMP player) {
|
||||
PlayerData data = PlayerDataController.Instance.getPlayerData(player);
|
||||
if (data == null || data.abilityData == null) return;
|
||||
|
||||
PacketHandler.Instance.sendToPlayer(new AbilityCooldownSyncPacket(
|
||||
data.abilityData.getCooldownEndTime(),
|
||||
data.abilityData.getGlobalCooldownDurationValue(),
|
||||
data.abilityData.getPerAbilityCooldownEndTimes(),
|
||||
data.abilityData.getPerAbilityCooldownDurations()
|
||||
), player);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,101 @@
|
||||
package kamkeel.npcs.network.packets.data.ability;
|
||||
|
||||
import cpw.mods.fml.relauncher.Side;
|
||||
import cpw.mods.fml.relauncher.SideOnly;
|
||||
import io.netty.buffer.ByteBuf;
|
||||
import kamkeel.npcs.controllers.AbilityController;
|
||||
import kamkeel.npcs.network.AbstractPacket;
|
||||
import kamkeel.npcs.network.PacketChannel;
|
||||
import kamkeel.npcs.network.PacketHandler;
|
||||
import kamkeel.npcs.network.enums.EnumDataPacket;
|
||||
import kamkeel.npcs.util.ByteBufUtils;
|
||||
import net.minecraft.entity.player.EntityPlayer;
|
||||
import net.minecraft.entity.player.EntityPlayerMP;
|
||||
import net.minecraft.nbt.NBTTagCompound;
|
||||
import noppes.npcs.client.ClientCacheHandler;
|
||||
import noppes.npcs.controllers.PlayerDataController;
|
||||
import noppes.npcs.controllers.data.AbilityHotbarData;
|
||||
import noppes.npcs.controllers.data.PlayerAbilityHotbarData;
|
||||
import noppes.npcs.controllers.data.PlayerData;
|
||||
|
||||
import java.io.IOException;
|
||||
|
||||
public final class AbilityHotbarSyncPacket extends AbstractPacket {
|
||||
public static final String packetName = "Data|AbilityHotbarSync";
|
||||
|
||||
private NBTTagCompound hotbarNBT;
|
||||
|
||||
public AbilityHotbarSyncPacket() {
|
||||
}
|
||||
|
||||
public AbilityHotbarSyncPacket(NBTTagCompound hotbarNBT) {
|
||||
this.hotbarNBT = hotbarNBT;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Enum getType() {
|
||||
return EnumDataPacket.ABILITY_HOTBAR_SYNC;
|
||||
}
|
||||
|
||||
@Override
|
||||
public PacketChannel getChannel() {
|
||||
return PacketHandler.DATA_PACKET;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void sendData(ByteBuf out) throws IOException {
|
||||
ByteBufUtils.writeNBT(out, hotbarNBT);
|
||||
}
|
||||
|
||||
@SideOnly(Side.CLIENT)
|
||||
@Override
|
||||
public void receiveData(ByteBuf in, EntityPlayer player) throws IOException {
|
||||
NBTTagCompound nbt = ByteBufUtils.readNBT(in);
|
||||
if (nbt == null) return;
|
||||
|
||||
PlayerData data = ClientCacheHandler.playerData;
|
||||
if (data != null) {
|
||||
data.hotbarData.readFromNBT(nbt);
|
||||
}
|
||||
}
|
||||
|
||||
public static void sendToPlayer(EntityPlayerMP player) {
|
||||
PlayerData data = PlayerDataController.Instance.getPlayerData(player);
|
||||
if (data == null) return;
|
||||
|
||||
PlayerAbilityHotbarData hotbarData = data.hotbarData;
|
||||
boolean anyCleared = false;
|
||||
|
||||
// Validate all slots before sending
|
||||
if (AbilityController.Instance != null) {
|
||||
for (int i = 0; i < hotbarData.slots.length; i++) {
|
||||
AbilityHotbarData slot = hotbarData.slots[i];
|
||||
if (slot.isEmpty()) continue;
|
||||
|
||||
boolean valid;
|
||||
if (slot.isChainKey()) {
|
||||
valid = AbilityController.Instance.canResolveChainedAbility(slot.getResolveKey());
|
||||
} else {
|
||||
valid = AbilityController.Instance.canResolveAbility(slot.abilityKey);
|
||||
}
|
||||
|
||||
if (valid && data.abilityData != null) {
|
||||
valid = data.abilityData.hasUnlockedAbility(slot.abilityKey);
|
||||
}
|
||||
|
||||
if (!valid) {
|
||||
slot.reset();
|
||||
anyCleared = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
NBTTagCompound nbt = new NBTTagCompound();
|
||||
hotbarData.writeToNBT(nbt);
|
||||
PacketHandler.Instance.sendToPlayer(new AbilityHotbarSyncPacket(nbt), player);
|
||||
|
||||
if (anyCleared) {
|
||||
data.save();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -57,19 +57,19 @@ public final class SpecialKeyStatePacket extends AbstractPacket {
|
||||
boolean wasDown = data.isSpecialKeyDown();
|
||||
data.setSpecialKeyDown(keyDown);
|
||||
|
||||
// Trigger ability activation on key press (rising edge)
|
||||
// Trigger ability activation or cancel on key press (rising edge)
|
||||
if (keyDown && !wasDown) {
|
||||
// Don't activate if player has a GUI open (not the default inventory)
|
||||
if (player.openContainer != null && !(player.openContainer instanceof net.minecraft.inventory.ContainerPlayer)) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Don't activate if player is riding an entity (mount)
|
||||
if (player.ridingEntity != null) {
|
||||
return;
|
||||
}
|
||||
|
||||
data.abilityData.activateAbility(player);
|
||||
// If currently executing an ability, try to cancel via double-press
|
||||
if (data.abilityData.isExecutingAbility() || data.abilityData.isExecutingChain()) {
|
||||
data.abilityData.tryCancelAbility();
|
||||
} else {
|
||||
data.abilityData.activateAbility(player);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+86
@@ -0,0 +1,86 @@
|
||||
package kamkeel.npcs.network.packets.player.ability;
|
||||
|
||||
import io.netty.buffer.ByteBuf;
|
||||
import kamkeel.npcs.controllers.AbilityController;
|
||||
import kamkeel.npcs.network.AbstractPacket;
|
||||
import kamkeel.npcs.network.PacketChannel;
|
||||
import kamkeel.npcs.network.PacketHandler;
|
||||
import kamkeel.npcs.network.enums.EnumPlayerPacket;
|
||||
import kamkeel.npcs.network.packets.data.ability.AbilityHotbarSyncPacket;
|
||||
import kamkeel.npcs.util.ByteBufUtils;
|
||||
import net.minecraft.entity.player.EntityPlayer;
|
||||
import net.minecraft.entity.player.EntityPlayerMP;
|
||||
import net.minecraft.nbt.NBTTagCompound;
|
||||
import noppes.npcs.controllers.PlayerDataController;
|
||||
import noppes.npcs.controllers.data.AbilityHotbarData;
|
||||
import noppes.npcs.controllers.data.PlayerData;
|
||||
|
||||
import java.io.IOException;
|
||||
|
||||
public final class AbilityHotbarSavePacket extends AbstractPacket {
|
||||
public static final String packetName = "Player|AbilityHotbarSave";
|
||||
|
||||
private int slotIndex;
|
||||
private NBTTagCompound slotData;
|
||||
|
||||
public AbilityHotbarSavePacket() {
|
||||
}
|
||||
|
||||
public AbilityHotbarSavePacket(int slotIndex, NBTTagCompound slotData) {
|
||||
this.slotIndex = slotIndex;
|
||||
this.slotData = slotData;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Enum getType() {
|
||||
return EnumPlayerPacket.AbilityHotbarSave;
|
||||
}
|
||||
|
||||
@Override
|
||||
public PacketChannel getChannel() {
|
||||
return PacketHandler.PLAYER_PACKET;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void sendData(ByteBuf out) throws IOException {
|
||||
out.writeInt(slotIndex);
|
||||
ByteBufUtils.writeNBT(out, slotData);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void receiveData(ByteBuf in, EntityPlayer player) throws IOException {
|
||||
int slot = in.readInt();
|
||||
NBTTagCompound compound = ByteBufUtils.readNBT(in);
|
||||
|
||||
if (slot < 0 || slot >= AbilityHotbarData.TOTAL_SLOTS) return;
|
||||
|
||||
PlayerData data = PlayerDataController.Instance.getPlayerData(player);
|
||||
if (data == null) return;
|
||||
|
||||
AbilityHotbarData slotData = data.hotbarData.getSlot(slot);
|
||||
if (slotData == null) return;
|
||||
|
||||
slotData.readFromNBT(compound.getCompoundTag("AbilityHotbar" + slot));
|
||||
|
||||
// Validate the ability key
|
||||
boolean valid = true;
|
||||
if (!slotData.isEmpty() && AbilityController.Instance != null) {
|
||||
if (slotData.isChainKey()) {
|
||||
valid = AbilityController.Instance.canResolveChainedAbility(slotData.getResolveKey());
|
||||
} else {
|
||||
valid = AbilityController.Instance.canResolveAbility(slotData.abilityKey);
|
||||
}
|
||||
|
||||
if (valid && data.abilityData != null) {
|
||||
valid = data.abilityData.hasUnlockedAbility(slotData.abilityKey);
|
||||
}
|
||||
}
|
||||
|
||||
if (!valid) {
|
||||
slotData.reset();
|
||||
}
|
||||
|
||||
data.save();
|
||||
AbilityHotbarSyncPacket.sendToPlayer((EntityPlayerMP) player);
|
||||
}
|
||||
}
|
||||
+63
@@ -0,0 +1,63 @@
|
||||
package kamkeel.npcs.network.packets.player.ability;
|
||||
|
||||
import io.netty.buffer.ByteBuf;
|
||||
import kamkeel.npcs.controllers.AbilityController;
|
||||
import kamkeel.npcs.controllers.data.ability.Ability;
|
||||
import kamkeel.npcs.controllers.data.ability.ChainedAbility;
|
||||
import kamkeel.npcs.network.AbstractPacket;
|
||||
import kamkeel.npcs.network.PacketChannel;
|
||||
import kamkeel.npcs.network.PacketHandler;
|
||||
import kamkeel.npcs.network.enums.EnumPlayerPacket;
|
||||
import kamkeel.npcs.util.ByteBufUtils;
|
||||
import net.minecraft.entity.player.EntityPlayer;
|
||||
import noppes.npcs.controllers.PlayerDataController;
|
||||
import noppes.npcs.controllers.data.AbilityHotbarData;
|
||||
import noppes.npcs.controllers.data.PlayerData;
|
||||
|
||||
import java.io.IOException;
|
||||
|
||||
public final class AbilityHotbarSelectPacket extends AbstractPacket {
|
||||
public static final String packetName = "Player|AbilityHotbarSelect";
|
||||
|
||||
private String abilityKey;
|
||||
|
||||
public AbilityHotbarSelectPacket() {
|
||||
}
|
||||
|
||||
public AbilityHotbarSelectPacket(String abilityKey) {
|
||||
this.abilityKey = abilityKey;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Enum getType() {
|
||||
return EnumPlayerPacket.AbilityHotbarSelect;
|
||||
}
|
||||
|
||||
@Override
|
||||
public PacketChannel getChannel() {
|
||||
return PacketHandler.PLAYER_PACKET;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void sendData(ByteBuf out) throws IOException {
|
||||
ByteBufUtils.writeString(out, abilityKey != null ? abilityKey : "");
|
||||
}
|
||||
|
||||
@Override
|
||||
public void receiveData(ByteBuf in, EntityPlayer player) throws IOException {
|
||||
String key = ByteBufUtils.readString(in);
|
||||
|
||||
PlayerData data = PlayerDataController.Instance.getPlayerData(player);
|
||||
if (data == null || data.abilityData == null) return;
|
||||
|
||||
if (key == null || key.isEmpty()) {
|
||||
// Deselect
|
||||
data.abilityData.setSelectedIndex(-1);
|
||||
} else {
|
||||
int index = data.abilityData.getUnlockedAbilityList().indexOf(key);
|
||||
if (index >= 0) {
|
||||
data.abilityData.setSelectedIndex(index);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,72 @@
|
||||
package kamkeel.npcs.network.packets.player.ability;
|
||||
|
||||
import io.netty.buffer.ByteBuf;
|
||||
import kamkeel.npcs.controllers.AbilityController;
|
||||
import kamkeel.npcs.controllers.data.ability.Ability;
|
||||
import kamkeel.npcs.network.AbstractPacket;
|
||||
import kamkeel.npcs.network.PacketChannel;
|
||||
import kamkeel.npcs.network.PacketHandler;
|
||||
import kamkeel.npcs.network.enums.EnumPlayerPacket;
|
||||
import kamkeel.npcs.util.ByteBufUtils;
|
||||
import net.minecraft.entity.player.EntityPlayer;
|
||||
import net.minecraft.util.ChatComponentText;
|
||||
import net.minecraft.util.StatCollector;
|
||||
import noppes.npcs.controllers.data.PlayerData;
|
||||
|
||||
import java.io.IOException;
|
||||
|
||||
public final class AbilityTogglePacket extends AbstractPacket {
|
||||
public static final String packetName = "Player|AbilityToggle";
|
||||
private String abilityKey;
|
||||
|
||||
public AbilityTogglePacket() {
|
||||
}
|
||||
|
||||
public AbilityTogglePacket(String abilityKey) {
|
||||
this.abilityKey = abilityKey;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Enum getType() {
|
||||
return EnumPlayerPacket.AbilityToggle;
|
||||
}
|
||||
|
||||
@Override
|
||||
public PacketChannel getChannel() {
|
||||
return PacketHandler.PLAYER_PACKET;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void sendData(ByteBuf out) throws IOException {
|
||||
ByteBufUtils.writeString(out, abilityKey != null ? abilityKey : "");
|
||||
}
|
||||
|
||||
@Override
|
||||
public void receiveData(ByteBuf in, EntityPlayer player) throws IOException {
|
||||
String key = ByteBufUtils.readString(in);
|
||||
if (key == null || key.isEmpty()) return;
|
||||
if (AbilityController.Instance == null) return;
|
||||
|
||||
Ability ability = AbilityController.Instance.resolveAbility(key);
|
||||
if (ability == null || !ability.isToggleable() || !ability.getAllowedBy().allowsPlayer()) return;
|
||||
|
||||
PlayerData playerData = PlayerData.get(player);
|
||||
if (playerData == null || playerData.abilityData == null) return;
|
||||
|
||||
int newState = playerData.abilityData.toggleAbility(key);
|
||||
|
||||
String displayName = ability.getDisplayName();
|
||||
if (newState > 0) {
|
||||
String stateLabel = ability.getToggleStateLabel(newState);
|
||||
if (stateLabel != null) {
|
||||
player.addChatMessage(new ChatComponentText("\u00A7a" + displayName + " " + stateLabel));
|
||||
} else {
|
||||
String enabled = StatCollector.translateToLocal("gui.enabled");
|
||||
player.addChatMessage(new ChatComponentText("\u00A7a" + displayName + " " + enabled));
|
||||
}
|
||||
} else {
|
||||
String disabled = StatCollector.translateToLocal("gui.disabled");
|
||||
player.addChatMessage(new ChatComponentText("\u00A7c" + displayName + " " + disabled));
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -15,6 +15,7 @@ import net.minecraft.nbt.NBTTagCompound;
|
||||
import net.minecraft.util.EnumChatFormatting;
|
||||
import net.minecraft.util.StatCollector;
|
||||
import noppes.npcs.client.ClientProxy;
|
||||
import noppes.npcs.client.gui.player.GuiAuctionInterface;
|
||||
import noppes.npcs.controllers.MagicController;
|
||||
import noppes.npcs.controllers.data.Magic;
|
||||
import org.lwjgl.input.Keyboard;
|
||||
@@ -230,14 +231,14 @@ public class AttributeItemUtil {
|
||||
* Returns the item tooltip.
|
||||
*/
|
||||
@SideOnly(Side.CLIENT)
|
||||
public static List<String> getToolTip(List<String> original, NBTTagCompound compound) {
|
||||
public static List<String> getToolTip(List<String> original, NBTTagCompound compound, boolean override) {
|
||||
List<String> tooltip = new ArrayList<>(original);
|
||||
// Get the RPGCore compound and then the Attributes compound.
|
||||
NBTTagCompound rpgCore = compound.hasKey(TAG_RPGCORE) ? compound.getCompoundTag(TAG_RPGCORE) : new NBTTagCompound();
|
||||
NBTTagCompound attrTag = rpgCore.hasKey(TAG_ATTRIBUTES) ? rpgCore.getCompoundTag(TAG_ATTRIBUTES) : new NBTTagCompound();
|
||||
if (Keyboard.isKeyDown(ClientProxy.NPCButton.getKeyCode())) {
|
||||
if (Keyboard.isKeyDown(ClientProxy.NPCButton.getKeyCode()) || override) {
|
||||
List<String> newTooltips = new ArrayList<>();
|
||||
if (!tooltip.isEmpty()) {
|
||||
if (!tooltip.isEmpty() && !override) {
|
||||
newTooltips.add(tooltip.get(0));
|
||||
}
|
||||
|
||||
@@ -325,7 +326,11 @@ public class AttributeItemUtil {
|
||||
newTooltips.addAll(buildSection(reqEntries));
|
||||
}
|
||||
|
||||
tooltip = newTooltips;
|
||||
if(override){
|
||||
tooltip.addAll(newTooltips);
|
||||
} else {
|
||||
tooltip = newTooltips;
|
||||
}
|
||||
} else {
|
||||
String keyName = Keyboard.getKeyName(ClientProxy.NPCButton.getKeyCode());
|
||||
tooltip.add(EnumChatFormatting.YELLOW + "" + EnumChatFormatting.ITALIC +
|
||||
|
||||
@@ -4,6 +4,7 @@ import kamkeel.npcs.controllers.AbilityController;
|
||||
import kamkeel.npcs.controllers.data.ability.Ability;
|
||||
import kamkeel.npcs.controllers.data.ability.AbilityVariant;
|
||||
import kamkeel.npcs.controllers.data.ability.IEffectAction;
|
||||
import kamkeel.npcs.controllers.data.ability.conditions.AbilityCondition;
|
||||
import noppes.npcs.LogWriter;
|
||||
import noppes.npcs.controllers.AnimationController;
|
||||
import noppes.npcs.controllers.data.Animation;
|
||||
@@ -207,4 +208,36 @@ public class Register<T> {
|
||||
return new Register.EffectActions(namespace);
|
||||
}
|
||||
}
|
||||
|
||||
public static class Conditions extends Register<AbilityCondition> {
|
||||
|
||||
private Conditions(String namespace) {
|
||||
super("condition", namespace);
|
||||
}
|
||||
|
||||
public AbilityCondition register(String name, Supplier<AbilityCondition> factory) {
|
||||
entries.put(registryKey + "." + namespace + "." + name, factory);
|
||||
return factory.get();
|
||||
}
|
||||
|
||||
public void register() {
|
||||
for (Map.Entry<String, Supplier<AbilityCondition>> entry : entries.entrySet()) {
|
||||
AbilityController.Instance.registerCondition(entry.getValue());
|
||||
}
|
||||
}
|
||||
|
||||
public static Register.Conditions create(String namespace, String displayName) {
|
||||
if (!REGISTERED_NAMESPACES.containsKey("condition"))
|
||||
REGISTERED_NAMESPACES.put("condition", new ArrayList<>());
|
||||
|
||||
if (REGISTERED_NAMESPACES.get("condition").contains(namespace)) {
|
||||
LogWriter.error("REGISTER CONDITIONS: Namespace " + namespace + " already registered!");
|
||||
}
|
||||
|
||||
REGISTERED_NAMESPACES.get("condition").add(namespace);
|
||||
NAMESPACE_DISPLAY_NAMES.put(namespace, displayName);
|
||||
|
||||
return new Register.Conditions(namespace);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -14,6 +14,7 @@ import noppes.npcs.controllers.AnimationController;
|
||||
import noppes.npcs.controllers.data.Animation;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashMap;
|
||||
import java.util.Iterator;
|
||||
import java.util.LinkedHashMap;
|
||||
import java.util.LinkedHashSet;
|
||||
@@ -44,10 +45,25 @@ public abstract class AbstractDataAbilities {
|
||||
protected Ability currentAbility;
|
||||
|
||||
/**
|
||||
* World time when cooldown ends
|
||||
* World time when global cooldown ends
|
||||
*/
|
||||
protected long cooldownEndTime = 0;
|
||||
|
||||
/**
|
||||
* Duration of the current global cooldown in ticks (for progress calculation)
|
||||
*/
|
||||
protected int globalCooldownDuration = 0;
|
||||
|
||||
/**
|
||||
* Per-ability cooldown end times. Key = ability key, Value = world time when cooldown ends.
|
||||
*/
|
||||
protected HashMap<String, Long> perAbilityCooldownEndTimes = new HashMap<>();
|
||||
|
||||
/**
|
||||
* Per-ability cooldown durations in ticks (for progress calculation).
|
||||
*/
|
||||
protected HashMap<String, Integer> perAbilityCooldownDurations = new HashMap<>();
|
||||
|
||||
/**
|
||||
* Rotation lock state
|
||||
*/
|
||||
@@ -526,6 +542,106 @@ public abstract class AbstractDataAbilities {
|
||||
cooldownEndTime = endTime;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the global cooldown end time.
|
||||
*/
|
||||
public long getCooldownEndTime() {
|
||||
return cooldownEndTime;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the global cooldown duration value.
|
||||
*/
|
||||
public int getGlobalCooldownDurationValue() {
|
||||
return globalCooldownDuration;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the per-ability cooldown end times map.
|
||||
*/
|
||||
public HashMap<String, Long> getPerAbilityCooldownEndTimes() {
|
||||
return perAbilityCooldownEndTimes;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the per-ability cooldown durations map.
|
||||
*/
|
||||
public HashMap<String, Integer> getPerAbilityCooldownDurations() {
|
||||
return perAbilityCooldownDurations;
|
||||
}
|
||||
|
||||
/**
|
||||
* Apply cooldown sync data from server. Called on client side.
|
||||
*/
|
||||
public void applyCooldownSync(long globalEndTime, int globalDuration,
|
||||
HashMap<String, Long> perEndTimes,
|
||||
HashMap<String, Integer> perDurations) {
|
||||
this.cooldownEndTime = globalEndTime;
|
||||
this.globalCooldownDuration = globalDuration;
|
||||
this.perAbilityCooldownEndTimes = perEndTimes;
|
||||
this.perAbilityCooldownDurations = perDurations;
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
// PER-ABILITY COOLDOWN MANAGEMENT
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
|
||||
/**
|
||||
* Check if a specific ability is on its per-ability cooldown.
|
||||
*/
|
||||
public boolean isOnPerAbilityCooldown(String key) {
|
||||
Long endTime = perAbilityCooldownEndTimes.get(key);
|
||||
return endTime != null && getWorldTime() < endTime;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set a per-ability cooldown.
|
||||
*/
|
||||
public void setPerAbilityCooldown(String key, long endTime, int duration) {
|
||||
perAbilityCooldownEndTimes.put(key, endTime);
|
||||
perAbilityCooldownDurations.put(key, duration);
|
||||
}
|
||||
|
||||
/**
|
||||
* Reset a specific per-ability cooldown.
|
||||
*/
|
||||
public void resetPerAbilityCooldown(String key) {
|
||||
perAbilityCooldownEndTimes.remove(key);
|
||||
perAbilityCooldownDurations.remove(key);
|
||||
}
|
||||
|
||||
/**
|
||||
* Reset all per-ability cooldowns.
|
||||
*/
|
||||
public void resetAllPerAbilityCooldowns() {
|
||||
perAbilityCooldownEndTimes.clear();
|
||||
perAbilityCooldownDurations.clear();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get global cooldown progress for HUD rendering.
|
||||
* @return 1.0 when cooldown just started (fully covered), 0.0 when done
|
||||
*/
|
||||
public float getGlobalCooldownProgress() {
|
||||
if (globalCooldownDuration <= 0) return 0f;
|
||||
long remaining = cooldownEndTime - getWorldTime();
|
||||
if (remaining <= 0) return 0f;
|
||||
return Math.min(1f, (float) remaining / globalCooldownDuration);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get per-ability cooldown progress for HUD rendering.
|
||||
* @return 1.0 when cooldown just started (fully covered), 0.0 when done
|
||||
*/
|
||||
public float getPerAbilityCooldownProgress(String key) {
|
||||
Long endTime = perAbilityCooldownEndTimes.get(key);
|
||||
Integer duration = perAbilityCooldownDurations.get(key);
|
||||
if (endTime == null || duration == null || duration <= 0) return 0f;
|
||||
long remaining = endTime - getWorldTime();
|
||||
if (remaining <= 0) return 0f;
|
||||
return Math.min(1f, (float) remaining / duration);
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
// POSITION LOCKING
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
@@ -918,6 +1034,62 @@ public abstract class AbstractDataAbilities {
|
||||
protected void onInterruptComplete() {
|
||||
}
|
||||
|
||||
/**
|
||||
* Cancel the currently executing ability (voluntary player action).
|
||||
* Unlike interrupt, this always goes directly to IDLE (never DAZED),
|
||||
* immediately rolls cooldown, and clears state.
|
||||
* Also handles cancellation during chain delay (between chain entries).
|
||||
*/
|
||||
public void cancelCurrentAbility() {
|
||||
boolean hasExecutingAbility = currentAbility != null && currentAbility.isExecuting();
|
||||
boolean isInChainDelay = currentChain != null && chainDelayRemaining > 0;
|
||||
|
||||
if (!hasExecutingAbility && !isInChainDelay) return;
|
||||
|
||||
if (hasExecutingAbility) {
|
||||
AbilityPhase phase = currentAbility.getPhase();
|
||||
// Cannot cancel during DAZED (already interrupted)
|
||||
if (phase == AbilityPhase.DAZED) return;
|
||||
// Only allow cancel during active phases
|
||||
if (phase != AbilityPhase.WINDUP && phase != AbilityPhase.ACTIVE
|
||||
&& phase != AbilityPhase.BURST_DELAY) return;
|
||||
|
||||
// Remove telegraph
|
||||
removeTelegraph(currentAbility);
|
||||
|
||||
// Fire extender complete hook (cancelled = interrupted)
|
||||
AbilityController.Instance.fireOnAbilityComplete(currentAbility, getEntity(), getTarget(), true);
|
||||
|
||||
// Fire interrupt event (source=null, damage=0 for voluntary cancel)
|
||||
fireInterruptEvent(currentAbility, getTarget(), null, 0);
|
||||
|
||||
// Cancel the ability (cleanup + go directly to IDLE, no DAZED)
|
||||
currentAbility.onInterrupt(getEntity(), null, 0);
|
||||
currentAbility.cancel();
|
||||
|
||||
// Release locks and stop animation
|
||||
stopAbilityAnimation();
|
||||
releaseRotationControl();
|
||||
releaseLockedPosition();
|
||||
}
|
||||
|
||||
// Roll cooldown
|
||||
if (currentChain != null) {
|
||||
rollChainCooldown(currentChain);
|
||||
currentChain = null;
|
||||
chainEntryIndex = -1;
|
||||
chainDelayRemaining = -1;
|
||||
} else if (currentAbility != null) {
|
||||
rollCooldown(currentAbility);
|
||||
}
|
||||
|
||||
// Interrupt all concurrent slots
|
||||
interruptConcurrentSlots();
|
||||
|
||||
// Clear state via the normal completion path
|
||||
onAbilityComplete();
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
// CHAINED ABILITY EXECUTION
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
|
||||
@@ -209,21 +209,31 @@ public class AnimationMixinFunctions {
|
||||
return null;
|
||||
}
|
||||
|
||||
public static void playerFullModel_head(Entity p_78088_1_, CallbackInfo callbackInfo) {
|
||||
if (!DBCAddon.IsAvailable() && ClientCacheHandler.playerAnimations.containsKey(p_78088_1_.getUniqueID())) {
|
||||
AnimationData animData = ClientCacheHandler.playerAnimations.get(p_78088_1_.getUniqueID());
|
||||
if (animData != null && animData.isActive()) {
|
||||
Frame frame = (Frame) animData.animation.currentFrame();
|
||||
if (frame.frameParts.containsKey(EnumAnimationPart.FULL_MODEL)) {
|
||||
FramePart part = frame.frameParts.get(EnumAnimationPart.FULL_MODEL);
|
||||
part.interpolateOffset();
|
||||
part.interpolateAngles();
|
||||
float pi = 180 / (float) Math.PI;
|
||||
GL11.glTranslatef(part.prevPivots[0], -part.prevPivots[1], part.prevPivots[2]);
|
||||
GL11.glRotatef(part.prevRotations[0] * pi, 1, 0, 0);
|
||||
GL11.glRotatef(part.prevRotations[1] * pi, 0, 1, 0);
|
||||
GL11.glRotatef(part.prevRotations[2] * pi, 0, 0, 1);
|
||||
}
|
||||
public static void playerFullModel_head(Entity entity, CallbackInfo callbackInfo) {
|
||||
if (!ClientCacheHandler.playerAnimations.containsKey(entity.getUniqueID())) return;
|
||||
|
||||
AnimationData animData = ClientCacheHandler.playerAnimations.get(entity.getUniqueID());
|
||||
if (animData == null || !animData.isActive()) return;
|
||||
|
||||
// Snap body rotation to head so animations face the look direction
|
||||
if (entity instanceof EntityLivingBase) {
|
||||
EntityLivingBase living = (EntityLivingBase) entity;
|
||||
living.renderYawOffset = living.rotationYaw;
|
||||
living.prevRenderYawOffset = living.prevRotationYaw;
|
||||
}
|
||||
|
||||
// FULL_MODEL GL transforms (non-DBC only)
|
||||
if (!DBCAddon.IsAvailable()) {
|
||||
Frame frame = (Frame) animData.animation.currentFrame();
|
||||
if (frame.frameParts.containsKey(EnumAnimationPart.FULL_MODEL)) {
|
||||
FramePart part = frame.frameParts.get(EnumAnimationPart.FULL_MODEL);
|
||||
part.interpolateOffset();
|
||||
part.interpolateAngles();
|
||||
float pi = 180 / (float) Math.PI;
|
||||
GL11.glTranslatef(part.prevPivots[0], -part.prevPivots[1], part.prevPivots[2]);
|
||||
GL11.glRotatef(part.prevRotations[0] * pi, 1, 0, 0);
|
||||
GL11.glRotatef(part.prevRotations[1] * pi, 0, 1, 0);
|
||||
GL11.glRotatef(part.prevRotations[2] * pi, 0, 0, 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -28,14 +28,15 @@ import kamkeel.npcs.controllers.SyncController;
|
||||
import kamkeel.npcs.controllers.TelegraphController;
|
||||
import kamkeel.npcs.controllers.data.profile.CNPCData;
|
||||
import kamkeel.npcs.developer.Developer;
|
||||
import kamkeel.npcs.entity.EntityAbilityBarrier;
|
||||
import kamkeel.npcs.entity.EntityAbilityBeam;
|
||||
import kamkeel.npcs.entity.EntityAbilityDisc;
|
||||
import kamkeel.npcs.entity.EntityAbilityLaser;
|
||||
import kamkeel.npcs.entity.EntityAbilityOrb;
|
||||
import kamkeel.npcs.entity.EntityAbilityPanel;
|
||||
import kamkeel.npcs.entity.EntityAbilitySweeper;
|
||||
import kamkeel.npcs.entity.EntityAbilityZone;
|
||||
import kamkeel.npcs.entity.EntityEnergyDome;
|
||||
import kamkeel.npcs.entity.EntityEnergyPanel;
|
||||
import kamkeel.npcs.entity.EntityAbilityDome;
|
||||
import kamkeel.npcs.entity.EntityEnergySlicer;
|
||||
import kamkeel.npcs.network.PacketHandler;
|
||||
import kamkeel.npcs.util.BukkitUtil;
|
||||
@@ -297,8 +298,8 @@ public class CustomNpcs {
|
||||
registerNewEntity(EntityAbilityBeam.class, "abilitybeam", 64, 3, true);
|
||||
registerNewEntity(EntityAbilitySweeper.class, "abilitysweeper", 64, 3, true);
|
||||
registerNewEntity(EntityAbilityZone.class, "abilityzone", 64, 3, true);
|
||||
registerNewEntity(EntityEnergyDome.class, "energydome", 64, 3, true);
|
||||
registerNewEntity(EntityEnergyPanel.class, "energypanel", 64, 3, true);
|
||||
registerNewEntity(EntityAbilityDome.class, "energydome", 64, 3, true);
|
||||
registerNewEntity(EntityAbilityPanel.class, "energypanel", 64, 3, true);
|
||||
registerNewEntity(EntityEnergySlicer.class, "energyslicer", 64, 3, true);
|
||||
|
||||
new RecipeController();
|
||||
@@ -335,6 +336,14 @@ public class CustomNpcs {
|
||||
@EventHandler
|
||||
public void loadComplete(FMLLoadCompleteEvent ev) {
|
||||
proxy.buildPackageIndex();
|
||||
|
||||
// Load built-in animations on the client so they're available for ability preview.
|
||||
// On dedicated servers, AnimationController.load() only runs on the server JVM,
|
||||
// leaving the client without built-in animation data. In singleplayer, load()
|
||||
// runs later during server start and reloads everything, so this is harmless.
|
||||
if (FMLCommonHandler.instance().getSide().isClient()) {
|
||||
AnimationController.Instance.loadClientBuiltIns();
|
||||
}
|
||||
}
|
||||
|
||||
@EventHandler
|
||||
@@ -422,6 +431,7 @@ public class CustomNpcs {
|
||||
}
|
||||
|
||||
kamkeel.npcs.entity.EntityEnergyProjectile.clearAllProjectiles();
|
||||
EntityAbilityBarrier.clearAllBarriers();
|
||||
|
||||
if (FMLCommonHandler.instance().getSide().isClient())
|
||||
clientJaninoCompiler = null;
|
||||
|
||||
@@ -222,13 +222,18 @@ public class DataAbilities extends AbstractDataAbilities {
|
||||
|
||||
@Override
|
||||
protected void rollCooldown(Ability ability) {
|
||||
// Always roll NPC global cooldown (pacing timer)
|
||||
int baseCooldown = minCooldown;
|
||||
if (maxCooldown > minCooldown) {
|
||||
baseCooldown = minCooldown + random.nextInt(maxCooldown - minCooldown + 1);
|
||||
}
|
||||
cooldownEndTime = npc.worldObj.getTotalWorldTime() + baseCooldown;
|
||||
// Add ability-specific cooldown offset
|
||||
cooldownEndTime += ability.getCooldownTicks();
|
||||
cooldownEndTime = npc.worldObj.getTotalWorldTime() + baseCooldown + ability.getCooldownTicks();
|
||||
|
||||
// Additionally set per-ability cooldown if enabled
|
||||
if (ability.isPerAbilityCooldown() && ability.getCooldownTicks() > 0) {
|
||||
long endTime = npc.worldObj.getTotalWorldTime() + ability.getCooldownTicks();
|
||||
setPerAbilityCooldown(ability.getName(), endTime, ability.getCooldownTicks());
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
@@ -482,6 +487,14 @@ public class DataAbilities extends AbstractDataAbilities {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Per-ability cooldown filter: ability may have its own independent cooldown
|
||||
if (!action.isChain()) {
|
||||
Ability ab = (Ability) action;
|
||||
if (ab.isPerAbilityCooldown() && isOnPerAbilityCooldown(ab.getName())) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
@@ -726,6 +739,7 @@ public class DataAbilities extends AbstractDataAbilities {
|
||||
stopCurrentAbility();
|
||||
clearActiveToggles();
|
||||
interruptConcurrentSlots();
|
||||
resetAllPerAbilityCooldowns();
|
||||
|
||||
// Roll cooldown so NPC doesn't immediately attack after reset
|
||||
rollCooldownOnReset();
|
||||
|
||||
@@ -4,6 +4,8 @@ import cpw.mods.fml.common.FMLCommonHandler;
|
||||
import cpw.mods.fml.common.eventhandler.SubscribeEvent;
|
||||
import cpw.mods.fml.relauncher.Side;
|
||||
import kamkeel.npcs.controllers.SyncController;
|
||||
import kamkeel.npcs.entity.EntityAbilityBarrier;
|
||||
import kamkeel.npcs.entity.EntityAbilityDome;
|
||||
import kamkeel.npcs.network.PacketHandler;
|
||||
import kamkeel.npcs.network.enums.EnumSoundOperation;
|
||||
import kamkeel.npcs.network.enums.EnumSyncAction;
|
||||
@@ -151,6 +153,52 @@ public class ServerEventsHandler {
|
||||
}
|
||||
}
|
||||
|
||||
@SubscribeEvent
|
||||
public void barrierAbsorbDamage(LivingAttackEvent event) {
|
||||
if (event.entityLiving == null || event.entityLiving.worldObj == null || event.entityLiving.worldObj.isRemote)
|
||||
return;
|
||||
|
||||
EntityAbilityBarrier barrier = EntityAbilityBarrier.getAbsorbingBarrier(event.entityLiving);
|
||||
if (barrier != null) {
|
||||
// Redirect the caster's damage to their barrier
|
||||
barrier.absorbDamage(event.ammount);
|
||||
event.setCanceled(true);
|
||||
}
|
||||
}
|
||||
|
||||
@SubscribeEvent
|
||||
public void domeItemBlacklist(PlayerInteractEvent event) {
|
||||
if (event.action == PlayerInteractEvent.Action.LEFT_CLICK_BLOCK) return;
|
||||
EntityPlayer player = event.entityPlayer;
|
||||
if (player == null || player.worldObj == null || player.worldObj.isRemote) return;
|
||||
|
||||
ItemStack held = player.getHeldItem();
|
||||
if (held == null) return;
|
||||
|
||||
String itemId = net.minecraft.item.Item.itemRegistry.getNameForObject(held.getItem());
|
||||
if (itemId == null) return;
|
||||
|
||||
String[] blacklist = noppes.npcs.config.ConfigEnergy.DomeItemBlacklist;
|
||||
if (blacklist == null) return;
|
||||
|
||||
boolean blacklisted = false;
|
||||
for (String banned : blacklist) {
|
||||
if (banned.equals(itemId)) {
|
||||
blacklisted = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!blacklisted) return;
|
||||
|
||||
List<EntityAbilityBarrier> barriers = EntityAbilityBarrier.getActiveBarriers(player.worldObj);
|
||||
for (EntityAbilityBarrier barrier : barriers) {
|
||||
if (barrier instanceof EntityAbilityDome && barrier.isEntityInside(player)) {
|
||||
event.setCanceled(true);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@SubscribeEvent
|
||||
public void partyDamagedEvent(LivingAttackEvent event) {
|
||||
if (!(event.source != null && event.source.getEntity() instanceof EntityPlayer) || !(event.entityLiving instanceof EntityPlayer) || FMLCommonHandler.instance().getEffectiveSide().isClient())
|
||||
|
||||
@@ -25,6 +25,7 @@ import noppes.npcs.client.gui.hud.ClientHudManager;
|
||||
import noppes.npcs.client.gui.hud.CompassHudComponent;
|
||||
import noppes.npcs.client.gui.hud.EnumHudComponent;
|
||||
import noppes.npcs.client.gui.hud.QuestTrackingComponent;
|
||||
import noppes.npcs.client.gui.hud.ability.AbilityHotbarComponent;
|
||||
import noppes.npcs.client.gui.player.AuctionTooltipHandler;
|
||||
import noppes.npcs.client.renderer.MarkRenderer;
|
||||
import noppes.npcs.client.renderer.RenderCNPCPlayer;
|
||||
@@ -98,6 +99,24 @@ public class ClientEventHandler {
|
||||
return;
|
||||
}
|
||||
|
||||
// Ability Hotbar: Hold HUD key + scroll wheel to cycle
|
||||
if (event.dwheel != 0 && ClientProxy.AbilityHudKey != null) {
|
||||
int hudKeyCode = ClientProxy.AbilityHudKey.getKeyCode();
|
||||
if (hudKeyCode != 0 && org.lwjgl.input.Keyboard.isKeyDown(hudKeyCode)) {
|
||||
AbilityHotbarComponent comp = (AbilityHotbarComponent) ClientHudManager.getInstance()
|
||||
.getHudComponents().get(EnumHudComponent.AbilityHotbar);
|
||||
if (comp != null && comp.hasAnyAbilities()) {
|
||||
if (event.dwheel > 0) {
|
||||
comp.onCyclePrev();
|
||||
} else {
|
||||
comp.onCycleNext();
|
||||
}
|
||||
event.setCanceled(true);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
ArrayList<Integer> removeList = new ArrayList<>();
|
||||
for (Map.Entry<Integer, Long> entry : disabledButtonTimes.entrySet()) {
|
||||
if (entry.getValue() > 0) {
|
||||
@@ -125,6 +144,7 @@ public class ClientEventHandler {
|
||||
if (ClientHudManager.getInstance().getHudComponents().isEmpty()) {
|
||||
ClientHudManager.getInstance().registerHud(EnumHudComponent.QuestTracker, new QuestTrackingComponent(Minecraft.getMinecraft()));
|
||||
ClientHudManager.getInstance().registerHud(EnumHudComponent.QuestCompass, new CompassHudComponent(Minecraft.getMinecraft()));
|
||||
ClientHudManager.getInstance().registerHud(EnumHudComponent.AbilityHotbar, new AbilityHotbarComponent(Minecraft.getMinecraft()));
|
||||
}
|
||||
|
||||
ClientHudManager.getInstance().renderAllHUDs(event.partialTicks);
|
||||
|
||||
@@ -12,8 +12,8 @@ import kamkeel.npcs.client.renderer.RenderAbilityLaser;
|
||||
import kamkeel.npcs.client.renderer.RenderAbilityOrb;
|
||||
import kamkeel.npcs.client.renderer.RenderAbilitySweeper;
|
||||
import kamkeel.npcs.client.renderer.RenderAbilityZone;
|
||||
import kamkeel.npcs.client.renderer.RenderEnergyDome;
|
||||
import kamkeel.npcs.client.renderer.RenderEnergyPanel;
|
||||
import kamkeel.npcs.client.renderer.RenderAbilityDome;
|
||||
import kamkeel.npcs.client.renderer.RenderAbilityPanel;
|
||||
import kamkeel.npcs.client.renderer.RenderEnergySlicer;
|
||||
import kamkeel.npcs.client.renderer.TelegraphRenderer;
|
||||
import kamkeel.npcs.client.renderer.lightning.LightningHandler;
|
||||
@@ -24,8 +24,8 @@ import kamkeel.npcs.entity.EntityAbilityLaser;
|
||||
import kamkeel.npcs.entity.EntityAbilityOrb;
|
||||
import kamkeel.npcs.entity.EntityAbilitySweeper;
|
||||
import kamkeel.npcs.entity.EntityAbilityZone;
|
||||
import kamkeel.npcs.entity.EntityEnergyDome;
|
||||
import kamkeel.npcs.entity.EntityEnergyPanel;
|
||||
import kamkeel.npcs.entity.EntityAbilityDome;
|
||||
import kamkeel.npcs.entity.EntityAbilityPanel;
|
||||
import kamkeel.npcs.entity.EntityEnergySlicer;
|
||||
import net.minecraft.client.Minecraft;
|
||||
import net.minecraft.client.gui.GuiScreen;
|
||||
@@ -259,6 +259,7 @@ import java.util.Random;
|
||||
public class ClientProxy extends CommonProxy {
|
||||
public static KeyBinding NPCButton;
|
||||
public static KeyBinding SpecialKey;
|
||||
public static KeyBinding AbilityHudKey;
|
||||
public static final Random RAND = new Random();
|
||||
public static FontContainer Font;
|
||||
|
||||
@@ -279,8 +280,8 @@ public class ClientProxy extends CommonProxy {
|
||||
RenderingRegistry.registerEntityRenderingHandler(EntityAbilityBeam.class, new RenderAbilityBeam());
|
||||
RenderingRegistry.registerEntityRenderingHandler(EntityAbilitySweeper.class, new RenderAbilitySweeper());
|
||||
RenderingRegistry.registerEntityRenderingHandler(EntityAbilityZone.class, new RenderAbilityZone());
|
||||
RenderingRegistry.registerEntityRenderingHandler(EntityEnergyDome.class, new RenderEnergyDome());
|
||||
RenderingRegistry.registerEntityRenderingHandler(EntityEnergyPanel.class, new RenderEnergyPanel());
|
||||
RenderingRegistry.registerEntityRenderingHandler(EntityAbilityDome.class, new RenderAbilityDome());
|
||||
RenderingRegistry.registerEntityRenderingHandler(EntityAbilityPanel.class, new RenderAbilityPanel());
|
||||
RenderingRegistry.registerEntityRenderingHandler(EntityEnergySlicer.class, new RenderEnergySlicer());
|
||||
|
||||
RenderingRegistry.registerEntityRenderingHandler(EntityCustomNpc.class, new RenderCustomNpc());
|
||||
@@ -334,11 +335,14 @@ public class ClientProxy extends CommonProxy {
|
||||
Minecraft mc = Minecraft.getMinecraft();
|
||||
|
||||
NPCButton = new KeyBinding("NPC Inventory", Keyboard.KEY_N, "key.categories.customnpc");
|
||||
SpecialKey = new KeyBinding("key.customnpcs.special", Keyboard.KEY_B, "key.categories.customnpc");
|
||||
SpecialKey = new KeyBinding("key.customnpcs.special", Keyboard.KEY_GRAVE, "key.categories.customnpc");
|
||||
|
||||
ClientRegistry.registerKeyBinding(NPCButton);
|
||||
ClientRegistry.registerKeyBinding(SpecialKey);
|
||||
|
||||
AbilityHudKey = new KeyBinding("key.customnpcs.abilityHudKey", Keyboard.KEY_LMENU, "key.categories.customnpc");
|
||||
ClientRegistry.registerKeyBinding(AbilityHudKey);
|
||||
|
||||
new PresetController(CustomNpcs.Dir);
|
||||
|
||||
if (ConfigMain.EnableUpdateChecker) {
|
||||
|
||||
@@ -5,10 +5,12 @@ import cpw.mods.fml.common.eventhandler.SubscribeEvent;
|
||||
import cpw.mods.fml.common.gameevent.InputEvent;
|
||||
import cpw.mods.fml.common.gameevent.TickEvent;
|
||||
import cpw.mods.fml.common.gameevent.TickEvent.Phase;
|
||||
import cpw.mods.fml.relauncher.Side;
|
||||
import kamkeel.npcs.client.renderer.lightning.LightningBolt;
|
||||
import kamkeel.npcs.controllers.AbilityController;
|
||||
import kamkeel.npcs.controllers.data.telegraph.TelegraphManager;
|
||||
import kamkeel.npcs.network.PacketClient;
|
||||
import kamkeel.npcs.network.packets.data.RequestProperSpawnData;
|
||||
import kamkeel.npcs.network.packets.player.CheckPlayerValue;
|
||||
import kamkeel.npcs.network.packets.player.InputDevicePacket;
|
||||
import kamkeel.npcs.network.packets.player.ScreenSizePacket;
|
||||
@@ -59,6 +61,7 @@ public class ClientTickHandler {
|
||||
if (mc.theWorld == null) {
|
||||
ClientCacheHandler.clearCache();
|
||||
ClientAbilityState.reset();
|
||||
RequestProperSpawnData.clear();
|
||||
}
|
||||
this.prevWorld = mc.theWorld;
|
||||
}
|
||||
@@ -154,6 +157,16 @@ public class ClientTickHandler {
|
||||
renderCNPCPlayer.itemRenderer.updateEquippedItem();
|
||||
}
|
||||
}
|
||||
|
||||
// Tick telegraph manager AFTER entity updates so telegraph positions
|
||||
// match entity interpolation (Phase.END runs after world tick)
|
||||
if (TelegraphManager.ClientInstance != null) {
|
||||
TelegraphManager.ClientInstance.tick(mc.theWorld);
|
||||
}
|
||||
|
||||
// Update lightning bolts for ability effects
|
||||
LightningBolt.updateAll();
|
||||
|
||||
return;
|
||||
}
|
||||
if (mc.thePlayer != null && mc.thePlayer.openContainer instanceof ContainerPlayer) {
|
||||
@@ -179,13 +192,6 @@ public class ClientTickHandler {
|
||||
MusicController.Instance.onUpdate();
|
||||
ScriptSoundController.Instance.onUpdate();
|
||||
|
||||
// Tick telegraph manager for ability warnings
|
||||
if (TelegraphManager.ClientInstance != null) {
|
||||
TelegraphManager.ClientInstance.tick(mc.theWorld);
|
||||
}
|
||||
|
||||
// Update lightning bolts for ability effects
|
||||
LightningBolt.updateAll();
|
||||
if (Minecraft.getMinecraft().thePlayer != null && (prevWidth != mc.displayWidth || prevHeight != mc.displayHeight)) {
|
||||
prevWidth = mc.displayWidth;
|
||||
prevHeight = mc.displayHeight;
|
||||
@@ -196,10 +202,46 @@ public class ClientTickHandler {
|
||||
return;
|
||||
|
||||
if (mc.theWorld.getTotalWorldTime() % 20 == 0) { // Update every second
|
||||
if (RequestProperSpawnData.canDoBatchUpdate())
|
||||
RequestProperSpawnData.handleBacklog();
|
||||
updateCompassMarks();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Enforce ability lock motion constraints right before entity update.
|
||||
* The Phase.END zeroing in onClientTick can be overwritten by other mods'
|
||||
* ClientTickEvent Phase.START handlers (e.g. flight mods re-applying gravity).
|
||||
* PlayerTickEvent fires after all ClientTickEvent handlers but before
|
||||
* player.onUpdate(), making this the definitive point to enforce motion locks.
|
||||
*/
|
||||
@SubscribeEvent(priority = EventPriority.LOWEST)
|
||||
public void onPlayerTick(TickEvent.PlayerTickEvent event) {
|
||||
if (event.phase != Phase.START || event.side != Side.CLIENT)
|
||||
return;
|
||||
|
||||
Minecraft mc = Minecraft.getMinecraft();
|
||||
if (mc.thePlayer == null || mc.currentScreen != null)
|
||||
return;
|
||||
|
||||
if (!ClientAbilityState.shouldSuppressMovementInput())
|
||||
return;
|
||||
|
||||
if (!ClientAbilityState.hasAbilityMovement) {
|
||||
mc.thePlayer.motionX = 0;
|
||||
mc.thePlayer.motionZ = 0;
|
||||
}
|
||||
|
||||
if ((ClientAbilityState.movementLocked || ClientAbilityState.positionLocked)
|
||||
&& !ClientAbilityState.hasAbilityMovement) {
|
||||
if (ClientAbilityState.wasFlyingAtLock) {
|
||||
mc.thePlayer.motionY = 0;
|
||||
} else {
|
||||
mc.thePlayer.motionY = Math.min(mc.thePlayer.motionY, 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@SubscribeEvent
|
||||
public void onMouse(InputEvent.MouseInputEvent event) {
|
||||
if (Mouse.getEventButton() == -1 && Mouse.getEventDWheel() == 0)
|
||||
|
||||
@@ -127,7 +127,7 @@ public class SubGuiEffectGeneral extends SubGuiInterface implements ITextfieldLi
|
||||
int iconWidth = effect.getWidth();
|
||||
int iconHeight = effect.getHeight();
|
||||
int width = data.getTotalWidth();
|
||||
int height = data.getTotalWidth();
|
||||
int height = data.getTotalHeight();
|
||||
|
||||
|
||||
func_152125_a(x, y, iconX, iconY, iconWidth, iconHeight, iconRenderSize, iconRenderSize, width, height);
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
package noppes.npcs.client.gui.advanced;
|
||||
|
||||
import kamkeel.npcs.controllers.data.ability.Ability;
|
||||
import kamkeel.npcs.controllers.data.ability.Condition;
|
||||
import kamkeel.npcs.controllers.data.ability.conditions.AbilityCondition;
|
||||
import kamkeel.npcs.controllers.data.ability.gui.AbilityFieldBuilder;
|
||||
import net.minecraft.client.gui.GuiButton;
|
||||
import net.minecraft.nbt.NBTTagCompound;
|
||||
@@ -20,6 +20,8 @@ import noppes.npcs.client.gui.util.SubGuiInterface;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
import static kamkeel.npcs.controllers.data.ability.conditions.AbilityCondition.MAX_CONDITIONS;
|
||||
|
||||
public class SubGuiAbilityConfig extends SubGuiInterface implements ITextfieldListener, ISubGuiListener {
|
||||
|
||||
private static final int DECLARATIVE_ID_START = 1000;
|
||||
@@ -42,6 +44,12 @@ public class SubGuiAbilityConfig extends SubGuiInterface implements ITextfieldLi
|
||||
private static final int L_LABEL_X = 5;
|
||||
private static final int ROW_H = 24;
|
||||
|
||||
// Condition buttons
|
||||
private static final int COND_BASE = 50;
|
||||
private static final int COND_STRIDE = 10;
|
||||
private static final int COND_END = COND_BASE + MAX_CONDITIONS * COND_STRIDE; // 50 + N*10
|
||||
private static final int BTN_ADD_COND = COND_END;
|
||||
|
||||
private final Ability ability;
|
||||
private final IAbilityConfigCallback callback;
|
||||
private int activeTab = TAB_GENERAL;
|
||||
@@ -49,7 +57,7 @@ public class SubGuiAbilityConfig extends SubGuiInterface implements ITextfieldLi
|
||||
private List<FieldDef> fieldDefs;
|
||||
private List<String> customTabNames;
|
||||
|
||||
private List<Condition> conditions;
|
||||
private List<AbilityCondition> conditions;
|
||||
private int editingConditionIndex = -1;
|
||||
|
||||
private AbilityFieldBuilder builder;
|
||||
@@ -234,46 +242,29 @@ public class SubGuiAbilityConfig extends SubGuiInterface implements ITextfieldLi
|
||||
sw.addLabel(new GuiNpcLabel(labelCounter, "ability.conditions", L_LABEL_X, y + 2, 0xFFFF55));
|
||||
y += 15;
|
||||
|
||||
for (int i = 0; i < conditions.size() && i < 3; i++) {
|
||||
Condition cond = conditions.get(i);
|
||||
for (int i = 0; i < conditions.size() && i < MAX_CONDITIONS; i++) {
|
||||
AbilityCondition cond = conditions.get(i);
|
||||
String condName = getConditionDisplayName(cond);
|
||||
sw.addButton(new GuiNpcButton(50 + i * 10, L_LABEL_X, y, 140, 20, condName));
|
||||
sw.addButton(new GuiNpcButton(51 + i * 10, L_LABEL_X + 145, y, 40, 20, "gui.edit"));
|
||||
sw.addButton(new GuiNpcButton(52 + i * 10, L_LABEL_X + 190, y, 20, 20, "X"));
|
||||
GuiNpcButton condBtn = new GuiNpcButton(COND_BASE + i * COND_STRIDE, L_LABEL_X, y, 140, 20, condName);
|
||||
condBtn.hoverableText = cond.getConditionSummary();
|
||||
sw.addButton(condBtn);
|
||||
sw.addButton(new GuiNpcButton(COND_BASE + i * COND_STRIDE + 1, L_LABEL_X + 145, y, 40, 20, "gui.edit"));
|
||||
sw.addButton(new GuiNpcButton(COND_BASE + i * COND_STRIDE + 2, L_LABEL_X + 190, y, 20, 20, "X"));
|
||||
y += 22;
|
||||
}
|
||||
|
||||
if (conditions.size() < 3) {
|
||||
sw.addButton(new GuiNpcButton(80, L_LABEL_X, y, 50, 20, "gui.add"));
|
||||
if (conditions.size() < MAX_CONDITIONS) {
|
||||
sw.addButton(new GuiNpcButton(BTN_ADD_COND, L_LABEL_X, y, 50, 20, "gui.add"));;
|
||||
y += ROW_H;
|
||||
}
|
||||
|
||||
return y;
|
||||
}
|
||||
|
||||
private String getConditionDisplayName(Condition cond) {
|
||||
private String getConditionDisplayName(AbilityCondition cond) {
|
||||
if (cond == null) return "None";
|
||||
String typeId = cond.getTypeId();
|
||||
switch (typeId) {
|
||||
case "hp_above":
|
||||
return StatCollector.translateToLocal("condition.hp_above") + " " + (int) (getConditionThreshold(cond) * 100) + "%";
|
||||
case "hp_below":
|
||||
return StatCollector.translateToLocal("condition.hp_below") + " " + (int) (getConditionThreshold(cond) * 100) + "%";
|
||||
case "target_hp_above":
|
||||
return StatCollector.translateToLocal("condition.target_hp_above") + " " + (int) (getConditionThreshold(cond) * 100) + "%";
|
||||
case "target_hp_below":
|
||||
return StatCollector.translateToLocal("condition.target_hp_below") + " " + (int) (getConditionThreshold(cond) * 100) + "%";
|
||||
case "hit_count":
|
||||
Condition.ConditionHitCount hc = (Condition.ConditionHitCount) cond;
|
||||
return StatCollector.translateToLocal("condition.hit_count") + ": " + hc.getRequiredHits() + "/" + hc.getWithinTicks() + "t";
|
||||
default:
|
||||
return typeId;
|
||||
}
|
||||
}
|
||||
|
||||
private float getConditionThreshold(Condition cond) {
|
||||
NBTTagCompound nbt = cond.writeNBT();
|
||||
return nbt.hasKey("threshold") ? nbt.getFloat("threshold") : 0.5f;
|
||||
String name = cond.getName();
|
||||
return StatCollector.translateToLocal(name);
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════════════
|
||||
@@ -331,9 +322,9 @@ public class SubGuiAbilityConfig extends SubGuiInterface implements ITextfieldLi
|
||||
}
|
||||
|
||||
private boolean handleConditionButton(int id) {
|
||||
if (id >= 50 && id < 80) {
|
||||
int condIndex = (id - 50) / 10;
|
||||
int action = (id - 50) % 10;
|
||||
if (id >= COND_BASE && id < COND_END) {
|
||||
int condIndex = (id - COND_BASE) / COND_STRIDE;
|
||||
int action = (id - COND_BASE) % COND_STRIDE;
|
||||
if (action == 0 || action == 1) {
|
||||
if (condIndex < conditions.size()) {
|
||||
editingConditionIndex = condIndex;
|
||||
@@ -347,8 +338,8 @@ public class SubGuiAbilityConfig extends SubGuiInterface implements ITextfieldLi
|
||||
}
|
||||
return true;
|
||||
}
|
||||
if (id == 80) {
|
||||
if (conditions.size() < 3) {
|
||||
if (id == BTN_ADD_COND) {
|
||||
if (conditions.size() < MAX_CONDITIONS) {
|
||||
editingConditionIndex = conditions.size();
|
||||
setSubGui(new SubGuiConditionEdit(null));
|
||||
}
|
||||
@@ -382,7 +373,7 @@ public class SubGuiAbilityConfig extends SubGuiInterface implements ITextfieldLi
|
||||
|
||||
if (subgui instanceof SubGuiConditionEdit) {
|
||||
SubGuiConditionEdit condEdit = (SubGuiConditionEdit) subgui;
|
||||
Condition result = condEdit.getResult();
|
||||
AbilityCondition result = condEdit.getResult();
|
||||
if (result != null && editingConditionIndex >= 0) {
|
||||
if (editingConditionIndex < conditions.size()) {
|
||||
conditions.set(editingConditionIndex, result);
|
||||
@@ -409,7 +400,7 @@ public class SubGuiAbilityConfig extends SubGuiInterface implements ITextfieldLi
|
||||
|
||||
protected void applyToAbility() {
|
||||
ability.getConditions().clear();
|
||||
for (Condition c : conditions) ability.addCondition(c);
|
||||
for (AbilityCondition c : conditions) ability.addCondition(c);
|
||||
}
|
||||
|
||||
public void loadAbility(Ability loadedAbility) {
|
||||
|
||||
@@ -6,13 +6,13 @@ import kamkeel.npcs.controllers.data.ability.AbilityAction;
|
||||
import kamkeel.npcs.controllers.data.ability.AbilityVariant;
|
||||
import kamkeel.npcs.controllers.data.ability.ChainedAbility;
|
||||
import kamkeel.npcs.controllers.data.ability.ChainedAbilityEntry;
|
||||
import kamkeel.npcs.controllers.data.ability.Condition;
|
||||
import kamkeel.npcs.controllers.data.ability.AbilityIconData;
|
||||
import kamkeel.npcs.controllers.data.ability.IChainedAbilityFieldProvider;
|
||||
import kamkeel.npcs.controllers.data.ability.UserType;
|
||||
import kamkeel.npcs.controllers.data.ability.conditions.AbilityCondition;
|
||||
import kamkeel.npcs.network.PacketClient;
|
||||
import kamkeel.npcs.network.packets.request.ability.CustomAbilitySavePacket;
|
||||
import net.minecraft.client.gui.GuiButton;
|
||||
import net.minecraft.nbt.NBTTagCompound;
|
||||
import net.minecraft.util.StatCollector;
|
||||
import noppes.npcs.client.gui.builder.FieldDef;
|
||||
import noppes.npcs.client.gui.builder.GuiFieldBuilder;
|
||||
@@ -21,18 +21,19 @@ import noppes.npcs.client.gui.util.GuiNpcButton;
|
||||
import noppes.npcs.client.gui.util.GuiNpcLabel;
|
||||
import noppes.npcs.client.gui.util.GuiNpcTextField;
|
||||
import noppes.npcs.client.gui.util.GuiScrollWindow;
|
||||
import noppes.npcs.client.gui.util.IAbilityConfigCallback;
|
||||
import noppes.npcs.client.gui.util.IChainedAbilityConfigCallback;
|
||||
import noppes.npcs.client.gui.util.ISubGuiListener;
|
||||
import noppes.npcs.client.gui.util.ITextfieldListener;
|
||||
import noppes.npcs.client.gui.util.SubGuiInterface;
|
||||
import noppes.npcs.client.gui.util.*;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import noppes.npcs.client.gui.util.IChainedAbilityConfigCallback;
|
||||
|
||||
|
||||
import java.util.Collections;
|
||||
import java.util.LinkedHashSet;
|
||||
import java.util.List;
|
||||
import java.util.Set;
|
||||
|
||||
import static kamkeel.npcs.controllers.data.ability.conditions.AbilityCondition.MAX_CONDITIONS;
|
||||
|
||||
/**
|
||||
* SubGui for editing a {@link ChainedAbility}.
|
||||
* Core tabs: General, Entries, Conditions.
|
||||
@@ -70,9 +71,9 @@ public class SubGuiChainedAbilityConfig extends SubGuiInterface implements IText
|
||||
// Actual ID = COND_BASE + i * COND_STRIDE + offset
|
||||
// offset 0 = name/click, 1 = edit, 2 = delete
|
||||
private static final int COND_BASE = 50;
|
||||
private static final int COND_END = 80;
|
||||
private static final int COND_STRIDE = 10;
|
||||
private static final int BTN_ADD_COND = 80;
|
||||
private static final int COND_END = COND_BASE + MAX_CONDITIONS * COND_STRIDE; // 50 + N*10
|
||||
private static final int BTN_ADD_COND = COND_END;
|
||||
|
||||
// ── Layout constants ──────────────────────────────────────────────────────
|
||||
private static final int L_LABEL_X = 5;
|
||||
@@ -88,7 +89,7 @@ public class SubGuiChainedAbilityConfig extends SubGuiInterface implements IText
|
||||
|
||||
private List<FieldDef> fieldDefs;
|
||||
private List<ChainedAbilityEntry> entries;
|
||||
private List<Condition> conditions;
|
||||
private List<AbilityCondition> conditions;
|
||||
|
||||
// Dynamic tabs injected by field providers (e.g., "Icon")
|
||||
private List<String> extraTabs = new ArrayList<>();
|
||||
@@ -157,7 +158,18 @@ public class SubGuiChainedAbilityConfig extends SubGuiInterface implements IText
|
||||
FieldDef.floatField("ability.maxRange", chain::getMaxRange, chain::setMaxRange).range(0, 64)
|
||||
).tab("Target"));
|
||||
|
||||
// External field providers (e.g., DBC Addon injecting an "Icon" tab)
|
||||
// ── Icon tab ──────────────────────────────────────────────
|
||||
AbilityIconData chainIcon = AbilityIconData.fromChainedAbility(chain);
|
||||
fieldDefs.add(FieldDef.stringField("gui.texture", chainIcon::getTexture, chainIcon::setTexture).tab("Icon"));
|
||||
fieldDefs.add(FieldDef.section("ability.icon.section.uv").tab("Icon"));
|
||||
fieldDefs.add(FieldDef.intField("ability.icon.x", chainIcon::getIconX, chainIcon::setIconX).tab("Icon").range(0, 4096));
|
||||
fieldDefs.add(FieldDef.intField("ability.icon.y", chainIcon::getIconY, chainIcon::setIconY).tab("Icon").range(0, 4096));
|
||||
fieldDefs.add(FieldDef.section("gui.size").tab("Icon"));
|
||||
fieldDefs.add(FieldDef.intField("gui.width", chainIcon::getWidth, chainIcon::setWidth).tab("Icon").range(1, 256));
|
||||
fieldDefs.add(FieldDef.intField("gui.height", chainIcon::getHeight, chainIcon::setHeight).tab("Icon").range(1, 256));
|
||||
fieldDefs.add(FieldDef.floatField("gui.scale", chainIcon::getScale, chainIcon::setScale).tab("Icon").range(0.1f, 10.0f));
|
||||
|
||||
// External field providers (e.g., DBC Addon injecting a "DBC" tab)
|
||||
if (AbilityController.Instance != null) {
|
||||
for (IChainedAbilityFieldProvider provider : AbilityController.Instance.getChainedFieldProviders()) {
|
||||
provider.addFieldDefinitions(chain, fieldDefs);
|
||||
@@ -416,8 +428,8 @@ public class SubGuiChainedAbilityConfig extends SubGuiInterface implements IText
|
||||
sw.addLabel(new GuiNpcLabel(labelCounter, "ability.conditions", L_LABEL_X, y + 2, 0xFFFF55));
|
||||
y += 15;
|
||||
|
||||
for (int i = 0; i < conditions.size() && i < 3; i++) {
|
||||
Condition cond = conditions.get(i);
|
||||
for (int i = 0; i < conditions.size() && i < MAX_CONDITIONS; i++) {
|
||||
AbilityCondition cond = conditions.get(i);
|
||||
String condName = getConditionDisplayName(cond);
|
||||
sw.addButton(new GuiNpcButton(COND_BASE + i * COND_STRIDE, L_LABEL_X, y, 140, 20, condName));
|
||||
sw.addButton(new GuiNpcButton(COND_BASE + i * COND_STRIDE + 1, L_LABEL_X + 145, y, 40, 20, "gui.edit"));
|
||||
@@ -425,7 +437,7 @@ public class SubGuiChainedAbilityConfig extends SubGuiInterface implements IText
|
||||
y += 22;
|
||||
}
|
||||
|
||||
if (conditions.size() < 3) {
|
||||
if (conditions.size() < MAX_CONDITIONS) {
|
||||
sw.addButton(new GuiNpcButton(BTN_ADD_COND, L_LABEL_X, y, 50, 20, "gui.add"));
|
||||
y += ROW_H;
|
||||
}
|
||||
@@ -433,29 +445,10 @@ public class SubGuiChainedAbilityConfig extends SubGuiInterface implements IText
|
||||
return y;
|
||||
}
|
||||
|
||||
private String getConditionDisplayName(Condition cond) {
|
||||
private String getConditionDisplayName(AbilityCondition cond) {
|
||||
if (cond == null) return "None";
|
||||
String typeId = cond.getTypeId();
|
||||
switch (typeId) {
|
||||
case "hp_above":
|
||||
return StatCollector.translateToLocal("condition.hp_above") + " " + (int) (getConditionThreshold(cond) * 100) + "%";
|
||||
case "hp_below":
|
||||
return StatCollector.translateToLocal("condition.hp_below") + " " + (int) (getConditionThreshold(cond) * 100) + "%";
|
||||
case "target_hp_above":
|
||||
return StatCollector.translateToLocal("condition.target_hp_above") + " " + (int) (getConditionThreshold(cond) * 100) + "%";
|
||||
case "target_hp_below":
|
||||
return StatCollector.translateToLocal("condition.target_hp_below") + " " + (int) (getConditionThreshold(cond) * 100) + "%";
|
||||
case "hit_count":
|
||||
Condition.ConditionHitCount hc = (Condition.ConditionHitCount) cond;
|
||||
return StatCollector.translateToLocal("condition.hit_count") + ": " + hc.getRequiredHits() + "/" + hc.getWithinTicks() + "t";
|
||||
default:
|
||||
return typeId;
|
||||
}
|
||||
}
|
||||
|
||||
private float getConditionThreshold(Condition cond) {
|
||||
NBTTagCompound nbt = cond.writeNBT();
|
||||
return nbt.hasKey("threshold") ? nbt.getFloat("threshold") : 0.5f;
|
||||
String name = cond.getName();
|
||||
return StatCollector.translateToLocal(name);
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════════════
|
||||
@@ -623,7 +616,7 @@ public class SubGuiChainedAbilityConfig extends SubGuiInterface implements IText
|
||||
return true;
|
||||
}
|
||||
if (id == BTN_ADD_COND) {
|
||||
if (conditions.size() < 3) {
|
||||
if (conditions.size() < MAX_CONDITIONS) {
|
||||
editingConditionIndex = conditions.size();
|
||||
setSubGui(new SubGuiConditionEdit(null));
|
||||
}
|
||||
@@ -833,7 +826,7 @@ public class SubGuiChainedAbilityConfig extends SubGuiInterface implements IText
|
||||
}
|
||||
|
||||
private void handleConditionEditClosed(SubGuiConditionEdit gui) {
|
||||
Condition result = gui.getResult();
|
||||
AbilityCondition result = gui.getResult();
|
||||
if (result != null && editingConditionIndex >= 0) {
|
||||
if (editingConditionIndex < conditions.size()) {
|
||||
conditions.set(editingConditionIndex, result);
|
||||
@@ -879,7 +872,7 @@ public class SubGuiChainedAbilityConfig extends SubGuiInterface implements IText
|
||||
|
||||
// Conditions
|
||||
chain.getConditions().clear();
|
||||
for (Condition c : conditions) {
|
||||
for (AbilityCondition c : conditions) {
|
||||
chain.getConditions().add(c);
|
||||
}
|
||||
|
||||
|
||||
@@ -1,190 +1,310 @@
|
||||
package noppes.npcs.client.gui.advanced;
|
||||
|
||||
import kamkeel.npcs.controllers.data.ability.Condition;
|
||||
import kamkeel.npcs.controllers.AbilityController;
|
||||
import kamkeel.npcs.controllers.data.ability.conditions.AbilityCondition;
|
||||
import kamkeel.npcs.util.Register;
|
||||
import net.minecraft.client.gui.GuiButton;
|
||||
import noppes.npcs.client.gui.util.GuiNpcButton;
|
||||
import noppes.npcs.client.gui.util.GuiNpcLabel;
|
||||
import noppes.npcs.client.gui.util.GuiNpcTextField;
|
||||
import noppes.npcs.client.gui.util.ITextfieldListener;
|
||||
import noppes.npcs.client.gui.util.SubGuiInterface;
|
||||
import net.minecraft.client.resources.I18n;
|
||||
import noppes.npcs.client.gui.builder.FieldDef;
|
||||
import noppes.npcs.client.gui.util.*;
|
||||
import kamkeel.npcs.controllers.data.ability.gui.AbilityFieldBuilder;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.function.Supplier;
|
||||
|
||||
/**
|
||||
* SubGui for editing a single ability condition.
|
||||
* Allows selecting condition type and configuring its parameters.
|
||||
* SubGui for editing a single AbilityCondition.
|
||||
*
|
||||
* Split-panel layout:
|
||||
* Left – Mod namespace filter + scrollable condition type list
|
||||
* Right – FieldDef configuration for the selected condition
|
||||
*/
|
||||
public class SubGuiConditionEdit extends SubGuiInterface implements ITextfieldListener {
|
||||
public class SubGuiConditionEdit extends SubGuiInterface implements ITextfieldListener, ISubGuiListener, ICustomScrollListener {
|
||||
|
||||
// Condition types
|
||||
private static final String[] CONDITION_TYPES = {
|
||||
"condition.hp_above",
|
||||
"condition.hp_below",
|
||||
"condition.target_hp_above",
|
||||
"condition.target_hp_below",
|
||||
"condition.hit_count"
|
||||
};
|
||||
private static final int DECLARATIVE_ID_START = 1000;
|
||||
private static final int CLEAR_ID_START = 2000;
|
||||
private static final int LABEL_ID_START = 3000;
|
||||
|
||||
private static final String[] CONDITION_TYPE_IDS = {
|
||||
"hp_above",
|
||||
"hp_below",
|
||||
"target_hp_above",
|
||||
"target_hp_below",
|
||||
"hit_count"
|
||||
};
|
||||
private static final int BTN_NAMESPACE = 1;
|
||||
private static final int BTN_CANCEL = 10;
|
||||
private static final int BTN_DONE = 11;
|
||||
private static final int TF_SEARCH = 12;
|
||||
|
||||
// Current condition being edited
|
||||
private Condition condition;
|
||||
private Condition result;
|
||||
// Left panel
|
||||
private static final int LEFT_WIDTH = 110;
|
||||
private static final int LEFT_MARGIN = 5;
|
||||
|
||||
// State
|
||||
private int selectedTypeIndex = 0;
|
||||
private float threshold = 0.5f; // For HP conditions (0.0-1.0)
|
||||
private int requiredHits = 3; // For hit_count
|
||||
private int withinTicks = 60; // For hit_count
|
||||
// Right panel
|
||||
private static final int RIGHT_GAP = 5;
|
||||
|
||||
public SubGuiConditionEdit(Condition existing) {
|
||||
this.condition = existing;
|
||||
private String searchText = "";
|
||||
|
||||
private AbilityCondition condition;
|
||||
private AbilityCondition result;
|
||||
private String selectedTypeId;
|
||||
|
||||
// Namespace filter
|
||||
private int namespaceFilter = 0; // 0 = ALL, 1 = cnpc, 2+ = modded namespaces
|
||||
private List<String> modNamespaces;
|
||||
|
||||
// Type list
|
||||
private GuiCustomScroll scroll;
|
||||
private final HashMap<String, String> displayNameToTypeId = new HashMap<>();
|
||||
private String[] filteredTypeIds;
|
||||
|
||||
private AbilityFieldBuilder builder;
|
||||
|
||||
public SubGuiConditionEdit(AbilityCondition existing) {
|
||||
this.result = null;
|
||||
this.modNamespaces = getModNamespaces();
|
||||
|
||||
if (existing != null) {
|
||||
String typeId = existing.getTypeId();
|
||||
for (int i = 0; i < CONDITION_TYPE_IDS.length; i++) {
|
||||
if (CONDITION_TYPE_IDS[i].equals(typeId)) {
|
||||
selectedTypeIndex = i;
|
||||
break;
|
||||
}
|
||||
this.condition = existing;
|
||||
this.selectedTypeId = existing.getTypeId();
|
||||
// Set namespace filter to match existing condition
|
||||
setNamespaceForTypeId(selectedTypeId);
|
||||
} else {
|
||||
// Default to first available condition
|
||||
String[] allTypes = AbilityController.Instance.getConditionTypes();
|
||||
if (allTypes.length > 0) {
|
||||
this.selectedTypeId = allTypes[0];
|
||||
this.condition = spawnCondition(selectedTypeId);
|
||||
}
|
||||
loadFromCondition(existing);
|
||||
}
|
||||
|
||||
setBackground("menubg.png");
|
||||
xSize = 220;
|
||||
ySize = 140;
|
||||
setBackground("menubg.png", 217);
|
||||
xSize = 356;
|
||||
ySize = 200;
|
||||
}
|
||||
|
||||
private void loadFromCondition(Condition cond) {
|
||||
String typeId = cond.getTypeId();
|
||||
if (typeId.equals("hit_count")) {
|
||||
Condition.ConditionHitCount hitCount = (Condition.ConditionHitCount) cond;
|
||||
requiredHits = hitCount.getRequiredHits();
|
||||
withinTicks = hitCount.getWithinTicks();
|
||||
} else {
|
||||
// HP-based conditions
|
||||
net.minecraft.nbt.NBTTagCompound nbt = cond.writeNBT();
|
||||
threshold = nbt.hasKey("threshold") ? nbt.getFloat("threshold") : 0.5f;
|
||||
private List<String> getModNamespaces() {
|
||||
List<String> result = new ArrayList<>();
|
||||
List<String> registered = Register.REGISTERED_NAMESPACES.get("condition");
|
||||
if (registered != null) {
|
||||
result.addAll(registered);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
private void setNamespaceForTypeId(String typeId) {
|
||||
if (typeId == null) return;
|
||||
String[] parts = typeId.split("\\.", 3);
|
||||
if (parts.length < 2) return;
|
||||
String ns = parts[1];
|
||||
|
||||
if ("cnpc".equals(ns)) {
|
||||
namespaceFilter = 1;
|
||||
} else {
|
||||
for (int i = 0; i < modNamespaces.size(); i++) {
|
||||
if (modNamespaces.get(i).equals(ns)) {
|
||||
namespaceFilter = 2 + i;
|
||||
return;
|
||||
}
|
||||
}
|
||||
namespaceFilter = 0; // Fallback to ALL
|
||||
}
|
||||
}
|
||||
|
||||
private String getNamespaceFilterLabel() {
|
||||
if (namespaceFilter == 0) return "ALL";
|
||||
if (namespaceFilter == 1) return "CNPC";
|
||||
int modIdx = namespaceFilter - 2;
|
||||
if (modIdx >= 0 && modIdx < modNamespaces.size()) {
|
||||
String ns = modNamespaces.get(modIdx);
|
||||
String display = Register.NAMESPACE_DISPLAY_NAMES.get(ns);
|
||||
return display != null ? display : ns.toUpperCase();
|
||||
}
|
||||
return "ALL";
|
||||
}
|
||||
|
||||
private void cycleNamespaceFilter() {
|
||||
namespaceFilter++;
|
||||
// 0=ALL, 1=CNPC, 2..2+N-1=mod namespaces, then wrap
|
||||
int max = 2 + modNamespaces.size();
|
||||
if (namespaceFilter >= max) {
|
||||
namespaceFilter = 0;
|
||||
}
|
||||
// Skip empty mod namespace slots
|
||||
if (namespaceFilter >= 2) {
|
||||
int modIdx = namespaceFilter - 2;
|
||||
if (modIdx >= modNamespaces.size()) {
|
||||
namespaceFilter = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private String[] getFilteredTypes() {
|
||||
if (namespaceFilter == 0) {
|
||||
return AbilityController.Instance.getConditionTypes();
|
||||
} else if (namespaceFilter == 1) {
|
||||
return AbilityController.Instance.getConditionTypesByNamespace("cnpc");
|
||||
} else {
|
||||
int modIdx = namespaceFilter - 2;
|
||||
if (modIdx >= 0 && modIdx < modNamespaces.size()) {
|
||||
return AbilityController.Instance.getConditionTypesByNamespace(modNamespaces.get(modIdx));
|
||||
}
|
||||
return AbilityController.Instance.getConditionTypes();
|
||||
}
|
||||
}
|
||||
|
||||
private AbilityCondition spawnCondition(String typeId) {
|
||||
if (typeId == null) return null;
|
||||
Supplier<AbilityCondition> factory = AbilityController.Instance.getConditionType(typeId);
|
||||
return factory != null ? factory.get() : null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void initGui() {
|
||||
GuiNpcTextField.unfocus();
|
||||
super.initGui();
|
||||
|
||||
int y = guiTop + 8;
|
||||
int labelX = guiLeft + 8;
|
||||
int fieldX = guiLeft + 90;
|
||||
int leftX = guiLeft + LEFT_MARGIN;
|
||||
int btnY = guiTop + ySize - 26;
|
||||
|
||||
// Title
|
||||
addLabel(new GuiNpcLabel(0, "condition.edit", labelX, y));
|
||||
y += 18;
|
||||
// Namespace filter button (above left scroll only)
|
||||
addButton(new GuiNpcButton(BTN_NAMESPACE, leftX, guiTop + 5, LEFT_WIDTH, 20, getNamespaceFilterLabel()));
|
||||
|
||||
// Condition Type selector
|
||||
addLabel(new GuiNpcLabel(1, "gui.type", labelX, y + 5));
|
||||
GuiNpcButton typeBtn = new GuiNpcButton(1, fieldX, y, 115, 20, CONDITION_TYPES, selectedTypeIndex);
|
||||
typeBtn.setHoverText("condition.hover.type");
|
||||
addButton(typeBtn);
|
||||
y += 26;
|
||||
|
||||
// Type-specific fields
|
||||
String typeId = CONDITION_TYPE_IDS[selectedTypeIndex];
|
||||
if (typeId.equals("hit_count")) {
|
||||
// Hit count fields
|
||||
addLabel(new GuiNpcLabel(2, "condition.hits", labelX, y + 5));
|
||||
GuiNpcTextField hitsField = new GuiNpcTextField(2, this, fontRendererObj, fieldX, y, 40, 20, "" + requiredHits);
|
||||
hitsField.setIntegersOnly();
|
||||
hitsField.setMinMaxDefault(1, 100, 3);
|
||||
hitsField.setHoverText("condition.hover.hits");
|
||||
addTextField(hitsField);
|
||||
y += 24;
|
||||
|
||||
addLabel(new GuiNpcLabel(3, "condition.within", labelX, y + 5));
|
||||
GuiNpcTextField ticksField = new GuiNpcTextField(3, this, fontRendererObj, fieldX, y, 40, 20, "" + withinTicks);
|
||||
ticksField.setIntegersOnly();
|
||||
ticksField.setMinMaxDefault(1, 1200, 60);
|
||||
ticksField.setHoverText("condition.hover.within");
|
||||
addTextField(ticksField);
|
||||
} else {
|
||||
// HP threshold field (as percentage)
|
||||
addLabel(new GuiNpcLabel(2, "condition.percent", labelX, y + 5));
|
||||
int percent = (int) (threshold * 100);
|
||||
GuiNpcTextField thresholdField = new GuiNpcTextField(4, this, fontRendererObj, fieldX, y, 40, 20, "" + percent);
|
||||
thresholdField.setIntegersOnly();
|
||||
thresholdField.setMinMaxDefault(1, 99, 50);
|
||||
thresholdField.setHoverText("condition.hover.threshold");
|
||||
addTextField(thresholdField);
|
||||
addLabel(new GuiNpcLabel(4, "%", fieldX + 45, y + 5));
|
||||
// Build filtered type list
|
||||
filteredTypeIds = getFilteredTypes();
|
||||
displayNameToTypeId.clear();
|
||||
List<String> scrollList = new ArrayList<>();
|
||||
for (String typeId : filteredTypeIds) {
|
||||
Supplier<AbilityCondition> factory = AbilityController.Instance.getConditionType(typeId);
|
||||
String displayName = factory != null ? I18n.format(factory.get().getName()) : typeId;
|
||||
if (!searchText.isEmpty() && !displayName.toLowerCase().contains(searchText.toLowerCase())) continue;
|
||||
scrollList.add(displayName);
|
||||
displayNameToTypeId.put(displayName, typeId);
|
||||
}
|
||||
|
||||
// Left panel: condition type scroll list (between namespace button and search bar)
|
||||
int scrollTop = guiTop + 29;
|
||||
int scrollBottom = btnY - 24;
|
||||
int scrollHeight = scrollBottom - scrollTop;
|
||||
if (scroll == null) {
|
||||
scroll = new GuiCustomScroll(this, 0);
|
||||
}
|
||||
scroll.guiLeft = leftX;
|
||||
scroll.guiTop = scrollTop;
|
||||
scroll.setSize(LEFT_WIDTH, scrollHeight);
|
||||
scroll.setUnsortedList(scrollList);
|
||||
|
||||
// Pre-select current condition type in scroll
|
||||
if (selectedTypeId != null) {
|
||||
for (int i = 0; i < scrollList.size(); i++) {
|
||||
String typeId = displayNameToTypeId.get(scrollList.get(i));
|
||||
if (typeId != null && typeId.equals(selectedTypeId)) {
|
||||
scroll.selected = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
addScroll(scroll);
|
||||
|
||||
// Search text field (below left scroll)
|
||||
GuiNpcTextField searchField = new GuiNpcTextField(TF_SEARCH, this, fontRendererObj, leftX, scrollBottom + 2, LEFT_WIDTH, 20, searchText);
|
||||
searchField.setHoverText("gui.search");
|
||||
addTextField(searchField);
|
||||
|
||||
// Right panel: condition config via FieldDef (full height from top to buttons)
|
||||
int rightX = leftX + LEFT_WIDTH + RIGHT_GAP;
|
||||
int rightW = xSize - LEFT_MARGIN * 2 - LEFT_WIDTH - RIGHT_GAP;
|
||||
int rightTop = guiTop + 5;
|
||||
int rightHeight = btnY - rightTop - 4;
|
||||
|
||||
List<FieldDef> fields = new ArrayList<>();
|
||||
if (condition != null) {
|
||||
fields = condition.getAllDefinitions();
|
||||
}
|
||||
|
||||
builder = new AbilityFieldBuilder(this, fontRendererObj);
|
||||
builder.startIds(DECLARATIVE_ID_START, CLEAR_ID_START, LABEL_ID_START);
|
||||
builder.contentRight(rightW);
|
||||
builder.startY(5);
|
||||
builder.buildScrollWindow(fields, rightX, rightTop, rightW, rightHeight);
|
||||
|
||||
// Bottom buttons
|
||||
addButton(new GuiNpcButton(10, guiLeft + 8, guiTop + ySize - 28, 60, 20, "gui.cancel"));
|
||||
addButton(new GuiNpcButton(11, guiLeft + xSize - 68, guiTop + ySize - 28, 60, 20, "gui.done"));
|
||||
addButton(new GuiNpcButton(BTN_CANCEL, leftX, btnY, 60, 20, "gui.cancel"));
|
||||
GuiNpcButton doneBtn = new GuiNpcButton(BTN_DONE, guiLeft + xSize - LEFT_MARGIN - 60, btnY, 60, 20, "gui.done");
|
||||
if (condition == null || !condition.isConfigured()) {
|
||||
doneBtn.setEnabled(false);
|
||||
}
|
||||
addButton(doneBtn);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void buttonEvent(GuiButton guibutton) {
|
||||
int id = guibutton.id;
|
||||
|
||||
if (id == 1) {
|
||||
// Type changed
|
||||
selectedTypeIndex = ((GuiNpcButton) guibutton).getValue();
|
||||
if (id == BTN_NAMESPACE) {
|
||||
cycleNamespaceFilter();
|
||||
initGui();
|
||||
} else if (id == 10) {
|
||||
// Cancel - close without saving
|
||||
return;
|
||||
}
|
||||
|
||||
if (id == BTN_CANCEL) {
|
||||
result = null;
|
||||
close();
|
||||
} else if (id == 11) {
|
||||
// Done - create condition and close
|
||||
result = createCondition();
|
||||
return;
|
||||
}
|
||||
|
||||
if (id == BTN_DONE) {
|
||||
result = condition;
|
||||
close();
|
||||
return;
|
||||
}
|
||||
|
||||
if (builder != null && builder.handleButtonEvent(id, guibutton)) {
|
||||
if (!hasSubGui()) {
|
||||
initGui();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void customScrollClicked(int i, int j, int k, GuiCustomScroll guiCustomScroll) {
|
||||
if (guiCustomScroll.id == 0 && scroll.hasSelected()) {
|
||||
String displayName = scroll.getSelected();
|
||||
String typeId = displayNameToTypeId.get(displayName);
|
||||
if (typeId != null && !typeId.equals(selectedTypeId)) {
|
||||
selectedTypeId = typeId;
|
||||
condition = spawnCondition(selectedTypeId);
|
||||
initGui();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void customScrollDoubleClicked(String selection, GuiCustomScroll guiCustomScroll) {
|
||||
// Same as single click — user still needs to configure fields
|
||||
}
|
||||
|
||||
@Override
|
||||
public void unFocused(GuiNpcTextField textField) {
|
||||
int id = textField.id;
|
||||
|
||||
if (id == 2) {
|
||||
requiredHits = textField.getInteger();
|
||||
} else if (id == 3) {
|
||||
withinTicks = textField.getInteger();
|
||||
} else if (id == 4) {
|
||||
int percent = textField.getInteger();
|
||||
threshold = percent / 100.0f;
|
||||
if (textField.id == TF_SEARCH) {
|
||||
String newText = textField.getText();
|
||||
if (!newText.equals(searchText)) {
|
||||
searchText = newText;
|
||||
initGui();
|
||||
}
|
||||
return;
|
||||
}
|
||||
if (textField.id < DECLARATIVE_ID_START) return;
|
||||
if (builder != null && builder.handleTextFieldEvent(textField.id, textField)) {
|
||||
initGui();
|
||||
}
|
||||
}
|
||||
|
||||
private Condition createCondition() {
|
||||
String typeId = CONDITION_TYPE_IDS[selectedTypeIndex];
|
||||
|
||||
switch (typeId) {
|
||||
case "hp_above":
|
||||
return new Condition.ConditionHPAbove(threshold);
|
||||
case "hp_below":
|
||||
return new Condition.ConditionHPBelow(threshold);
|
||||
case "target_hp_above":
|
||||
return new Condition.ConditionTargetHPAbove(threshold);
|
||||
case "target_hp_below":
|
||||
return new Condition.ConditionTargetHPBelow(threshold);
|
||||
case "hit_count":
|
||||
return new Condition.ConditionHitCount(requiredHits, withinTicks);
|
||||
default:
|
||||
return null;
|
||||
@Override
|
||||
public void subGuiClosed(SubGuiInterface subgui) {
|
||||
if (builder != null && builder.handleSubGuiClosed(subgui)) {
|
||||
initGui();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the resulting condition after dialog closes.
|
||||
* Returns null if cancelled or no valid condition.
|
||||
*/
|
||||
public Condition getResult() {
|
||||
public AbilityCondition getResult() {
|
||||
return result;
|
||||
}
|
||||
}
|
||||
@@ -344,6 +344,9 @@ public class GuiFieldBuilder {
|
||||
String translated = StatCollector.translateToLocal(def.getLabel());
|
||||
int labelW = fontRenderer.getStringWidth(translated);
|
||||
int fieldX = colLLabel + labelW + labelPadding;
|
||||
// Clamp field width so it doesn't extend under the scrollbar
|
||||
int maxW = contentRight - fieldX - 15;
|
||||
if (maxW > 0 && fieldW > maxW) fieldW = maxW;
|
||||
renderFieldAt(def, colLLabel, fieldX, fieldW, y);
|
||||
}
|
||||
|
||||
|
||||
@@ -173,7 +173,7 @@ public class GuiNPCManageEffects extends GuiNPCInterface2 implements ICustomScro
|
||||
int iconWidth = effect.getWidth();
|
||||
int iconHeight = effect.getHeight();
|
||||
int width = data.getTotalWidth();
|
||||
int height = data.getTotalWidth();
|
||||
int height = data.getTotalHeight();
|
||||
|
||||
|
||||
func_152125_a(x, y, iconX, iconY, iconWidth, iconHeight, iconRenderSize, iconRenderSize, width, height);
|
||||
|
||||
@@ -81,10 +81,10 @@ public class CompassHudComponent extends HudComponent {
|
||||
ConfigClient.CompassEnabledProperty.set(ConfigClient.CompassEnabled);
|
||||
|
||||
ConfigClient.CompassOverlayX = posX;
|
||||
ConfigClient.CompassOverlayXProperty.set(ConfigClient.CompassOverlayX);
|
||||
ConfigClient.CompassOverlayXProperty.set((double) ConfigClient.CompassOverlayX);
|
||||
|
||||
ConfigClient.CompassOverlayY = posY;
|
||||
ConfigClient.CompassOverlayYProperty.set(ConfigClient.CompassOverlayY);
|
||||
ConfigClient.CompassOverlayYProperty.set((double) ConfigClient.CompassOverlayY);
|
||||
|
||||
ConfigClient.CompassOverlayScale = scale;
|
||||
ConfigClient.CompassOverlayScaleProperty.set(ConfigClient.CompassOverlayScale);
|
||||
|
||||
@@ -2,5 +2,6 @@ package noppes.npcs.client.gui.hud;
|
||||
|
||||
public enum EnumHudComponent {
|
||||
QuestTracker,
|
||||
QuestCompass
|
||||
QuestCompass,
|
||||
AbilityHotbar
|
||||
}
|
||||
@@ -173,7 +173,8 @@ public class GuiHudEditor extends GuiScreen {
|
||||
int absHeight = (int) (hud.overlayHeight * effectiveScale);
|
||||
if (mouseX >= actualX && mouseX <= actualX + absWidth &&
|
||||
mouseY >= actualY && mouseY <= actualY + absHeight) {
|
||||
if (mouseX >= actualX + absWidth - HANDLE_SIZE && mouseY >= actualY + absHeight - HANDLE_SIZE) {
|
||||
int scaledHandle = Math.max(8, (int) (HANDLE_SIZE * effectiveScale));
|
||||
if (mouseX >= actualX + absWidth - scaledHandle && mouseY >= actualY + absHeight - scaledHandle) {
|
||||
resizing = true;
|
||||
selectedComponent = hud;
|
||||
initialScale = hud.scale;
|
||||
@@ -214,12 +215,14 @@ public class GuiHudEditor extends GuiScreen {
|
||||
int newY = scaledHeight - (Mouse.getY() * scaledHeight / mc.displayHeight) - dragOffsetY;
|
||||
if (newX < 0) newX = 0;
|
||||
if (newY < 0) newY = 0;
|
||||
if (newX + (int) (selectedComponent.overlayWidth * effectiveScale) > scaledWidth)
|
||||
newX = scaledWidth - (int) (selectedComponent.overlayWidth * effectiveScale);
|
||||
if (newY + (int) (selectedComponent.overlayHeight * effectiveScale) > scaledHeight)
|
||||
newY = scaledHeight - (int) (selectedComponent.overlayHeight * effectiveScale);
|
||||
selectedComponent.posX = (int) (100F * newX / scaledWidth);
|
||||
selectedComponent.posY = (int) (100F * newY / scaledHeight);
|
||||
int compW = (int) Math.ceil(selectedComponent.overlayWidth * effectiveScale);
|
||||
int compH = (int) Math.ceil(selectedComponent.overlayHeight * effectiveScale);
|
||||
if (newX + compW > scaledWidth)
|
||||
newX = scaledWidth - compW;
|
||||
if (newY + compH > scaledHeight)
|
||||
newY = scaledHeight - compH;
|
||||
selectedComponent.posX = 100F * newX / scaledWidth;
|
||||
selectedComponent.posY = 100F * newY / scaledHeight;
|
||||
}
|
||||
if (resizing) {
|
||||
int currentMouseX = Mouse.getX() * width / mc.displayWidth;
|
||||
@@ -260,8 +263,8 @@ public class GuiHudEditor extends GuiScreen {
|
||||
}
|
||||
int centerX = (res.getScaledWidth() - compWidth) / 2;
|
||||
int centerY = (res.getScaledHeight() - compHeight) / 2;
|
||||
selectedComponent.posX = (int) (100F * centerX / res.getScaledWidth());
|
||||
selectedComponent.posY = (int) (100F * centerY / res.getScaledHeight());
|
||||
selectedComponent.posX = 100F * centerX / res.getScaledWidth();
|
||||
selectedComponent.posY = 100F * centerY / res.getScaledHeight();
|
||||
updateCustomButtons();
|
||||
}
|
||||
} else if (button.id == CYCLE_LEFT_ID) {
|
||||
|
||||
@@ -8,7 +8,8 @@ import java.util.List;
|
||||
|
||||
public abstract class HudComponent {
|
||||
// Stored as percentages (0-100) of the current screen resolution.
|
||||
protected int posX = 50, posY = 50, scale = 100, textAlign = 0;
|
||||
public float posX = 50, posY = 50;
|
||||
protected int scale = 100, textAlign = 0;
|
||||
|
||||
public boolean enabled = true;
|
||||
public boolean hasData = false;
|
||||
|
||||
@@ -113,10 +113,10 @@ public class QuestTrackingComponent extends HudComponent {
|
||||
@Override
|
||||
public void save() {
|
||||
ConfigClient.QuestOverlayX = posX;
|
||||
ConfigClient.QuestOverlayXProperty.set(ConfigClient.QuestOverlayX);
|
||||
ConfigClient.QuestOverlayXProperty.set((double) ConfigClient.QuestOverlayX);
|
||||
|
||||
ConfigClient.QuestOverlayY = posY;
|
||||
ConfigClient.QuestOverlayYProperty.set(ConfigClient.QuestOverlayY);
|
||||
ConfigClient.QuestOverlayYProperty.set((double) ConfigClient.QuestOverlayY);
|
||||
|
||||
ConfigClient.QuestOverlayScale = scale;
|
||||
ConfigClient.QuestOverlayScaleProperty.set(ConfigClient.QuestOverlayScale);
|
||||
@@ -218,8 +218,8 @@ public class QuestTrackingComponent extends HudComponent {
|
||||
int compHeight = (int) (overlayHeight * effectiveScale);
|
||||
int centerX = (res.getScaledWidth() - compWidth) / 2;
|
||||
int centerY = (res.getScaledHeight() - compHeight) / 2;
|
||||
posX = (int) (100F * centerX / res.getScaledWidth());
|
||||
posY = (int) (100F * centerY / res.getScaledHeight());
|
||||
posX = 100F * centerX / res.getScaledWidth();
|
||||
posY = 100F * centerY / res.getScaledHeight();
|
||||
} else {
|
||||
super.onEditorButtonPressed(button);
|
||||
}
|
||||
|
||||
@@ -0,0 +1,683 @@
|
||||
package noppes.npcs.client.gui.hud.ability;
|
||||
|
||||
import cpw.mods.fml.relauncher.Side;
|
||||
import cpw.mods.fml.relauncher.SideOnly;
|
||||
import kamkeel.npcs.controllers.AbilityController;
|
||||
import kamkeel.npcs.controllers.data.ability.Ability;
|
||||
import kamkeel.npcs.controllers.data.ability.IAbilityAction;
|
||||
import kamkeel.npcs.network.PacketHandler;
|
||||
import kamkeel.npcs.network.packets.player.ability.AbilityHotbarSelectPacket;
|
||||
import net.minecraft.client.Minecraft;
|
||||
import noppes.npcs.client.ClientProxy;
|
||||
import net.minecraft.client.gui.FontRenderer;
|
||||
import net.minecraft.client.gui.GuiButton;
|
||||
import net.minecraft.client.gui.ScaledResolution;
|
||||
import net.minecraft.nbt.NBTTagCompound;
|
||||
import noppes.npcs.client.ClientCacheHandler;
|
||||
import noppes.npcs.client.gui.hud.HudComponent;
|
||||
import noppes.npcs.config.ConfigClient;
|
||||
import noppes.npcs.controllers.data.AbilityHotbarData;
|
||||
import noppes.npcs.controllers.data.PlayerAbilityHotbarData;
|
||||
import noppes.npcs.controllers.data.PlayerData;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
@SideOnly(Side.CLIENT)
|
||||
public class AbilityHotbarComponent extends HudComponent {
|
||||
public static final int TOTAL_SLOTS = AbilityHotbarData.TOTAL_SLOTS;
|
||||
|
||||
private static final int BASE_SLOT_SIZE = 24;
|
||||
private static final int BASE_SPACING = 28;
|
||||
|
||||
private AbilityHotbarSlotRenderer[] slots = new AbilityHotbarSlotRenderer[TOTAL_SLOTS];
|
||||
|
||||
// Filtered carousel: only filled slots + one deselect entry
|
||||
// Each entry is a raw slot index (0-11), or -1 for the deselect slot
|
||||
private int[] activeIndices = new int[0];
|
||||
private int activeCenter = 0;
|
||||
|
||||
private float scrollOffset = 0f;
|
||||
private long scrollStartTime = 0;
|
||||
private static final long SCROLL_DURATION = 150;
|
||||
|
||||
private long lastUpdateTime = 0;
|
||||
private static final long UPDATE_INTERVAL = 500;
|
||||
|
||||
// Debounce: delay sending selection packet
|
||||
private String pendingSelectKey = null;
|
||||
private long pendingSelectTime = 0;
|
||||
private static final long SELECT_DEBOUNCE = 300;
|
||||
|
||||
// Grace period: don't let server state override local state after user interaction
|
||||
private long lastUserCycleTime = 0;
|
||||
private static final long USER_CYCLE_GRACE = 1000;
|
||||
|
||||
// Fade: when ShowAlways=false, fade in/out when HUD key is held
|
||||
private float fadeAlpha = 0f;
|
||||
private long lastFadeTime = 0;
|
||||
private static final float FADE_SPEED = 3f; // per second — ~333ms full transition
|
||||
|
||||
private Minecraft mc;
|
||||
|
||||
public AbilityHotbarComponent(Minecraft mc) {
|
||||
this.mc = mc;
|
||||
updateOverlayDimensions();
|
||||
for (int i = 0; i < TOTAL_SLOTS; i++) {
|
||||
slots[i] = new AbilityHotbarSlotRenderer(i);
|
||||
}
|
||||
load();
|
||||
}
|
||||
|
||||
private int getEffectiveVisibleSlots() {
|
||||
int configMax = ConfigClient.AbilityHotbarVisibleSlots;
|
||||
if (configMax != 3 && configMax != 5 && configMax != 7) configMax = 5;
|
||||
int filledCount = activeIndices.length - 1; // subtract deselect slot
|
||||
if (filledCount < 0) filledCount = 0;
|
||||
if (filledCount < 5) return Math.min(configMax, 3);
|
||||
if (filledCount < 7) return Math.min(configMax, 5);
|
||||
return configMax;
|
||||
}
|
||||
|
||||
private void updateOverlayDimensions() {
|
||||
boolean isHorizontal = ConfigClient.AbilityHotbarHorizontal;
|
||||
int visibleSlots = getEffectiveVisibleSlots();
|
||||
int span = BASE_SPACING * (visibleSlots - 1) + BASE_SLOT_SIZE;
|
||||
int thick = BASE_SLOT_SIZE + 4;
|
||||
if (isHorizontal) {
|
||||
overlayWidth = span;
|
||||
overlayHeight = thick;
|
||||
} else {
|
||||
overlayWidth = thick;
|
||||
overlayHeight = span;
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void loadData(NBTTagCompound compound) {
|
||||
}
|
||||
|
||||
@Override
|
||||
public void load() {
|
||||
posX = ConfigClient.AbilityHotbarX;
|
||||
posY = ConfigClient.AbilityHotbarY;
|
||||
scale = ConfigClient.AbilityHotbarScale;
|
||||
enabled = ConfigClient.AbilityHotbarEnabled;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void save() {
|
||||
ConfigClient.AbilityHotbarX = posX;
|
||||
ConfigClient.AbilityHotbarXProperty.set((double) posX);
|
||||
|
||||
ConfigClient.AbilityHotbarY = posY;
|
||||
ConfigClient.AbilityHotbarYProperty.set((double) posY);
|
||||
|
||||
ConfigClient.AbilityHotbarScale = scale;
|
||||
ConfigClient.AbilityHotbarScaleProperty.set(scale);
|
||||
|
||||
ConfigClient.AbilityHotbarEnabled = enabled;
|
||||
ConfigClient.AbilityHotbarEnabledProperty.set(enabled);
|
||||
|
||||
ConfigClient.AbilityHotbarHorizontalProperty.set(ConfigClient.AbilityHotbarHorizontal);
|
||||
ConfigClient.AbilityHotbarAltTextureProperty.set(ConfigClient.AbilityHotbarAltTexture);
|
||||
ConfigClient.AbilityHotbarTextPositionProperty.set(ConfigClient.AbilityHotbarTextPosition);
|
||||
ConfigClient.AbilityHotbarVisibleSlotsProperty.set(ConfigClient.AbilityHotbarVisibleSlots);
|
||||
ConfigClient.AbilityHotbarShowAlwaysProperty.set(ConfigClient.AbilityHotbarShowAlways);
|
||||
ConfigClient.AbilityHotbarTextVisibilityProperty.set(ConfigClient.AbilityHotbarTextVisibility);
|
||||
|
||||
if (ConfigClient.config.hasChanged()) {
|
||||
ConfigClient.config.save();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void renderOnScreen(float partialTicks) {
|
||||
if (!enabled || isEditting) return;
|
||||
if (mc.thePlayer == null || mc.currentScreen != null) return;
|
||||
if (!hasAnyAbilities()) return;
|
||||
|
||||
// Fade logic: when ShowAlways=false, only show while HUD key is held
|
||||
boolean showAlways = ConfigClient.AbilityHotbarShowAlways;
|
||||
long now = Minecraft.getSystemTime();
|
||||
if (!showAlways) {
|
||||
boolean hudKeyHeld = isHudKeyHeld();
|
||||
float dt = lastFadeTime > 0 ? (now - lastFadeTime) / 1000f : 0f;
|
||||
dt = Math.min(dt, 0.1f); // cap to avoid jumps after pauses
|
||||
lastFadeTime = now;
|
||||
if (hudKeyHeld || pendingSelectKey != null || scrollOffset != 0f) {
|
||||
fadeAlpha = Math.min(1f, fadeAlpha + FADE_SPEED * dt);
|
||||
} else {
|
||||
fadeAlpha = Math.max(0f, fadeAlpha - FADE_SPEED * dt);
|
||||
}
|
||||
if (fadeAlpha <= 0f) return;
|
||||
} else {
|
||||
fadeAlpha = 1f;
|
||||
lastFadeTime = now;
|
||||
}
|
||||
|
||||
long currentTime = Minecraft.getSystemTime();
|
||||
if (currentTime - lastUpdateTime > UPDATE_INTERVAL) {
|
||||
updateAbilities();
|
||||
lastUpdateTime = currentTime;
|
||||
}
|
||||
|
||||
// Flush debounced selection packet
|
||||
if (pendingSelectKey != null && currentTime - pendingSelectTime >= SELECT_DEBOUNCE) {
|
||||
PacketHandler.Instance.sendToServer(new AbilityHotbarSelectPacket(pendingSelectKey));
|
||||
pendingSelectKey = null;
|
||||
}
|
||||
|
||||
updateScrollAnimation();
|
||||
updateOverlayDimensions();
|
||||
|
||||
if (activeIndices.length == 0) return;
|
||||
|
||||
ScaledResolution sr = new ScaledResolution(mc, mc.displayWidth, mc.displayHeight);
|
||||
boolean isHorizontal = ConfigClient.AbilityHotbarHorizontal;
|
||||
float effectiveScale = getEffectiveScale(sr);
|
||||
int visibleSlots = getEffectiveVisibleSlots();
|
||||
int half = visibleSlots / 2;
|
||||
|
||||
int actualX = (int) (posX / 100.0f * sr.getScaledWidth());
|
||||
int actualY = (int) (posY / 100.0f * sr.getScaledHeight());
|
||||
|
||||
GL11.glPushMatrix();
|
||||
GL11.glTranslatef(actualX, actualY, 0);
|
||||
GL11.glScalef(effectiveScale, effectiveScale, 1);
|
||||
|
||||
int centerX = overlayWidth / 2;
|
||||
int centerY = overlayHeight / 2;
|
||||
|
||||
// Compute text visibility: 0=Shown, 1=Hidden, 2=Held
|
||||
boolean showText;
|
||||
int textVis = ConfigClient.AbilityHotbarTextVisibility;
|
||||
if (textVis == 1) {
|
||||
showText = false;
|
||||
} else if (textVis == 2) {
|
||||
showText = isHudKeyHeld();
|
||||
} else {
|
||||
showText = true;
|
||||
}
|
||||
|
||||
for (int i = 0; i < TOTAL_SLOTS; i++) {
|
||||
slots[i].updateNameFade();
|
||||
}
|
||||
|
||||
for (int offset = -half; offset <= half; offset++) {
|
||||
int activeIdx = ((activeCenter + offset) % activeIndices.length + activeIndices.length) % activeIndices.length;
|
||||
int rawSlotIndex = activeIndices[activeIdx];
|
||||
|
||||
float visualPos = offset + scrollOffset;
|
||||
float absDist = Math.abs(visualPos);
|
||||
|
||||
float slotScale;
|
||||
if (absDist <= 1f) {
|
||||
slotScale = 1.0f - 0.25f * absDist;
|
||||
} else {
|
||||
slotScale = 0.75f - 0.15f * (absDist - 1f);
|
||||
}
|
||||
slotScale = Math.max(0.1f, slotScale);
|
||||
|
||||
int scaledSize = Math.max(1, (int) (BASE_SLOT_SIZE * slotScale));
|
||||
|
||||
int cx, cy;
|
||||
if (isHorizontal) {
|
||||
cx = centerX + (int) (visualPos * BASE_SPACING);
|
||||
cy = centerY;
|
||||
} else {
|
||||
cx = centerX;
|
||||
cy = centerY + (int) (visualPos * BASE_SPACING);
|
||||
}
|
||||
|
||||
float maxDist = half + 0.5f;
|
||||
if (absDist > maxDist) continue;
|
||||
|
||||
float edgeAlpha = absDist > half - 0.5f ? 1f - (absDist - (half - 0.5f)) : 1f;
|
||||
float slotAlpha = edgeAlpha * fadeAlpha;
|
||||
boolean isCenter = (offset == 0 && scrollOffset == 0f);
|
||||
|
||||
// Compute per-slot cooldown progress (all slots, not just center)
|
||||
float slotCooldown = 0f;
|
||||
if (rawSlotIndex >= 0 && slots[rawSlotIndex].abilityKey != null) {
|
||||
slotCooldown = getCooldownProgressForSlot(rawSlotIndex);
|
||||
}
|
||||
|
||||
if (rawSlotIndex == -1) {
|
||||
// Deselect slot — draw empty marker
|
||||
drawDeselectSlot(cx, cy, scaledSize, isCenter, slotAlpha);
|
||||
} else {
|
||||
slots[rawSlotIndex].drawCarousel(mc, sr, slotCooldown, cx, cy, scaledSize, isCenter, slotAlpha, showText);
|
||||
}
|
||||
}
|
||||
|
||||
GL11.glPopMatrix();
|
||||
}
|
||||
|
||||
private void drawDeselectSlot(int cx, int cy, int size, boolean isCenter, float alpha) {
|
||||
float radius = size / 2f;
|
||||
float baseAlpha = isCenter ? 0.9f : 0.6f;
|
||||
float a = baseAlpha * alpha;
|
||||
boolean altTexture = ConfigClient.AbilityHotbarAltTexture;
|
||||
|
||||
GL11.glPushMatrix();
|
||||
GL11.glTranslatef(cx, cy, 0);
|
||||
|
||||
GL11.glDisable(GL11.GL_TEXTURE_2D);
|
||||
GL11.glEnable(GL11.GL_BLEND);
|
||||
GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
|
||||
|
||||
if (isCenter) {
|
||||
GL11.glColor4f(0.5f, 0.2f, 0.2f, a);
|
||||
} else {
|
||||
GL11.glColor4f(0.3f, 0.3f, 0.3f, a);
|
||||
}
|
||||
|
||||
if (altTexture) {
|
||||
GL11.glBegin(GL11.GL_QUADS);
|
||||
GL11.glVertex2f(-radius, -radius);
|
||||
GL11.glVertex2f(radius, -radius);
|
||||
GL11.glVertex2f(radius, radius);
|
||||
GL11.glVertex2f(-radius, radius);
|
||||
GL11.glEnd();
|
||||
} else {
|
||||
GL11.glBegin(GL11.GL_TRIANGLE_FAN);
|
||||
GL11.glVertex2f(0, 0);
|
||||
for (int i = 0; i <= 32; i++) {
|
||||
double angle = 2 * Math.PI * i / 32;
|
||||
GL11.glVertex2f((float) (Math.cos(angle) * radius), (float) (Math.sin(angle) * radius));
|
||||
}
|
||||
GL11.glEnd();
|
||||
}
|
||||
|
||||
// Draw X mark
|
||||
if (isCenter) {
|
||||
GL11.glColor4f(0.8f, 0.4f, 0.4f, alpha);
|
||||
} else {
|
||||
GL11.glColor4f(0.5f, 0.5f, 0.5f, alpha * 0.8f);
|
||||
}
|
||||
float xSize = radius * 0.4f;
|
||||
GL11.glLineWidth(2.0f);
|
||||
GL11.glBegin(GL11.GL_LINES);
|
||||
GL11.glVertex2f(-xSize, -xSize);
|
||||
GL11.glVertex2f(xSize, xSize);
|
||||
GL11.glVertex2f(-xSize, xSize);
|
||||
GL11.glVertex2f(xSize, -xSize);
|
||||
GL11.glEnd();
|
||||
|
||||
GL11.glEnable(GL11.GL_TEXTURE_2D);
|
||||
GL11.glColor4f(1, 1, 1, 1);
|
||||
GL11.glPopMatrix();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void renderEditing() {
|
||||
isEditting = true;
|
||||
updateOverlayDimensions();
|
||||
|
||||
ScaledResolution sr = new ScaledResolution(mc, mc.displayWidth, mc.displayHeight);
|
||||
float effectiveScale = getEffectiveScale(sr);
|
||||
boolean isHorizontal = ConfigClient.AbilityHotbarHorizontal;
|
||||
FontRenderer fr = mc.fontRenderer;
|
||||
int visibleSlots = getEffectiveVisibleSlots();
|
||||
int half = visibleSlots / 2;
|
||||
|
||||
int actualX = (int) (posX / 100.0f * sr.getScaledWidth());
|
||||
int actualY = (int) (posY / 100.0f * sr.getScaledHeight());
|
||||
|
||||
GL11.glPushMatrix();
|
||||
GL11.glTranslatef(actualX, actualY, 0);
|
||||
GL11.glScalef(effectiveScale, effectiveScale, 1);
|
||||
|
||||
int centerX = overlayWidth / 2;
|
||||
int centerY = overlayHeight / 2;
|
||||
|
||||
int[] slotCx = new int[visibleSlots];
|
||||
int[] slotCy = new int[visibleSlots];
|
||||
int[] slotSizes = new int[visibleSlots];
|
||||
|
||||
for (int offset = -half; offset <= half; offset++) {
|
||||
float absDist = Math.abs(offset);
|
||||
float slotScale;
|
||||
if (absDist <= 1f) {
|
||||
slotScale = 1.0f - 0.25f * absDist;
|
||||
} else {
|
||||
slotScale = 0.75f - 0.15f * (absDist - 1f);
|
||||
}
|
||||
slotScale = Math.max(0.1f, slotScale);
|
||||
int scaledSize = Math.max(1, (int) (BASE_SLOT_SIZE * slotScale));
|
||||
|
||||
int cx, cy;
|
||||
if (isHorizontal) {
|
||||
cx = centerX + offset * BASE_SPACING;
|
||||
cy = centerY;
|
||||
} else {
|
||||
cx = centerX;
|
||||
cy = centerY + offset * BASE_SPACING;
|
||||
}
|
||||
|
||||
int idx = offset + half;
|
||||
slotCx[idx] = cx;
|
||||
slotCy[idx] = cy;
|
||||
slotSizes[idx] = scaledSize;
|
||||
|
||||
float radius = scaledSize / 2f;
|
||||
boolean altTexture = ConfigClient.AbilityHotbarAltTexture;
|
||||
|
||||
GL11.glDisable(GL11.GL_TEXTURE_2D);
|
||||
GL11.glEnable(GL11.GL_BLEND);
|
||||
GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
|
||||
|
||||
float alpha = offset == 0 ? 0.9f : 0.6f;
|
||||
if (offset == 0) {
|
||||
GL11.glColor4f(0.8f, 0.8f, 0.2f, alpha);
|
||||
} else {
|
||||
GL11.glColor4f(0.4f, 0.4f, 0.4f, alpha);
|
||||
}
|
||||
|
||||
if (altTexture) {
|
||||
GL11.glBegin(GL11.GL_QUADS);
|
||||
GL11.glVertex2f(cx - radius, cy - radius);
|
||||
GL11.glVertex2f(cx + radius, cy - radius);
|
||||
GL11.glVertex2f(cx + radius, cy + radius);
|
||||
GL11.glVertex2f(cx - radius, cy + radius);
|
||||
GL11.glEnd();
|
||||
} else {
|
||||
GL11.glBegin(GL11.GL_TRIANGLE_FAN);
|
||||
GL11.glVertex2f(cx, cy);
|
||||
for (int i = 0; i <= 32; i++) {
|
||||
double angle = 2 * Math.PI * i / 32;
|
||||
GL11.glVertex2f(cx + (float) (Math.cos(angle) * radius), cy + (float) (Math.sin(angle) * radius));
|
||||
}
|
||||
GL11.glEnd();
|
||||
}
|
||||
}
|
||||
|
||||
GL11.glEnable(GL11.GL_TEXTURE_2D);
|
||||
GL11.glEnable(GL11.GL_BLEND);
|
||||
for (int i = 0; i < visibleSlots; i++) {
|
||||
String label = String.valueOf(i + 1);
|
||||
float labelScale = slotSizes[i] / 24.0f;
|
||||
if (labelScale < 0.4f) continue;
|
||||
|
||||
int textColor = (i == half) ? 0xFFFFFFFF : 0xAABBBBBB;
|
||||
int textW = fr.getStringWidth(label);
|
||||
|
||||
GL11.glPushMatrix();
|
||||
GL11.glTranslatef(slotCx[i], slotCy[i], 0);
|
||||
GL11.glScalef(labelScale, labelScale, 1);
|
||||
fr.drawString(label, -textW / 2, -fr.FONT_HEIGHT / 2, textColor);
|
||||
GL11.glPopMatrix();
|
||||
}
|
||||
|
||||
boolean altTexture = ConfigClient.AbilityHotbarAltTexture;
|
||||
String modeLabel = altTexture ? "Square" : "Circle";
|
||||
int modeLabelW = fr.getStringWidth(modeLabel);
|
||||
fr.drawStringWithShadow(modeLabel, overlayWidth / 2 - modeLabelW / 2, overlayHeight + 2, 0xAA888888);
|
||||
|
||||
GL11.glDisable(GL11.GL_TEXTURE_2D);
|
||||
GL11.glEnable(GL11.GL_BLEND);
|
||||
GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
|
||||
GL11.glColor4f(0.2f, 0.8f, 0.2f, 0.8f);
|
||||
GL11.glLineWidth(1.0f);
|
||||
GL11.glBegin(GL11.GL_LINE_LOOP);
|
||||
GL11.glVertex2f(0, 0);
|
||||
GL11.glVertex2f(overlayWidth, 0);
|
||||
GL11.glVertex2f(overlayWidth, overlayHeight);
|
||||
GL11.glVertex2f(0, overlayHeight);
|
||||
GL11.glEnd();
|
||||
|
||||
GL11.glColor4f(0.8f, 0.8f, 0.8f, 0.9f);
|
||||
GL11.glBegin(GL11.GL_QUADS);
|
||||
GL11.glVertex2f(overlayWidth - 10, overlayHeight - 10);
|
||||
GL11.glVertex2f(overlayWidth, overlayHeight - 10);
|
||||
GL11.glVertex2f(overlayWidth, overlayHeight);
|
||||
GL11.glVertex2f(overlayWidth - 10, overlayHeight);
|
||||
GL11.glEnd();
|
||||
|
||||
GL11.glDisable(GL11.GL_BLEND);
|
||||
GL11.glEnable(GL11.GL_TEXTURE_2D);
|
||||
GL11.glColor4f(1, 1, 1, 1);
|
||||
|
||||
GL11.glPopMatrix();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void addEditorButtons(List<GuiButton> buttonList) {
|
||||
super.addEditorButtons(buttonList);
|
||||
String orientLabel = ConfigClient.AbilityHotbarHorizontal ? "Horizontal" : "Vertical";
|
||||
buttonList.add(new GuiButton(1, 0, 0, 120, 20, orientLabel));
|
||||
|
||||
String texLabel = ConfigClient.AbilityHotbarAltTexture ? "Square" : "Circle";
|
||||
buttonList.add(new GuiButton(2, 0, 0, 120, 20, texLabel));
|
||||
|
||||
buttonList.add(new GuiButton(3, 0, 0, 120, 20, getTextPositionLabel()));
|
||||
buttonList.add(new GuiButton(4, 0, 0, 120, 20, "Slots: " + ConfigClient.AbilityHotbarVisibleSlots));
|
||||
buttonList.add(new GuiButton(5, 0, 0, 120, 20, ConfigClient.AbilityHotbarShowAlways ? "Show: Always" : "Show: Hold Key"));
|
||||
buttonList.add(new GuiButton(6, 0, 0, 120, 20, getTextVisibilityLabel()));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onEditorButtonPressed(GuiButton button) {
|
||||
if (button.id == 1) {
|
||||
ConfigClient.AbilityHotbarHorizontal = !ConfigClient.AbilityHotbarHorizontal;
|
||||
button.displayString = ConfigClient.AbilityHotbarHorizontal ? "Horizontal" : "Vertical";
|
||||
updateOverlayDimensions();
|
||||
} else if (button.id == 2) {
|
||||
ConfigClient.AbilityHotbarAltTexture = !ConfigClient.AbilityHotbarAltTexture;
|
||||
button.displayString = ConfigClient.AbilityHotbarAltTexture ? "Square" : "Circle";
|
||||
} else if (button.id == 3) {
|
||||
// Toggle between 1 (Above/Left) and 2 (Below/Right)
|
||||
ConfigClient.AbilityHotbarTextPosition = ConfigClient.AbilityHotbarTextPosition == 1 ? 2 : 1;
|
||||
button.displayString = getTextPositionLabel();
|
||||
} else if (button.id == 4) {
|
||||
int current = ConfigClient.AbilityHotbarVisibleSlots;
|
||||
if (current <= 3) ConfigClient.AbilityHotbarVisibleSlots = 5;
|
||||
else if (current <= 5) ConfigClient.AbilityHotbarVisibleSlots = 7;
|
||||
else ConfigClient.AbilityHotbarVisibleSlots = 3;
|
||||
button.displayString = "Slots: " + ConfigClient.AbilityHotbarVisibleSlots;
|
||||
updateOverlayDimensions();
|
||||
} else if (button.id == 5) {
|
||||
ConfigClient.AbilityHotbarShowAlways = !ConfigClient.AbilityHotbarShowAlways;
|
||||
button.displayString = ConfigClient.AbilityHotbarShowAlways ? "Show: Always" : "Show: Hold Key";
|
||||
} else if (button.id == 6) {
|
||||
ConfigClient.AbilityHotbarTextVisibility = (ConfigClient.AbilityHotbarTextVisibility + 1) % 3;
|
||||
button.displayString = getTextVisibilityLabel();
|
||||
} else {
|
||||
super.onEditorButtonPressed(button);
|
||||
}
|
||||
}
|
||||
|
||||
private String getTextPositionLabel() {
|
||||
boolean h = ConfigClient.AbilityHotbarHorizontal;
|
||||
switch (ConfigClient.AbilityHotbarTextPosition) {
|
||||
case 1: return h ? "Text: Above" : "Text: Left";
|
||||
case 2: return h ? "Text: Below" : "Text: Right";
|
||||
default: return h ? "Text: Below" : "Text: Right";
|
||||
}
|
||||
}
|
||||
|
||||
private String getTextVisibilityLabel() {
|
||||
switch (ConfigClient.AbilityHotbarTextVisibility) {
|
||||
case 0: return "Text: Shown";
|
||||
case 1: return "Text: Hidden";
|
||||
case 2: return "Text: Held";
|
||||
default: return "Text: Shown";
|
||||
}
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
// Ability Update & Scroll
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
|
||||
private void updateAbilities() {
|
||||
PlayerData playerData = ClientCacheHandler.playerData;
|
||||
if (playerData == null) return;
|
||||
|
||||
PlayerAbilityHotbarData hotbarData = playerData.hotbarData;
|
||||
if (hotbarData == null) return;
|
||||
|
||||
for (int i = 0; i < TOTAL_SLOTS; i++) {
|
||||
AbilityHotbarData slotData = hotbarData.slots[i];
|
||||
String key = slotData.isEmpty() ? null : slotData.abilityKey;
|
||||
Ability ability = null;
|
||||
IAbilityAction action = null;
|
||||
if (key != null && AbilityController.Instance != null) {
|
||||
if (slotData.isChainKey()) {
|
||||
action = AbilityController.Instance.resolveChainedAbility(slotData.getResolveKey());
|
||||
} else {
|
||||
ability = AbilityController.Instance.resolveAbility(key);
|
||||
action = ability;
|
||||
}
|
||||
if (ability == null && action == null) key = null;
|
||||
}
|
||||
slots[i].setAbility(key, ability, action);
|
||||
}
|
||||
|
||||
// Rebuild active indices: filled slots + one deselect slot (-1)
|
||||
ArrayList<Integer> active = new ArrayList<>();
|
||||
for (int i = 0; i < TOTAL_SLOTS; i++) {
|
||||
if (slots[i].abilityKey != null) {
|
||||
active.add(i);
|
||||
}
|
||||
}
|
||||
active.add(-1); // Deselect slot at the end
|
||||
activeIndices = new int[active.size()];
|
||||
for (int i = 0; i < active.size(); i++) {
|
||||
activeIndices[i] = active.get(i);
|
||||
}
|
||||
|
||||
// Clamp activeCenter
|
||||
if (activeCenter >= activeIndices.length) {
|
||||
activeCenter = 0;
|
||||
}
|
||||
|
||||
// Don't override local selection state while user is scrolling, debounce is pending,
|
||||
// or within the grace period after the last user interaction.
|
||||
// This prevents the server state from fighting the local carousel position.
|
||||
long now = Minecraft.getSystemTime();
|
||||
if (pendingSelectKey != null || scrollOffset != 0f || (now - lastUserCycleTime < USER_CYCLE_GRACE)) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Sync selected state and find which active index is selected
|
||||
if (playerData.abilityData != null) {
|
||||
String selectedKey = playerData.abilityData.getSelectedAbilityKey();
|
||||
boolean foundSelected = false;
|
||||
for (int i = 0; i < TOTAL_SLOTS; i++) {
|
||||
AbilityHotbarData slotData = hotbarData.slots[i];
|
||||
boolean sel = selectedKey != null && !slotData.isEmpty()
|
||||
&& selectedKey.equals(slotData.abilityKey);
|
||||
slots[i].setSelectedState(sel);
|
||||
if (sel) {
|
||||
// Find this slot's position in activeIndices
|
||||
for (int j = 0; j < activeIndices.length; j++) {
|
||||
if (activeIndices[j] == i) {
|
||||
activeCenter = j;
|
||||
foundSelected = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (!foundSelected) {
|
||||
// No ability selected on server — center on deselect slot
|
||||
for (int j = 0; j < activeIndices.length; j++) {
|
||||
if (activeIndices[j] == -1) {
|
||||
activeCenter = j;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private boolean isHudKeyHeld() {
|
||||
if (ClientProxy.AbilityHudKey == null) return false;
|
||||
int keyCode = ClientProxy.AbilityHudKey.getKeyCode();
|
||||
return keyCode != 0 && org.lwjgl.input.Keyboard.isKeyDown(keyCode);
|
||||
}
|
||||
|
||||
public boolean hasAnyAbilities() {
|
||||
PlayerData playerData = ClientCacheHandler.playerData;
|
||||
if (playerData == null || playerData.hotbarData == null) return false;
|
||||
return playerData.hotbarData.hasAnyAbilities();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get cooldown progress for a hotbar slot.
|
||||
* Per-ability cooldown abilities use their own cooldown; others use global.
|
||||
* @return 1.0 = fully on cooldown, 0.0 = ready
|
||||
*/
|
||||
private float getCooldownProgressForSlot(int slotIndex) {
|
||||
PlayerData playerData = ClientCacheHandler.playerData;
|
||||
if (playerData == null || playerData.abilityData == null) return 0f;
|
||||
|
||||
String key = slots[slotIndex].abilityKey;
|
||||
Ability ability = slots[slotIndex].ability;
|
||||
|
||||
if (ability != null && ability.isPerAbilityCooldown()) {
|
||||
return playerData.abilityData.getPerAbilityCooldownProgress(key);
|
||||
} else {
|
||||
return playerData.abilityData.getGlobalCooldownProgress();
|
||||
}
|
||||
}
|
||||
|
||||
public void onCycleNext() {
|
||||
cycle(1);
|
||||
}
|
||||
|
||||
public void onCyclePrev() {
|
||||
cycle(-1);
|
||||
}
|
||||
|
||||
private void cycle(int direction) {
|
||||
if (!enabled) return;
|
||||
if (mc.thePlayer == null || mc.currentScreen != null) return;
|
||||
if (activeIndices.length == 0) return;
|
||||
|
||||
activeCenter = ((activeCenter + direction) % activeIndices.length + activeIndices.length) % activeIndices.length;
|
||||
scrollOffset = direction;
|
||||
long now = Minecraft.getSystemTime();
|
||||
scrollStartTime = now;
|
||||
lastUserCycleTime = now;
|
||||
|
||||
int rawSlotIndex = activeIndices[activeCenter];
|
||||
|
||||
// Update selection states locally
|
||||
for (int i = 0; i < TOTAL_SLOTS; i++) {
|
||||
slots[i].setSelectedState(i == rawSlotIndex);
|
||||
}
|
||||
|
||||
// Debounce: queue the selection, don't send immediately
|
||||
String keyToSend = rawSlotIndex >= 0 && slots[rawSlotIndex].abilityKey != null
|
||||
? slots[rawSlotIndex].abilityKey : "";
|
||||
pendingSelectKey = keyToSend;
|
||||
pendingSelectTime = Minecraft.getSystemTime();
|
||||
}
|
||||
|
||||
private void updateScrollAnimation() {
|
||||
if (scrollOffset == 0f) return;
|
||||
|
||||
long now = Minecraft.getSystemTime();
|
||||
float t = (float) (now - scrollStartTime) / SCROLL_DURATION;
|
||||
t = Math.min(t, 1f);
|
||||
|
||||
float eased = easeOutCubic(t);
|
||||
float initialOffset = scrollOffset < 0 ? -1f : 1f;
|
||||
scrollOffset = initialOffset * (1f - eased);
|
||||
|
||||
if (t >= 1f) scrollOffset = 0f;
|
||||
}
|
||||
|
||||
private float easeOutCubic(float x) {
|
||||
float v = 1 - x;
|
||||
return 1 - v * v * v;
|
||||
}
|
||||
|
||||
public void refresh() {
|
||||
updateAbilities();
|
||||
lastUpdateTime = Minecraft.getSystemTime();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,302 @@
|
||||
package noppes.npcs.client.gui.hud.ability;
|
||||
|
||||
import cpw.mods.fml.relauncher.Side;
|
||||
import cpw.mods.fml.relauncher.SideOnly;
|
||||
import kamkeel.npcs.controllers.data.ability.Ability;
|
||||
import kamkeel.npcs.controllers.data.ability.ChainedAbility;
|
||||
import kamkeel.npcs.controllers.data.ability.IAbilityAction;
|
||||
import net.minecraft.client.Minecraft;
|
||||
import net.minecraft.client.gui.FontRenderer;
|
||||
import net.minecraft.client.gui.Gui;
|
||||
import net.minecraft.client.gui.ScaledResolution;
|
||||
import noppes.npcs.config.ConfigClient;
|
||||
import noppes.npcs.controllers.data.PlayerData;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
|
||||
@SideOnly(Side.CLIENT)
|
||||
public class AbilityHotbarSlotRenderer extends Gui {
|
||||
private static final int CIRCLE_SEGMENTS = 32;
|
||||
private static final long NAME_FADE_DURATION = 180;
|
||||
|
||||
public int index;
|
||||
public String abilityKey = null;
|
||||
public Ability ability = null;
|
||||
public IAbilityAction action = null;
|
||||
private AbilityIcon icon = null;
|
||||
|
||||
public boolean isSelected = false;
|
||||
public float nameAlpha = 0f;
|
||||
private boolean nameFadingIn = false;
|
||||
private long nameFadeStartTime = 0;
|
||||
|
||||
public AbilityHotbarSlotRenderer(int index) {
|
||||
this.index = index;
|
||||
}
|
||||
|
||||
public void setAbility(String key, Ability ability, IAbilityAction action) {
|
||||
this.abilityKey = key;
|
||||
this.ability = ability;
|
||||
this.action = action;
|
||||
if (ability != null) {
|
||||
this.icon = AbilityIcon.fromAbility(ability);
|
||||
} else if (action instanceof ChainedAbility) {
|
||||
this.icon = AbilityIcon.fromChainedAbility((ChainedAbility) action);
|
||||
} else {
|
||||
this.icon = null;
|
||||
}
|
||||
}
|
||||
|
||||
public void drawCarousel(Minecraft mc, ScaledResolution sr, float cooldownProgress,
|
||||
int cx, int cy, int size, boolean isCenter, float slotAlpha,
|
||||
boolean showText) {
|
||||
float nameAlpha = this.nameAlpha;
|
||||
boolean isHorizontal = ConfigClient.AbilityHotbarHorizontal;
|
||||
if (size <= 0 || slotAlpha <= 0) return;
|
||||
float radius = size / 2f;
|
||||
float baseAlpha = isCenter ? 0.9f : 0.6f;
|
||||
float alpha = baseAlpha * slotAlpha;
|
||||
|
||||
GL11.glPushMatrix();
|
||||
GL11.glTranslatef(cx, cy, 0);
|
||||
|
||||
boolean altTexture = ConfigClient.AbilityHotbarAltTexture;
|
||||
|
||||
if (altTexture) {
|
||||
drawRoundedRect(-radius, -radius, radius, radius, 0.6f, 0.6f, 0.6f, 0.75f * alpha, false);
|
||||
if (isCenter) {
|
||||
drawRoundedRect(-radius, -radius, radius, radius, 0.8f, 0.8f, 0.2f, alpha, true);
|
||||
} else {
|
||||
drawRoundedRect(-radius, -radius, radius, radius, 0.4f, 0.4f, 0.4f, alpha * 0.8f, true);
|
||||
}
|
||||
} else {
|
||||
if (isCenter) {
|
||||
drawCircle(radius, 0.8f, 0.8f, 0.2f, 0.66f * alpha, false);
|
||||
drawCircle(radius, 0.8f, 0.8f, 0.2f, alpha, true);
|
||||
} else {
|
||||
drawCircle(radius, 1f, 1f, 1f, 0.66f * alpha, false);
|
||||
drawCircle(radius, 0.4f, 0.4f, 0.4f, alpha * 0.8f, true);
|
||||
}
|
||||
}
|
||||
|
||||
// Ability icon
|
||||
if (icon != null) {
|
||||
GL11.glPushMatrix();
|
||||
float targetSize = size * 0.55f;
|
||||
float iconNaturalSize = Math.max(icon.width, icon.height);
|
||||
if (iconNaturalSize <= 0) iconNaturalSize = 16f;
|
||||
float iconScale = targetSize / iconNaturalSize;
|
||||
GL11.glScalef(iconScale, iconScale, 1);
|
||||
GL11.glColor4f(1, 1, 1, slotAlpha);
|
||||
icon.draw(getToggleState());
|
||||
GL11.glColor4f(1, 1, 1, 1);
|
||||
GL11.glPopMatrix();
|
||||
}
|
||||
|
||||
// Cooldown overlay (all slots)
|
||||
if (cooldownProgress > 0 && abilityKey != null) {
|
||||
drawCooldownOverlay(radius, cooldownProgress, altTexture, slotAlpha);
|
||||
}
|
||||
|
||||
GL11.glPopMatrix();
|
||||
|
||||
// Ability name on center slot (respects text position and visibility config)
|
||||
int textPos = ConfigClient.AbilityHotbarTextPosition;
|
||||
if (showText && isCenter && action != null && nameAlpha > 0) {
|
||||
FontRenderer fr = mc.fontRenderer;
|
||||
String name = getAbilityName();
|
||||
if (name != null && !name.isEmpty()) {
|
||||
int a = (int) (nameAlpha * 255) & 0xFF;
|
||||
int nameColor = (a << 24) | (getNameColor() & 0x00FFFFFF);
|
||||
int nameX, nameY;
|
||||
if (isHorizontal) {
|
||||
nameX = cx - fr.getStringWidth(name) / 2;
|
||||
if (textPos == 1) {
|
||||
nameY = cy - (int) radius - fr.FONT_HEIGHT - 2; // Above
|
||||
} else {
|
||||
nameY = cy + (int) radius + 2; // Below
|
||||
}
|
||||
} else {
|
||||
nameY = cy - fr.FONT_HEIGHT / 2;
|
||||
if (textPos == 1) {
|
||||
nameX = cx - (int) radius - fr.getStringWidth(name) - 4; // Left
|
||||
} else {
|
||||
nameX = cx + (int) radius + 4; // Right
|
||||
}
|
||||
}
|
||||
GL11.glEnable(GL11.GL_BLEND);
|
||||
GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
|
||||
GL11.glColor4f(1, 1, 1, nameAlpha);
|
||||
fr.drawStringWithShadow(name, nameX, nameY, nameColor);
|
||||
GL11.glDisable(GL11.GL_BLEND);
|
||||
GL11.glColor4f(1, 1, 1, 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void drawRoundedRect(float x1, float y1, float x2, float y2,
|
||||
float r, float g, float b, float a, boolean outline) {
|
||||
GL11.glDisable(GL11.GL_TEXTURE_2D);
|
||||
GL11.glDisable(GL11.GL_CULL_FACE);
|
||||
GL11.glEnable(GL11.GL_BLEND);
|
||||
GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
|
||||
GL11.glColor4f(r, g, b, a);
|
||||
|
||||
if (outline) {
|
||||
GL11.glLineWidth(2.0f);
|
||||
GL11.glBegin(GL11.GL_LINE_LOOP);
|
||||
} else {
|
||||
GL11.glBegin(GL11.GL_QUADS);
|
||||
}
|
||||
|
||||
GL11.glVertex2f(x1, y1);
|
||||
GL11.glVertex2f(x2, y1);
|
||||
GL11.glVertex2f(x2, y2);
|
||||
GL11.glVertex2f(x1, y2);
|
||||
GL11.glEnd();
|
||||
|
||||
GL11.glEnable(GL11.GL_TEXTURE_2D);
|
||||
GL11.glEnable(GL11.GL_CULL_FACE);
|
||||
GL11.glColor4f(1, 1, 1, 1);
|
||||
}
|
||||
|
||||
private void drawCircle(float radius, float r, float g, float b, float a, boolean outline) {
|
||||
GL11.glDisable(GL11.GL_TEXTURE_2D);
|
||||
GL11.glDisable(GL11.GL_CULL_FACE);
|
||||
GL11.glEnable(GL11.GL_BLEND);
|
||||
GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
|
||||
GL11.glColor4f(r, g, b, a);
|
||||
|
||||
if (outline) {
|
||||
GL11.glLineWidth(1.5f);
|
||||
GL11.glBegin(GL11.GL_LINE_LOOP);
|
||||
} else {
|
||||
GL11.glBegin(GL11.GL_TRIANGLE_FAN);
|
||||
GL11.glVertex2f(0, 0);
|
||||
}
|
||||
|
||||
for (int i = 0; i <= CIRCLE_SEGMENTS; i++) {
|
||||
double angle = 2 * Math.PI * i / CIRCLE_SEGMENTS;
|
||||
GL11.glVertex2f((float) (Math.cos(angle) * radius), (float) (Math.sin(angle) * radius));
|
||||
}
|
||||
GL11.glEnd();
|
||||
|
||||
GL11.glDisable(GL11.GL_BLEND);
|
||||
GL11.glEnable(GL11.GL_TEXTURE_2D);
|
||||
GL11.glEnable(GL11.GL_CULL_FACE);
|
||||
GL11.glColor4f(1, 1, 1, 1);
|
||||
}
|
||||
|
||||
/**
|
||||
* Draw a cooldown overlay on the slot.
|
||||
* progress: 1.0 = fully on cooldown (just started), 0.0 = ready
|
||||
* Renders a filled shape covering the entire slot that transitions from red to green.
|
||||
*/
|
||||
private void drawCooldownOverlay(float radius, float progress, boolean altTexture, float slotAlpha) {
|
||||
progress = Math.min(1f, Math.max(0f, progress));
|
||||
if (progress <= 0f) return;
|
||||
|
||||
// Color: red (progress=1.0) → orange → yellow-green → green (progress→0.0)
|
||||
float cr, cg, cb;
|
||||
if (progress > 0.5f) {
|
||||
float t = (progress - 0.5f) * 2f; // 1.0 at progress=1.0, 0.0 at progress=0.5
|
||||
cr = 0.8f;
|
||||
cg = 0.15f + 0.25f * (1f - t); // 0.15 → 0.4
|
||||
cb = 0.1f;
|
||||
} else if (progress > 0.2f) {
|
||||
float t = (progress - 0.2f) / 0.3f; // 1.0 at 0.5, 0.0 at 0.2
|
||||
cr = 0.8f * t + 0.3f * (1f - t); // 0.8 → 0.3
|
||||
cg = 0.4f * t + 0.7f * (1f - t); // 0.4 → 0.7
|
||||
cb = 0.1f;
|
||||
} else {
|
||||
float t = progress / 0.2f; // 1.0 at 0.2, 0.0 at 0.0
|
||||
cr = 0.3f * t + 0.1f * (1f - t); // 0.3 → 0.1
|
||||
cg = 0.7f * t + 0.7f * (1f - t); // 0.7
|
||||
cb = 0.1f + 0.1f * (1f - t); // 0.1 → 0.2
|
||||
}
|
||||
|
||||
// Semi-transparent so icon is visible underneath; fade out near end
|
||||
float overlayAlpha = 0.5f * slotAlpha * Math.min(1f, progress * 3f);
|
||||
|
||||
GL11.glDisable(GL11.GL_TEXTURE_2D);
|
||||
GL11.glDisable(GL11.GL_CULL_FACE);
|
||||
GL11.glEnable(GL11.GL_BLEND);
|
||||
GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
|
||||
GL11.glColor4f(cr, cg, cb, overlayAlpha);
|
||||
|
||||
if (altTexture) {
|
||||
// Square slot: full filled rectangle
|
||||
GL11.glBegin(GL11.GL_QUADS);
|
||||
GL11.glVertex2f(-radius, -radius);
|
||||
GL11.glVertex2f(radius, -radius);
|
||||
GL11.glVertex2f(radius, radius);
|
||||
GL11.glVertex2f(-radius, radius);
|
||||
GL11.glEnd();
|
||||
} else {
|
||||
// Circle slot: full filled circle
|
||||
GL11.glBegin(GL11.GL_TRIANGLE_FAN);
|
||||
GL11.glVertex2f(0, 0);
|
||||
for (int i = 0; i <= CIRCLE_SEGMENTS; i++) {
|
||||
double angle = 2 * Math.PI * i / CIRCLE_SEGMENTS;
|
||||
GL11.glVertex2f((float) (Math.cos(angle) * radius), (float) (Math.sin(angle) * radius));
|
||||
}
|
||||
GL11.glEnd();
|
||||
}
|
||||
|
||||
GL11.glDisable(GL11.GL_BLEND);
|
||||
GL11.glEnable(GL11.GL_TEXTURE_2D);
|
||||
GL11.glEnable(GL11.GL_CULL_FACE);
|
||||
GL11.glColor4f(1, 1, 1, 1);
|
||||
}
|
||||
|
||||
private String getAbilityName() {
|
||||
if (ability != null) {
|
||||
int state = getToggleState();
|
||||
if (state > 0) {
|
||||
String label = ability.getToggleStateLabel(state);
|
||||
if (label != null) return label;
|
||||
}
|
||||
return ability.getDisplayName();
|
||||
}
|
||||
if (action instanceof ChainedAbility) return ((ChainedAbility) action).getDisplayName();
|
||||
return action != null ? action.getName() : "";
|
||||
}
|
||||
|
||||
private int getToggleState() {
|
||||
if (ability == null || !ability.isToggleable()) return 0;
|
||||
Minecraft mc = Minecraft.getMinecraft();
|
||||
if (mc.thePlayer == null) return 0;
|
||||
PlayerData playerData = PlayerData.get(mc.thePlayer);
|
||||
if (playerData == null || playerData.abilityData == null) return 0;
|
||||
return playerData.abilityData.getToggleState(abilityKey);
|
||||
}
|
||||
|
||||
private int getNameColor() {
|
||||
if (ability != null && ability.isToggleable()) {
|
||||
return getToggleState() > 0 ? 0xFF55FF55 : 0xFFFF5555;
|
||||
}
|
||||
return 0xFFFFFFFF;
|
||||
}
|
||||
|
||||
public void setSelectedState(boolean newSelectState) {
|
||||
if (!isSelected && newSelectState) {
|
||||
nameFadingIn = true;
|
||||
nameFadeStartTime = Minecraft.getSystemTime();
|
||||
}
|
||||
if (isSelected && !newSelectState) {
|
||||
nameFadingIn = false;
|
||||
nameFadeStartTime = Minecraft.getSystemTime();
|
||||
}
|
||||
isSelected = newSelectState;
|
||||
}
|
||||
|
||||
public void updateNameFade() {
|
||||
long now = Minecraft.getSystemTime();
|
||||
float t = (float) (now - nameFadeStartTime) / NAME_FADE_DURATION;
|
||||
t = Math.min(1f, Math.max(0f, t));
|
||||
if (nameFadingIn) {
|
||||
nameAlpha = t;
|
||||
} else {
|
||||
nameAlpha = 1f - t;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,140 @@
|
||||
package noppes.npcs.client.gui.hud.ability;
|
||||
|
||||
import cpw.mods.fml.relauncher.Side;
|
||||
import cpw.mods.fml.relauncher.SideOnly;
|
||||
import kamkeel.npcs.controllers.data.ability.Ability;
|
||||
import kamkeel.npcs.controllers.data.ability.AbilityIconData;
|
||||
import kamkeel.npcs.controllers.data.ability.ChainedAbility;
|
||||
import kamkeel.npcs.controllers.data.ability.IAbilityAction;
|
||||
import net.minecraft.client.Minecraft;
|
||||
import net.minecraft.client.gui.Gui;
|
||||
import net.minecraft.client.renderer.Tessellator;
|
||||
import net.minecraft.client.renderer.texture.TextureManager;
|
||||
import net.minecraft.nbt.NBTTagCompound;
|
||||
import net.minecraft.util.ResourceLocation;
|
||||
import noppes.npcs.client.ClientCacheHandler;
|
||||
import noppes.npcs.client.renderer.ImageData;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
|
||||
@SideOnly(Side.CLIENT)
|
||||
public class AbilityIcon extends Gui {
|
||||
private static final ResourceLocation FALLBACK_TEXTURE = new ResourceLocation("customnpcs", "textures/gui/ability_fallback.png");
|
||||
|
||||
// Backed by AbilityIconData
|
||||
private final AbilityIconData data;
|
||||
public int width;
|
||||
public int height;
|
||||
|
||||
private AbilityIcon(AbilityIconData data) {
|
||||
this.data = data;
|
||||
this.width = data.width;
|
||||
this.height = data.height;
|
||||
}
|
||||
|
||||
public static AbilityIcon fromAbility(Ability ability) {
|
||||
if (ability != null) {
|
||||
return new AbilityIcon(AbilityIconData.fromAbility(ability));
|
||||
}
|
||||
return fromDefaults();
|
||||
}
|
||||
|
||||
public static AbilityIcon fromChainedAbility(ChainedAbility chain) {
|
||||
if (chain != null) {
|
||||
return new AbilityIcon(AbilityIconData.fromChainedAbility(chain));
|
||||
}
|
||||
return fromDefaults();
|
||||
}
|
||||
|
||||
public static AbilityIcon fromAction(IAbilityAction action) {
|
||||
if (action instanceof Ability) return fromAbility((Ability) action);
|
||||
if (action instanceof ChainedAbility) return fromChainedAbility((ChainedAbility) action);
|
||||
return fromDefaults();
|
||||
}
|
||||
|
||||
private static AbilityIcon fromDefaults() {
|
||||
return new AbilityIcon(AbilityIconData.fromCustomData(new NBTTagCompound()));
|
||||
}
|
||||
|
||||
public void draw() {
|
||||
draw(0);
|
||||
}
|
||||
|
||||
public void draw(int state) {
|
||||
TextureManager renderEngine = Minecraft.getMinecraft().renderEngine;
|
||||
|
||||
ImageData imageData = null;
|
||||
if (data.hasTexture()) {
|
||||
imageData = ClientCacheHandler.getImageData(data.texture);
|
||||
}
|
||||
|
||||
GL11.glPushMatrix();
|
||||
GL11.glColor4f(1, 1, 1, 1);
|
||||
|
||||
Tessellator t;
|
||||
|
||||
if (imageData == null || !imageData.imageLoaded()) {
|
||||
GL11.glScalef(1.0f, 1.0f, 1);
|
||||
renderEngine.bindTexture(FALLBACK_TEXTURE);
|
||||
t = getFallbackTessellator();
|
||||
} else {
|
||||
GL11.glScalef(data.scale, data.scale, 1);
|
||||
renderEngine.bindTexture(imageData.getLocation());
|
||||
t = getTessellator(imageData, state);
|
||||
}
|
||||
|
||||
t.draw();
|
||||
GL11.glPopMatrix();
|
||||
}
|
||||
|
||||
private Tessellator getTessellator(ImageData imageData, int state) {
|
||||
float hw = data.width / 2f;
|
||||
float hh = data.height / 2f;
|
||||
|
||||
float texW = imageData.getTotalWidth();
|
||||
float texH = imageData.getTotalHeight();
|
||||
|
||||
int ix = data.getIconXForState(state);
|
||||
int iy = data.getIconYForState(state);
|
||||
|
||||
float u1 = ix / texW;
|
||||
float v1 = iy / texH;
|
||||
float u2 = (ix + data.width) / texW;
|
||||
float v2 = (iy + data.height) / texH;
|
||||
|
||||
Tessellator t = Tessellator.instance;
|
||||
t.startDrawingQuads();
|
||||
t.addVertexWithUV(-hw, hh, zLevel, u1, v2);
|
||||
t.addVertexWithUV(hw, hh, zLevel, u2, v2);
|
||||
t.addVertexWithUV(hw, -hh, zLevel, u2, v1);
|
||||
t.addVertexWithUV(-hw, -hh, zLevel, u1, v1);
|
||||
return t;
|
||||
}
|
||||
|
||||
private Tessellator getFallbackTessellator() {
|
||||
float hw = 16f;
|
||||
float hh = 16f;
|
||||
|
||||
Tessellator t = Tessellator.instance;
|
||||
t.startDrawingQuads();
|
||||
t.addVertexWithUV(-hw, hh, zLevel, 0, 1);
|
||||
t.addVertexWithUV(hw, hh, zLevel, 1, 1);
|
||||
t.addVertexWithUV(hw, -hh, zLevel, 1, 0);
|
||||
t.addVertexWithUV(-hw, -hh, zLevel, 0, 0);
|
||||
return t;
|
||||
}
|
||||
|
||||
public boolean hasTexture() {
|
||||
return data.hasTexture();
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the approximate visual size (max dimension) that draw() produces.
|
||||
* Textured: max(width,height) * scale. Fallback: 32.
|
||||
*/
|
||||
public float getDrawSize() {
|
||||
if (data.hasTexture()) {
|
||||
return Math.max(width, height) * data.scale;
|
||||
}
|
||||
return 32f;
|
||||
}
|
||||
}
|
||||
@@ -88,10 +88,16 @@ public class GuiAuctionTrades extends GuiAuctionInterface implements IGuiData {
|
||||
AuctionListing listing = tradesContainer.getListingAt(slot);
|
||||
AuctionClaim claim = tradesContainer.getClaimAt(slot);
|
||||
|
||||
if (listing != null && tradesContainer.isSellingAt(slot) && mouseButton == 1) {
|
||||
// Right-click on own listing = show cancel
|
||||
setPending(slot, PendingOp.CANCEL);
|
||||
NoppesUtil.clickSound();
|
||||
if (listing != null && tradesContainer.isSellingAt(slot)) {
|
||||
if (mouseButton == 0) {
|
||||
// Left-click on own listing = view details
|
||||
AuctionActionPacket.openBidding(listing.id);
|
||||
NoppesUtil.clickSound();
|
||||
} else if (mouseButton == 1) {
|
||||
// Right-click on own listing = show cancel
|
||||
setPending(slot, PendingOp.CANCEL);
|
||||
NoppesUtil.clickSound();
|
||||
}
|
||||
} else if (listing != null && tradesContainer.isBiddingAt(slot) && mouseButton == 0) {
|
||||
// Left-click on active bid = open bidding GUI to increase bid
|
||||
AuctionActionPacket.openBidding(listing.id);
|
||||
@@ -315,16 +321,13 @@ public class GuiAuctionTrades extends GuiAuctionInterface implements IGuiData {
|
||||
AuctionListing listing = tradesContainer.getListingAt(slot);
|
||||
AuctionClaim claim = tradesContainer.getClaimAt(slot);
|
||||
|
||||
if (listing != null) {
|
||||
if (tradesContainer.isSellingAt(slot)) {
|
||||
tooltip.add(EnumChatFormatting.GOLD + StatCollector.translateToLocal("auction.trades.activeListing"));
|
||||
tooltip.add(EnumChatFormatting.YELLOW + StatCollector.translateToLocal("auction.trades.rightClickToCancel"));
|
||||
} else if (tradesContainer.isBiddingAt(slot)) {
|
||||
tooltip.add(EnumChatFormatting.AQUA + StatCollector.translateToLocal("auction.trades.activeBid"));
|
||||
tooltip.add(EnumChatFormatting.GRAY + StatCollector.translateToLocal("auction.trades.winningBid"));
|
||||
tooltip.add(EnumChatFormatting.YELLOW + StatCollector.translateToLocal("auction.trades.leftClickToIncrease"));
|
||||
}
|
||||
} else if (claim != null) {
|
||||
// Slots with items have tooltips handled by AuctionTooltipHandler via ItemTooltipEvent
|
||||
if (listing != null) return;
|
||||
if (claim != null && (claim.type == EnumClaimType.ITEM ||
|
||||
(claim.type == EnumClaimType.REFUND && claim.item != null))) return;
|
||||
|
||||
// Non-item slots (currency claims, refund without item, unavailable)
|
||||
if (claim != null) {
|
||||
switch (claim.type) {
|
||||
case CURRENCY:
|
||||
tooltip.add(EnumChatFormatting.GREEN + StatCollector.translateToLocal("auction.trades.soldClaim"));
|
||||
@@ -342,20 +345,6 @@ public class GuiAuctionTrades extends GuiAuctionInterface implements IGuiData {
|
||||
tooltip.add(EnumChatFormatting.GRAY + StatCollector.translateToLocal("auction.trades.outbidBy") + ": " + EnumChatFormatting.AQUA + claim.otherPlayerName);
|
||||
}
|
||||
tooltip.add(EnumChatFormatting.GOLD + String.format("%,d", claim.currency) + " " + AuctionClientConfig.getCurrencyName());
|
||||
// Show rebid option if item is present (active listing)
|
||||
if (claim.item != null) {
|
||||
tooltip.add("");
|
||||
tooltip.add(EnumChatFormatting.GREEN + StatCollector.translateToLocal("auction.trades.leftClickRebid"));
|
||||
tooltip.add(EnumChatFormatting.YELLOW + StatCollector.translateToLocal("auction.trades.rightClickRefund"));
|
||||
return; // Skip the generic claim message
|
||||
}
|
||||
break;
|
||||
case ITEM:
|
||||
if (claim.isReturned) {
|
||||
tooltip.add(EnumChatFormatting.RED + StatCollector.translateToLocal("auction.trades.expiredClaim"));
|
||||
} else {
|
||||
tooltip.add(EnumChatFormatting.GREEN + StatCollector.translateToLocal("auction.trades.wonClaim"));
|
||||
}
|
||||
break;
|
||||
}
|
||||
tooltip.add(EnumChatFormatting.YELLOW + StatCollector.translateToLocal("auction.trades.leftClickToClaim"));
|
||||
|
||||
File diff suppressed because it is too large.
Load diff
@@ -73,6 +73,14 @@ public class GuiCNPCInventory extends GuiNPCInterface {
|
||||
addSideButton(profileButton);
|
||||
}
|
||||
|
||||
y += 21;
|
||||
GuiMenuSideButton abilitiesButton = new GuiMenuSideButton(-105, guiLeft + xSize + 37, this.guiTop + y, 22, 22, "");
|
||||
abilitiesButton.rightSided = true;
|
||||
abilitiesButton.active = activeTab == -105;
|
||||
abilitiesButton.renderIconPosX = 80;
|
||||
abilitiesButton.renderResource = specialIcons;
|
||||
addSideButton(abilitiesButton);
|
||||
|
||||
y += 21;
|
||||
GuiMenuSideButton clientButton = new GuiMenuSideButton(-103, guiLeft + xSize + 37, this.guiTop + y, 22, 22, "");
|
||||
clientButton.rightSided = true;
|
||||
@@ -154,6 +162,10 @@ public class GuiCNPCInventory extends GuiNPCInterface {
|
||||
activeTab = -104;
|
||||
mc.displayGuiScreen(new GuiProfiles());
|
||||
}
|
||||
if (guibutton.id == -105 && activeTab != -105) {
|
||||
activeTab = -105;
|
||||
mc.displayGuiScreen(new GuiAbilities());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+155
@@ -0,0 +1,155 @@
|
||||
package noppes.npcs.client.gui.player.inventory;
|
||||
|
||||
import kamkeel.npcs.controllers.AbilityController;
|
||||
import kamkeel.npcs.controllers.data.ability.Ability;
|
||||
import kamkeel.npcs.controllers.data.ability.ChainedAbility;
|
||||
import net.minecraft.client.gui.GuiButton;
|
||||
import noppes.npcs.client.ClientCacheHandler;
|
||||
import noppes.npcs.client.gui.util.GuiCustomScroll;
|
||||
import noppes.npcs.client.gui.util.GuiNpcButton;
|
||||
import noppes.npcs.client.gui.util.GuiNpcTextField;
|
||||
import noppes.npcs.client.gui.util.ICustomScrollListener;
|
||||
import noppes.npcs.client.gui.util.ITextfieldListener;
|
||||
import noppes.npcs.client.gui.util.SubGuiInterface;
|
||||
import noppes.npcs.controllers.data.AbilityHotbarData;
|
||||
import noppes.npcs.controllers.data.PlayerData;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* SubGui for selecting an ability to assign to a hotbar slot.
|
||||
*/
|
||||
public class SubGuiSelectAbilityForSlot extends SubGuiInterface implements ICustomScrollListener, ITextfieldListener {
|
||||
private HashMap<String, String> displayToKey = new HashMap<>();
|
||||
private GuiCustomScroll scrollAbilities;
|
||||
private String selected = null;
|
||||
private String search = "";
|
||||
|
||||
public boolean confirmed = false;
|
||||
public String selectedAbilityKey = null;
|
||||
public int slotIndex;
|
||||
public boolean removeAbility = false;
|
||||
|
||||
public SubGuiSelectAbilityForSlot(int slotIndex) {
|
||||
this.slotIndex = slotIndex;
|
||||
this.closeOnEsc = true;
|
||||
this.drawDefaultBackground = true;
|
||||
guiLeft -= 10;
|
||||
xSize = 256 + 10;
|
||||
this.setBackground("menubg.png");
|
||||
}
|
||||
|
||||
@Override
|
||||
public void initGui() {
|
||||
super.initGui();
|
||||
guiTop += 10;
|
||||
|
||||
if (scrollAbilities == null) {
|
||||
scrollAbilities = new GuiCustomScroll(this, 0, 0);
|
||||
scrollAbilities.setSize(177, 185);
|
||||
}
|
||||
|
||||
scrollAbilities.guiLeft = guiLeft + 4;
|
||||
scrollAbilities.guiTop = guiTop + 4;
|
||||
addScroll(scrollAbilities);
|
||||
|
||||
loadAbilities();
|
||||
scrollAbilities.setList(getSearchList());
|
||||
|
||||
addTextField(new GuiNpcTextField(55, this, fontRendererObj, guiLeft + 4, guiTop + 192, 177, 20, search));
|
||||
|
||||
addButton(new GuiNpcButton(0, guiLeft + 183, guiTop + 4, 79, 20, "gui.add"));
|
||||
addButton(new GuiNpcButton(1, guiLeft + 183, guiTop + 26, 79, 20, "gui.cancel"));
|
||||
addButton(new GuiNpcButton(2, guiLeft + 183, guiTop + 88, 79, 20, "gui.remove"));
|
||||
}
|
||||
|
||||
private void loadAbilities() {
|
||||
displayToKey.clear();
|
||||
PlayerData playerData = ClientCacheHandler.playerData;
|
||||
if (playerData == null || playerData.abilityData == null) {
|
||||
return;
|
||||
}
|
||||
|
||||
List<String> abilities = playerData.abilityData.getUnlockedAbilityList();
|
||||
for (String key : abilities) {
|
||||
String displayName;
|
||||
if (key.startsWith(AbilityHotbarData.CHAIN_PREFIX)) {
|
||||
String chainKey = key.substring(AbilityHotbarData.CHAIN_PREFIX.length());
|
||||
ChainedAbility chain = AbilityController.Instance != null ?
|
||||
AbilityController.Instance.resolveChainedAbility(chainKey) : null;
|
||||
displayName = chain != null ? "\u00A76\u2726 " + chain.getDisplayName() : key;
|
||||
} else {
|
||||
Ability ability = AbilityController.Instance != null ?
|
||||
AbilityController.Instance.resolveAbility(key) : null;
|
||||
displayName = ability != null ? ability.getDisplayName() : key;
|
||||
}
|
||||
displayToKey.put(displayName, key);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void actionPerformed(GuiButton button) {
|
||||
int id = button.id;
|
||||
|
||||
if (id == 0 && selected != null) {
|
||||
confirmed = true;
|
||||
selectedAbilityKey = displayToKey.get(selected);
|
||||
this.close();
|
||||
}
|
||||
if (id == 1) {
|
||||
this.close();
|
||||
}
|
||||
if (id == 2) {
|
||||
this.removeAbility = true;
|
||||
this.close();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void customScrollClicked(int i, int i1, int i2, GuiCustomScroll guiCustomScroll) {
|
||||
if (guiCustomScroll == scrollAbilities)
|
||||
selected = scrollAbilities.getSelected();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void customScrollDoubleClicked(String selection, GuiCustomScroll guiCustomScroll) {
|
||||
if (guiCustomScroll == scrollAbilities && selection != null) {
|
||||
confirmed = true;
|
||||
selectedAbilityKey = displayToKey.get(selection);
|
||||
this.close();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void unFocused(GuiNpcTextField guiNpcTextField) {
|
||||
}
|
||||
|
||||
@Override
|
||||
public void keyTyped(char c, int i) {
|
||||
super.keyTyped(c, i);
|
||||
if (getTextField(55) != null) {
|
||||
if (getTextField(55).isFocused()) {
|
||||
if (search.equals(getTextField(55).getText()))
|
||||
return;
|
||||
search = getTextField(55).getText().toLowerCase();
|
||||
scrollAbilities.resetScroll();
|
||||
scrollAbilities.setList(getSearchList());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private List<String> getSearchList() {
|
||||
if (search.isEmpty()) {
|
||||
return new ArrayList<>(displayToKey.keySet());
|
||||
}
|
||||
|
||||
List<String> list = new ArrayList<>();
|
||||
for (String name : displayToKey.keySet()) {
|
||||
if (name.toLowerCase().contains(search))
|
||||
list.add(name);
|
||||
}
|
||||
return list;
|
||||
}
|
||||
}
|
||||
@@ -80,9 +80,10 @@ public class GuiEffectBar extends GuiScreen {
|
||||
int iconWidth = entry.effect.getWidth();
|
||||
int iconHeight = entry.effect.getHeight();
|
||||
int texWidth = imageData.getTotalWidth();
|
||||
int texHeight = imageData.getTotalHeight();
|
||||
|
||||
// Use iconYOffset to vertically center the icon
|
||||
func_152125_a(x + 2, drawY + iconYOffset, iconU, iconV, iconWidth, iconHeight, iconRenderSize, iconRenderSize, texWidth, texWidth);
|
||||
func_152125_a(x + 2, drawY + iconYOffset, iconU, iconV, iconWidth, iconHeight, iconRenderSize, iconRenderSize, texWidth, texHeight);
|
||||
|
||||
GL11.glDisable(GL11.GL_DEPTH_TEST);
|
||||
Minecraft.getMinecraft().getTextureManager().bindTexture(specialIcons);
|
||||
@@ -190,7 +191,7 @@ public class GuiEffectBar extends GuiScreen {
|
||||
if (imageData != null && imageData.imageLoaded()) {
|
||||
GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
|
||||
imageData.bindTexture();
|
||||
func_152125_a(tooltipX + (maxWidth - iconSize) / 2, textY + 4, hoveredEffect.iconX, hoveredEffect.iconY, hoveredEffect.getWidth(), hoveredEffect.getHeight(), iconSize, iconSize, imageData.getTotalWidth(), imageData.getTotalWidth());
|
||||
func_152125_a(tooltipX + (maxWidth - iconSize) / 2, textY + 4, hoveredEffect.iconX, hoveredEffect.iconY, hoveredEffect.getWidth(), hoveredEffect.getHeight(), iconSize, iconSize, imageData.getTotalWidth(), imageData.getTotalHeight());
|
||||
}
|
||||
|
||||
textureManager.bindTexture(specialIcons);
|
||||
|
||||
@@ -24,10 +24,21 @@ public class GuiMenuTopButton extends GuiNpcButton {
|
||||
height = 20;
|
||||
}
|
||||
|
||||
/**
|
||||
* Place to the RIGHT of the given button.
|
||||
*/
|
||||
public GuiMenuTopButton(int i, GuiButton parent, String s) {
|
||||
this(i, parent.xPosition + parent.width, parent.yPosition, s);
|
||||
}
|
||||
|
||||
/**
|
||||
* Place to the LEFT of the given button.
|
||||
*/
|
||||
public GuiMenuTopButton(int i, String s, GuiButton rightNeighbor) {
|
||||
this(i, rightNeighbor.xPosition - (Minecraft.getMinecraft().fontRenderer.getStringWidth(StatCollector.translateToLocal(s)) + 12),
|
||||
rightNeighbor.yPosition, s);
|
||||
}
|
||||
|
||||
public GuiMenuTopButton(int i, GuiButton parent, String s,
|
||||
IButtonListener listener) {
|
||||
this(i, parent, s);
|
||||
|
||||
@@ -69,10 +69,10 @@ public class ConfigClient {
|
||||
|
||||
// HUD PROPERTIES
|
||||
public static Property QuestOverlayXProperty;
|
||||
public static int QuestOverlayX = 0;
|
||||
public static float QuestOverlayX = 0;
|
||||
|
||||
public static Property QuestOverlayYProperty;
|
||||
public static int QuestOverlayY = 31;
|
||||
public static float QuestOverlayY = 31;
|
||||
|
||||
public static Property QuestOverlayScaleProperty;
|
||||
public static int QuestOverlayScale = 223;
|
||||
@@ -84,10 +84,10 @@ public class ConfigClient {
|
||||
public static boolean CompassEnabled = true;
|
||||
|
||||
public static Property CompassOverlayXProperty;
|
||||
public static int CompassOverlayX = 37;
|
||||
public static float CompassOverlayX = 37;
|
||||
|
||||
public static Property CompassOverlayYProperty;
|
||||
public static int CompassOverlayY = 0;
|
||||
public static float CompassOverlayY = 0;
|
||||
|
||||
public static Property CompassOverlayScaleProperty;
|
||||
public static int CompassOverlayScale = 276;
|
||||
@@ -95,6 +95,41 @@ public class ConfigClient {
|
||||
public static Property CompassOverlayWidthProperty;
|
||||
public static int CompassOverlayWidth = 200;
|
||||
|
||||
// Ability Hotbar HUD
|
||||
public static Property AbilityHotbarEnabledProperty;
|
||||
public static boolean AbilityHotbarEnabled = true;
|
||||
|
||||
public static Property AbilityHotbarXProperty;
|
||||
public static float AbilityHotbarX = 3;
|
||||
|
||||
public static Property AbilityHotbarYProperty;
|
||||
public static float AbilityHotbarY = 50;
|
||||
|
||||
public static Property AbilityHotbarScaleProperty;
|
||||
public static int AbilityHotbarScale = 100;
|
||||
|
||||
public static Property AbilityHotbarHorizontalProperty;
|
||||
public static boolean AbilityHotbarHorizontal = false;
|
||||
|
||||
public static Property AbilityHotbarAltTextureProperty;
|
||||
public static boolean AbilityHotbarAltTexture = false;
|
||||
|
||||
// 1=Above(H)/Left(V), 2=Below(H)/Right(V)
|
||||
public static Property AbilityHotbarTextPositionProperty;
|
||||
public static int AbilityHotbarTextPosition = 2;
|
||||
|
||||
// Max visible slots: 3, 5, or 7
|
||||
public static Property AbilityHotbarVisibleSlotsProperty;
|
||||
public static int AbilityHotbarVisibleSlots = 5;
|
||||
|
||||
// Show Always: true = always visible, false = only visible while HUD key held
|
||||
public static Property AbilityHotbarShowAlwaysProperty;
|
||||
public static boolean AbilityHotbarShowAlways = true;
|
||||
|
||||
// Text Visibility: 0=Shown, 1=Hidden, 2=Held (only while HUD key held)
|
||||
public static Property AbilityHotbarTextVisibilityProperty;
|
||||
public static int AbilityHotbarTextVisibility = 0;
|
||||
|
||||
/**
|
||||
* Texture Properties
|
||||
**/
|
||||
@@ -125,11 +160,11 @@ public class ConfigClient {
|
||||
config.load();
|
||||
|
||||
// Hud Quest Overlay settings
|
||||
QuestOverlayXProperty = config.get(HUD, "Quest Hud X", 0, "X position of the quest overlay.");
|
||||
QuestOverlayX = QuestOverlayXProperty.getInt(0);
|
||||
QuestOverlayXProperty = config.get(HUD, "Quest Hud X", 0.0, "X position of the quest overlay.");
|
||||
QuestOverlayX = (float) QuestOverlayXProperty.getDouble(0);
|
||||
|
||||
QuestOverlayYProperty = config.get(HUD, "Quest Hud Y", 31, "Y position of the quest overlay.");
|
||||
QuestOverlayY = QuestOverlayYProperty.getInt(31);
|
||||
QuestOverlayYProperty = config.get(HUD, "Quest Hud Y", 31.0, "Y position of the quest overlay.");
|
||||
QuestOverlayY = (float) QuestOverlayYProperty.getDouble(31);
|
||||
|
||||
QuestOverlayScaleProperty = config.get(HUD, "Quest Hud Scale", 223, "Scale percentage of the quest overlay.");
|
||||
QuestOverlayScale = QuestOverlayScaleProperty.getInt(223);
|
||||
@@ -149,22 +184,18 @@ public class ConfigClient {
|
||||
CompassOverlayXProperty = config.get(
|
||||
HUD,
|
||||
"Compass Hud X",
|
||||
37,
|
||||
"Horizontal position of compass overlay (0-100 percentage)",
|
||||
0,
|
||||
100
|
||||
37.0,
|
||||
"Horizontal position of compass overlay (0-100 percentage)"
|
||||
);
|
||||
CompassOverlayX = CompassOverlayXProperty.getInt();
|
||||
CompassOverlayX = (float) CompassOverlayXProperty.getDouble();
|
||||
|
||||
CompassOverlayYProperty = config.get(
|
||||
HUD,
|
||||
"Compass Hud Y",
|
||||
0,
|
||||
"Vertical position of compass overlay (0-100 percentage)",
|
||||
0,
|
||||
100
|
||||
0.0,
|
||||
"Vertical position of compass overlay (0-100 percentage)"
|
||||
);
|
||||
CompassOverlayY = CompassOverlayYProperty.getInt();
|
||||
CompassOverlayY = (float) CompassOverlayYProperty.getDouble();
|
||||
|
||||
CompassOverlayScaleProperty = config.get(
|
||||
HUD,
|
||||
@@ -186,6 +217,36 @@ public class ConfigClient {
|
||||
);
|
||||
CompassOverlayWidth = CompassOverlayWidthProperty.getInt();
|
||||
|
||||
// Ability Hotbar HUD Configs
|
||||
AbilityHotbarEnabledProperty = config.get(HUD, "Ability Hotbar Enabled", true, "Enable Ability Hotbar HUD Component");
|
||||
AbilityHotbarEnabled = AbilityHotbarEnabledProperty.getBoolean();
|
||||
|
||||
AbilityHotbarXProperty = config.get(HUD, "Ability Hotbar X", 3.0, "Horizontal position (0-100 percentage)");
|
||||
AbilityHotbarX = (float) AbilityHotbarXProperty.getDouble();
|
||||
|
||||
AbilityHotbarYProperty = config.get(HUD, "Ability Hotbar Y", 50.0, "Vertical position (0-100 percentage)");
|
||||
AbilityHotbarY = (float) AbilityHotbarYProperty.getDouble();
|
||||
|
||||
AbilityHotbarScaleProperty = config.get(HUD, "Ability Hotbar Scale", 100, "Scale percentage", 50, 300);
|
||||
AbilityHotbarScale = AbilityHotbarScaleProperty.getInt();
|
||||
|
||||
AbilityHotbarHorizontalProperty = config.get(HUD, "Ability Hotbar Horizontal", false, "Display horizontally instead of vertically");
|
||||
AbilityHotbarHorizontal = AbilityHotbarHorizontalProperty.getBoolean();
|
||||
|
||||
AbilityHotbarAltTextureProperty = config.get(HUD, "Ability Hotbar Alt Texture", false, "Use rounded square instead of circle slots");
|
||||
AbilityHotbarAltTexture = AbilityHotbarAltTextureProperty.getBoolean();
|
||||
|
||||
AbilityHotbarTextPositionProperty = config.get(HUD, "Ability Hotbar Text Position", 2, "Text label position (1=Above/Left, 2=Below/Right)");
|
||||
AbilityHotbarTextPosition = AbilityHotbarTextPositionProperty.getInt(2);
|
||||
|
||||
AbilityHotbarVisibleSlotsProperty = config.get(HUD, "Ability Hotbar Visible Slots", 5, "Max visible slots in hotbar (3, 5, or 7)");
|
||||
AbilityHotbarVisibleSlots = AbilityHotbarVisibleSlotsProperty.getInt(5);
|
||||
|
||||
AbilityHotbarShowAlwaysProperty = config.get(HUD, "Ability Hotbar Show Always", true, "Always show hotbar (false = only while HUD key is held)");
|
||||
AbilityHotbarShowAlways = AbilityHotbarShowAlwaysProperty.getBoolean(true);
|
||||
|
||||
AbilityHotbarTextVisibilityProperty = config.get(HUD, "Ability Hotbar Text Visibility", 0, "Text visibility (0=Shown, 1=Hidden, 2=Held)");
|
||||
AbilityHotbarTextVisibility = AbilityHotbarTextVisibilityProperty.getInt(0);
|
||||
|
||||
// General
|
||||
AllowClientScriptsProperty = config.get(GENERAL, "Allow Client Scripts", true, "Allow the server to run scripts on the client. If disabled, no server scripts will execute client-side.");
|
||||
|
||||
@@ -0,0 +1,37 @@
|
||||
package noppes.npcs.config;
|
||||
|
||||
import cpw.mods.fml.common.FMLLog;
|
||||
import net.minecraftforge.common.config.Configuration;
|
||||
import org.apache.logging.log4j.Level;
|
||||
|
||||
import java.io.File;
|
||||
|
||||
public class ConfigEnergy {
|
||||
public static Configuration config;
|
||||
|
||||
public final static String DOMES = "Domes";
|
||||
|
||||
public static String[] DomeItemBlacklist;
|
||||
|
||||
public static void init(File configFile) {
|
||||
config = new Configuration(configFile);
|
||||
|
||||
try {
|
||||
config.load();
|
||||
|
||||
DomeItemBlacklist = config.getStringList(
|
||||
"Item Blacklist", DOMES,
|
||||
new String[]{"minecraft:ender_pearl"},
|
||||
"Items that cannot be used while inside an Energy Dome.\n"
|
||||
+ "Format: modid:itemname (e.g., minecraft:ender_pearl)"
|
||||
);
|
||||
|
||||
} catch (Exception e) {
|
||||
FMLLog.log(Level.ERROR, e, "CustomNPC+ has had a problem loading its energy configuration");
|
||||
} finally {
|
||||
if (config.hasChanged()) {
|
||||
config.save();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -10,6 +10,7 @@ public class LoadConfiguration {
|
||||
public static File clientConfigFile;
|
||||
public static File experimentalConfigFile;
|
||||
public static File marketConfigFile;
|
||||
public static File energyConfigFile;
|
||||
|
||||
public static void init(String configpath) {
|
||||
mainConfigFile = new File(configpath + "main.cfg");
|
||||
@@ -19,6 +20,7 @@ public class LoadConfiguration {
|
||||
debugConfigFile = new File(configpath + "debug.cfg");
|
||||
experimentalConfigFile = new File(configpath + "experimental.cfg");
|
||||
marketConfigFile = new File(configpath + "market.cfg");
|
||||
energyConfigFile = new File(configpath + "energy.cfg");
|
||||
|
||||
ConfigMain.init(mainConfigFile);
|
||||
ConfigItem.init(itemConfigFile);
|
||||
@@ -27,5 +29,6 @@ public class LoadConfiguration {
|
||||
ConfigDebug.init(debugConfigFile);
|
||||
ConfigExperimental.init(experimentalConfigFile);
|
||||
ConfigMarket.init(marketConfigFile);
|
||||
ConfigEnergy.init(energyConfigFile);
|
||||
}
|
||||
}
|
||||
@@ -213,6 +213,18 @@ public class AnimationController implements IAnimationHandler {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Loads built-in animations for client-side usage.
|
||||
* On dedicated servers, AnimationController.load() never runs on the client JVM,
|
||||
* so built-in animations would be missing for client-only systems like ability preview.
|
||||
* This method loads just the built-in animations (from assets and registered addons)
|
||||
* without touching user animations or world save data.
|
||||
*/
|
||||
public void loadClientBuiltIns() {
|
||||
loadBuiltInAnimations();
|
||||
loadRegisteredBuiltIns();
|
||||
}
|
||||
|
||||
private File getDir() {
|
||||
return new File(CustomNpcs.getWorldSaveDirectory(), "animations");
|
||||
}
|
||||
|
||||
@@ -0,0 +1,47 @@
|
||||
package noppes.npcs.controllers.data;
|
||||
|
||||
import net.minecraft.nbt.NBTTagCompound;
|
||||
|
||||
public class AbilityHotbarData {
|
||||
public static final String CHAIN_PREFIX = "chain:";
|
||||
public static final int TOTAL_SLOTS = 12;
|
||||
|
||||
public int slot = -1;
|
||||
public String abilityKey = "";
|
||||
|
||||
public AbilityHotbarData() {
|
||||
}
|
||||
|
||||
public AbilityHotbarData(int slot) {
|
||||
this.slot = slot;
|
||||
}
|
||||
|
||||
public boolean isChainKey() {
|
||||
return abilityKey != null && abilityKey.startsWith(CHAIN_PREFIX);
|
||||
}
|
||||
|
||||
public String getResolveKey() {
|
||||
if (isChainKey()) return abilityKey.substring(CHAIN_PREFIX.length());
|
||||
return abilityKey;
|
||||
}
|
||||
|
||||
public NBTTagCompound writeToNBT(NBTTagCompound compound) {
|
||||
NBTTagCompound tag = new NBTTagCompound();
|
||||
tag.setInteger("slot", slot);
|
||||
tag.setString("abilityKey", abilityKey != null ? abilityKey : "");
|
||||
compound.setTag("AbilityHotbar" + slot, tag);
|
||||
return compound;
|
||||
}
|
||||
|
||||
public void readFromNBT(NBTTagCompound compound) {
|
||||
abilityKey = compound.getString("abilityKey");
|
||||
}
|
||||
|
||||
public void reset() {
|
||||
abilityKey = "";
|
||||
}
|
||||
|
||||
public boolean isEmpty() {
|
||||
return abilityKey == null || abilityKey.isEmpty();
|
||||
}
|
||||
}
|
||||
@@ -8,6 +8,7 @@ import kamkeel.npcs.controllers.data.ability.IAbilityAction;
|
||||
import kamkeel.npcs.controllers.data.ability.ToggleEntry;
|
||||
import kamkeel.npcs.controllers.data.ability.type.AbilityGuard;
|
||||
import kamkeel.npcs.controllers.data.telegraph.TelegraphInstance;
|
||||
import kamkeel.npcs.network.packets.data.ability.AbilityCooldownSyncPacket;
|
||||
import kamkeel.npcs.network.packets.data.ability.PlayerAbilityStatePacket;
|
||||
import kamkeel.npcs.network.packets.data.ability.PlayerAbilitySyncPacket;
|
||||
import kamkeel.npcs.network.packets.data.telegraph.TelegraphRemovePacket;
|
||||
@@ -22,6 +23,7 @@ import net.minecraft.util.DamageSource;
|
||||
import noppes.npcs.AbstractDataAbilities;
|
||||
import noppes.npcs.EventHooks;
|
||||
import noppes.npcs.LogWriter;
|
||||
import noppes.npcs.NoppesUtilPlayer;
|
||||
import noppes.npcs.api.ability.IPlayerAbilityData;
|
||||
import noppes.npcs.api.entity.IPlayer;
|
||||
import noppes.npcs.controllers.ScriptController;
|
||||
@@ -89,6 +91,16 @@ public class PlayerAbilityData extends AbstractDataAbilities implements IPlayerA
|
||||
*/
|
||||
private transient byte lastSyncedFlags = 0;
|
||||
|
||||
/**
|
||||
* World time when the last ability was activated (for double-press cancel detection).
|
||||
*/
|
||||
private transient long lastAbilityActivationTime = -1;
|
||||
|
||||
/**
|
||||
* Ticks after activation during which a second key press will cancel the ability.
|
||||
*/
|
||||
private static final int CANCEL_WINDOW_TICKS = 10;
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
// CONSTRUCTOR
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
@@ -225,14 +237,30 @@ public class PlayerAbilityData extends AbstractDataAbilities implements IPlayerA
|
||||
|
||||
@Override
|
||||
protected void rollCooldown(Ability ability) {
|
||||
if (!ability.isIgnoreCooldown()) {
|
||||
cooldownEndTime = getWorldTime() + ability.getCooldownTicks();
|
||||
if (ability.isIgnoreCooldown()) return;
|
||||
|
||||
int duration = ability.getCooldownTicks();
|
||||
long endTime = getWorldTime() + duration;
|
||||
|
||||
if (ability.isPerAbilityCooldown()) {
|
||||
// Per-ability: only this ability goes on cooldown
|
||||
if (currentAbilityKey != null) {
|
||||
setPerAbilityCooldown(currentAbilityKey, endTime, duration);
|
||||
}
|
||||
} else {
|
||||
// Global: all global-cooldown abilities share this cooldown
|
||||
cooldownEndTime = endTime;
|
||||
globalCooldownDuration = duration;
|
||||
}
|
||||
syncCooldownToClient();
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void rollChainCooldown(ChainedAbility chain) {
|
||||
cooldownEndTime = getWorldTime() + chain.getCooldownTicks();
|
||||
int duration = chain.getCooldownTicks();
|
||||
cooldownEndTime = getWorldTime() + duration;
|
||||
globalCooldownDuration = duration;
|
||||
syncCooldownToClient();
|
||||
}
|
||||
|
||||
@Override
|
||||
@@ -240,6 +268,7 @@ public class PlayerAbilityData extends AbstractDataAbilities implements IPlayerA
|
||||
currentAbility = null;
|
||||
currentAbilityKey = null;
|
||||
currentTarget = null;
|
||||
lastAbilityActivationTime = -1;
|
||||
syncAbilityStateClear(playerData.player);
|
||||
}
|
||||
|
||||
@@ -250,9 +279,12 @@ public class PlayerAbilityData extends AbstractDataAbilities implements IPlayerA
|
||||
@Override
|
||||
protected void onInterruptComplete() {
|
||||
// Player clears state immediately (unlike NPC which ticks through DAZED)
|
||||
// Stop the dazed animation that was started in interruptCurrentAbility()
|
||||
stopAbilityAnimation();
|
||||
currentAbility = null;
|
||||
currentAbilityKey = null;
|
||||
currentTarget = null;
|
||||
lastAbilityActivationTime = -1;
|
||||
syncAbilityStateClear(playerData.player);
|
||||
}
|
||||
|
||||
@@ -358,14 +390,27 @@ public class PlayerAbilityData extends AbstractDataAbilities implements IPlayerA
|
||||
|
||||
currentAbilityKey = key;
|
||||
currentTarget = null;
|
||||
lastAbilityActivationTime = getWorldTime();
|
||||
return startChain((ChainedAbility) action, null);
|
||||
}
|
||||
|
||||
// Regular ability activation
|
||||
Ability ability = (Ability) action;
|
||||
|
||||
// Check universal cooldown (abilities can optionally ignore it)
|
||||
if (!ability.isIgnoreCooldown() && isOnCooldown()) return false;
|
||||
// Toggle abilities cycle state instead of executing
|
||||
if (ability.isToggleable()) {
|
||||
toggleAbility(key);
|
||||
return true;
|
||||
}
|
||||
|
||||
// Check cooldown (per-ability cooldowns are independent from global)
|
||||
if (!ability.isIgnoreCooldown()) {
|
||||
if (ability.isPerAbilityCooldown()) {
|
||||
if (isOnPerAbilityCooldown(key)) return false;
|
||||
} else {
|
||||
if (isOnCooldown()) return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Fire extender start hook (e.g., resource cost checks)
|
||||
if (!AbilityController.Instance.fireOnAbilityStart(ability, player, null)) {
|
||||
@@ -381,6 +426,7 @@ public class PlayerAbilityData extends AbstractDataAbilities implements IPlayerA
|
||||
currentAbility = ability;
|
||||
currentAbilityKey = key;
|
||||
currentTarget = null; // Players don't have auto-targets
|
||||
lastAbilityActivationTime = getWorldTime();
|
||||
ability.start(null);
|
||||
|
||||
if (ability.getPhase() == AbilityPhase.ACTIVE) {
|
||||
@@ -420,6 +466,18 @@ public class PlayerAbilityData extends AbstractDataAbilities implements IPlayerA
|
||||
EntityPlayer player = playerData.player;
|
||||
if (player instanceof EntityPlayerMP) {
|
||||
PlayerAbilitySyncPacket.sendToPlayer((EntityPlayerMP) player);
|
||||
syncCooldownToClient();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Sync cooldown state (global + per-ability) to the client.
|
||||
* Sent as a lightweight packet separate from full ability sync.
|
||||
*/
|
||||
public void syncCooldownToClient() {
|
||||
EntityPlayer player = playerData.player;
|
||||
if (player instanceof EntityPlayerMP) {
|
||||
AbilityCooldownSyncPacket.sendToPlayer((EntityPlayerMP) player);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -460,7 +518,7 @@ public class PlayerAbilityData extends AbstractDataAbilities implements IPlayerA
|
||||
}
|
||||
|
||||
public void setSelectedIndex(int index) {
|
||||
if (index >= 0 && index < unlockedAbilities.size()) {
|
||||
if (index == -1 || (index >= 0 && index < unlockedAbilities.size())) {
|
||||
this.selectedIndex = index;
|
||||
syncToClient();
|
||||
}
|
||||
@@ -539,9 +597,15 @@ public class PlayerAbilityData extends AbstractDataAbilities implements IPlayerA
|
||||
|
||||
/**
|
||||
* Check if a specific ability key is on cooldown.
|
||||
* Currently uses universal cooldown (same for all abilities).
|
||||
* Respects per-ability cooldown if the ability has it enabled.
|
||||
*/
|
||||
public boolean isOnCooldown(String key, EntityPlayer player) {
|
||||
if (AbilityController.Instance != null) {
|
||||
Ability ability = AbilityController.Instance.resolveAbility(key);
|
||||
if (ability != null && ability.isPerAbilityCooldown()) {
|
||||
return isOnPerAbilityCooldown(key);
|
||||
}
|
||||
}
|
||||
return isOnCooldown(player);
|
||||
}
|
||||
|
||||
@@ -552,17 +616,21 @@ public class PlayerAbilityData extends AbstractDataAbilities implements IPlayerA
|
||||
|
||||
/**
|
||||
* Reset cooldown for a specific ability key.
|
||||
* Currently resets the universal cooldown.
|
||||
* Resets per-ability cooldown if applicable, and global cooldown.
|
||||
*/
|
||||
public void resetCooldown(String key) {
|
||||
resetPerAbilityCooldown(key);
|
||||
cooldownEndTime = 0;
|
||||
syncCooldownToClient();
|
||||
}
|
||||
|
||||
/**
|
||||
* Reset all cooldowns.
|
||||
* Reset all cooldowns (global + all per-ability).
|
||||
*/
|
||||
public void resetAllCooldowns() {
|
||||
cooldownEndTime = 0;
|
||||
resetAllPerAbilityCooldowns();
|
||||
syncCooldownToClient();
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
@@ -596,6 +664,8 @@ public class PlayerAbilityData extends AbstractDataAbilities implements IPlayerA
|
||||
@Override
|
||||
public void resetCooldown() {
|
||||
cooldownEndTime = 0;
|
||||
resetAllPerAbilityCooldowns();
|
||||
syncCooldownToClient();
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
@@ -606,6 +676,38 @@ public class PlayerAbilityData extends AbstractDataAbilities implements IPlayerA
|
||||
interruptCurrentAbility(null, 0);
|
||||
}
|
||||
|
||||
/**
|
||||
* Try to cancel the current ability via double-press.
|
||||
* Only succeeds if within the cancel window and not in DAZED phase.
|
||||
* Also handles cancellation during chain delay (between chain entries).
|
||||
*
|
||||
* @return true if the ability was cancelled
|
||||
*/
|
||||
public boolean tryCancelAbility() {
|
||||
boolean hasExecutingAbility = currentAbility != null && currentAbility.isExecuting();
|
||||
boolean isInChainDelay = currentChain != null && chainDelayRemaining > 0;
|
||||
|
||||
if (!hasExecutingAbility && !isInChainDelay) return false;
|
||||
|
||||
// Don't allow cancel during DAZED
|
||||
if (hasExecutingAbility) {
|
||||
AbilityPhase phase = currentAbility.getPhase();
|
||||
if (phase == AbilityPhase.DAZED) return false;
|
||||
if (phase != AbilityPhase.WINDUP && phase != AbilityPhase.ACTIVE
|
||||
&& phase != AbilityPhase.BURST_DELAY) return false;
|
||||
}
|
||||
|
||||
long worldTime = getWorldTime();
|
||||
if (lastAbilityActivationTime < 0 || (worldTime - lastAbilityActivationTime) > CANCEL_WINDOW_TICKS) {
|
||||
// Outside cancel window — update time so a quick follow-up press can cancel
|
||||
lastAbilityActivationTime = worldTime;
|
||||
return false;
|
||||
}
|
||||
|
||||
cancelCurrentAbility();
|
||||
return true;
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
// ENTITY RECONSTRUCTION RESET
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
@@ -645,9 +747,11 @@ public class PlayerAbilityData extends AbstractDataAbilities implements IPlayerA
|
||||
currentAbility = null;
|
||||
currentAbilityKey = null;
|
||||
currentTarget = null;
|
||||
lastAbilityActivationTime = -1;
|
||||
|
||||
if (clearCooldowns) {
|
||||
cooldownEndTime = 0;
|
||||
resetAllPerAbilityCooldowns();
|
||||
}
|
||||
interruptCooldownRolled = false;
|
||||
|
||||
@@ -935,8 +1039,9 @@ public class PlayerAbilityData extends AbstractDataAbilities implements IPlayerA
|
||||
}
|
||||
|
||||
/**
|
||||
* Remove any unlocked ability keys that can no longer be resolved.
|
||||
* Called during load to clean up references to deleted abilities.
|
||||
* Remove any unlocked ability keys that can no longer be resolved or
|
||||
* are no longer allowed for players (e.g. NPC-only abilities).
|
||||
* Called during load to clean up references to deleted/restricted abilities.
|
||||
* Supports both regular ability keys and "chain:" prefixed chained ability keys.
|
||||
*/
|
||||
private void validateUnlockedAbilities() {
|
||||
@@ -949,6 +1054,9 @@ public class PlayerAbilityData extends AbstractDataAbilities implements IPlayerA
|
||||
if (resolved == null) {
|
||||
it.remove();
|
||||
LogWriter.info("Removed invalid ability reference from player data: " + key);
|
||||
} else if (!resolved.getAllowedBy().allowsPlayer()) {
|
||||
it.remove();
|
||||
LogWriter.info("Removed non-player ability from player data: " + key);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,84 @@
|
||||
package noppes.npcs.controllers.data;
|
||||
|
||||
import kamkeel.npcs.controllers.AbilityController;
|
||||
import kamkeel.npcs.controllers.data.ability.Ability;
|
||||
import kamkeel.npcs.network.PacketHandler;
|
||||
import kamkeel.npcs.network.packets.data.ability.AbilityHotbarSyncPacket;
|
||||
import net.minecraft.entity.player.EntityPlayer;
|
||||
import net.minecraft.entity.player.EntityPlayerMP;
|
||||
import net.minecraft.nbt.NBTTagCompound;
|
||||
|
||||
public class PlayerAbilityHotbarData {
|
||||
public AbilityHotbarData[] slots = new AbilityHotbarData[AbilityHotbarData.TOTAL_SLOTS];
|
||||
|
||||
public PlayerAbilityHotbarData() {
|
||||
for (int i = 0; i < slots.length; i++) {
|
||||
slots[i] = new AbilityHotbarData(i);
|
||||
}
|
||||
}
|
||||
|
||||
public AbilityHotbarData getSlot(int index) {
|
||||
if (index < 0 || index >= slots.length) return null;
|
||||
return slots[index];
|
||||
}
|
||||
|
||||
public void setSlot(int index, String abilityKey) {
|
||||
if (index < 0 || index >= slots.length) return;
|
||||
slots[index].abilityKey = abilityKey != null ? abilityKey : "";
|
||||
}
|
||||
|
||||
public void clearSlot(int index) {
|
||||
if (index < 0 || index >= slots.length) return;
|
||||
slots[index].reset();
|
||||
}
|
||||
|
||||
public boolean hasAnyAbilities() {
|
||||
for (AbilityHotbarData slot : slots) {
|
||||
if (!slot.isEmpty()) return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
public void writeToNBT(NBTTagCompound compound) {
|
||||
for (int i = 0; i < slots.length; i++) {
|
||||
slots[i].writeToNBT(compound);
|
||||
}
|
||||
}
|
||||
|
||||
public void readFromNBT(NBTTagCompound compound) {
|
||||
for (int i = 0; i < slots.length; i++) {
|
||||
NBTTagCompound slotTag = compound.getCompoundTag("AbilityHotbar" + i);
|
||||
slots[i].readFromNBT(slotTag);
|
||||
}
|
||||
validateSlots();
|
||||
}
|
||||
|
||||
public void validateSlots() {
|
||||
if (AbilityController.Instance == null) return;
|
||||
for (AbilityHotbarData slot : slots) {
|
||||
if (slot.isEmpty()) continue;
|
||||
boolean valid;
|
||||
if (slot.isChainKey()) {
|
||||
valid = AbilityController.Instance.canResolveChainedAbility(slot.getResolveKey());
|
||||
} else {
|
||||
valid = AbilityController.Instance.canResolveAbility(slot.abilityKey);
|
||||
// Also check that resolved ability allows player usage
|
||||
if (valid) {
|
||||
Ability ability = AbilityController.Instance.resolveAbility(slot.abilityKey);
|
||||
if (ability != null && !ability.getAllowedBy().allowsPlayer()) {
|
||||
valid = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (!valid) {
|
||||
slot.reset();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void syncToClient(EntityPlayer player) {
|
||||
if (player instanceof EntityPlayerMP) {
|
||||
AbilityHotbarSyncPacket.sendToPlayer((EntityPlayerMP) player);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -65,6 +65,7 @@ public class PlayerData implements IExtendedEntityProperties, IPlayerData {
|
||||
public PlayerTradeData tradeData = new PlayerTradeData(this);
|
||||
|
||||
public PlayerAbilityData abilityData = new PlayerAbilityData(this);
|
||||
public PlayerAbilityHotbarData hotbarData = new PlayerAbilityHotbarData();
|
||||
public ActionManager actionManager = new ActionManager();
|
||||
public PlayerDataScript scriptData;
|
||||
|
||||
@@ -119,6 +120,9 @@ public class PlayerData implements IExtendedEntityProperties, IPlayerData {
|
||||
|
||||
// Sync player ability data to client
|
||||
abilityData.syncToClient();
|
||||
|
||||
// Sync hotbar data to client
|
||||
hotbarData.syncToClient(player);
|
||||
}
|
||||
|
||||
public void onLogout() {
|
||||
@@ -151,6 +155,7 @@ public class PlayerData implements IExtendedEntityProperties, IPlayerData {
|
||||
magicData.readToNBT(data);
|
||||
tradeData.readFromNBT(data);
|
||||
abilityData.readFromNBT(data);
|
||||
hotbarData.readFromNBT(data);
|
||||
|
||||
if (player != null) {
|
||||
playername = player.getCommandSenderName();
|
||||
@@ -195,6 +200,7 @@ public class PlayerData implements IExtendedEntityProperties, IPlayerData {
|
||||
magicData.writeToNBT(compound);
|
||||
tradeData.writeToNBT(compound);
|
||||
abilityData.writeToNBT(compound);
|
||||
hotbarData.writeToNBT(compound);
|
||||
|
||||
compound.setString("PlayerName", playername);
|
||||
compound.setString("UUID", uuid);
|
||||
|
||||
@@ -11,6 +11,7 @@ import kamkeel.npcs.network.PacketHandler;
|
||||
import kamkeel.npcs.network.enums.EnumSoundOperation;
|
||||
import kamkeel.npcs.network.packets.data.ChatBubblePacket;
|
||||
import kamkeel.npcs.network.packets.data.QuestCompletionPacket;
|
||||
import kamkeel.npcs.network.packets.data.RequestProperSpawnData;
|
||||
import kamkeel.npcs.network.packets.data.SoundManagementPacket;
|
||||
import kamkeel.npcs.network.packets.data.npc.UpdateNpcPacket;
|
||||
import kamkeel.npcs.network.packets.data.npc.WeaponNpcPacket;
|
||||
@@ -68,6 +69,7 @@ import net.minecraft.util.Vec3;
|
||||
import net.minecraft.world.World;
|
||||
import net.minecraft.world.WorldServer;
|
||||
import net.minecraftforge.common.MinecraftForge;
|
||||
import net.minecraftforge.common.util.Constants;
|
||||
import net.minecraftforge.common.util.FakePlayer;
|
||||
import net.minecraftforge.event.ServerChatEvent;
|
||||
import noppes.npcs.CustomItems;
|
||||
@@ -229,6 +231,9 @@ public abstract class EntityNPCInterface extends EntityCreature implements IEnti
|
||||
public FlyingMoveHelper flyMoveHelper = new FlyingMoveHelper(this);
|
||||
public PathNavigate flyNavigator = new PathNavigateFlying(this, worldObj);
|
||||
|
||||
@SideOnly(Side.CLIENT)
|
||||
public int immediateSpawnDataFixAttempts = 0;
|
||||
|
||||
public EntityNPCInterface(World world) {
|
||||
super(world);
|
||||
try {
|
||||
@@ -1829,10 +1834,17 @@ public abstract class EntityNPCInterface extends EntityCreature implements IEnti
|
||||
try {
|
||||
readSpawnData(ByteBufUtils.readNBT(buf));
|
||||
} catch (IOException e) {
|
||||
RequestProperSpawnData.reportMissingData(this);
|
||||
}
|
||||
}
|
||||
|
||||
public void readSpawnData(NBTTagCompound compound) {
|
||||
if ((compound.hasNoTags() || !compound.hasKey("MaxHealth", Constants.NBT.TAG_DOUBLE))) {
|
||||
RequestProperSpawnData.reportMissingData(this);
|
||||
return;
|
||||
}
|
||||
|
||||
immediateSpawnDataFixAttempts = 0;
|
||||
stats.maxHealth = compound.getDouble("MaxHealth");
|
||||
ais.setWalkingSpeed(compound.getInteger("Speed"));
|
||||
stats.hideKilledBody = compound.getBoolean("DeadBody");
|
||||
|
||||
@@ -1,9 +1,11 @@
|
||||
package noppes.npcs.mixin;
|
||||
|
||||
import kamkeel.npcs.util.AttributeItemUtil;
|
||||
import net.minecraft.client.Minecraft;
|
||||
import net.minecraft.entity.player.EntityPlayer;
|
||||
import net.minecraft.item.ItemStack;
|
||||
import net.minecraft.nbt.NBTTagCompound;
|
||||
import noppes.npcs.client.gui.player.GuiAuctionInterface;
|
||||
import org.spongepowered.asm.mixin.Mixin;
|
||||
import org.spongepowered.asm.mixin.Shadow;
|
||||
import org.spongepowered.asm.mixin.injection.At;
|
||||
@@ -28,9 +30,14 @@ public abstract class MixinItemStack {
|
||||
|
||||
@Inject(method = "getTooltip", at = @At("TAIL"), cancellable = true)
|
||||
public void getAttributeTooltip(EntityPlayer player, boolean advanced, CallbackInfoReturnable<List<String>> cir) {
|
||||
boolean override = false;
|
||||
if (Minecraft.getMinecraft().currentScreen instanceof GuiAuctionInterface) {
|
||||
override = true;
|
||||
}
|
||||
|
||||
List<String> tooltip = cir.getReturnValue();
|
||||
if (hasTagCompound() && getTagCompound().hasKey(TAG_RPGCORE)) {
|
||||
cir.setReturnValue(AttributeItemUtil.getToolTip(tooltip, getTagCompound()));
|
||||
cir.setReturnValue(AttributeItemUtil.getToolTip(tooltip, getTagCompound(), override));
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -9,9 +9,13 @@ import kamkeel.npcs.controllers.ProfileController;
|
||||
import kamkeel.npcs.controllers.TelegraphController;
|
||||
import kamkeel.npcs.entity.EntityAbilityBeam;
|
||||
import kamkeel.npcs.entity.EntityAbilityDisc;
|
||||
import kamkeel.npcs.entity.EntityAbilityDome;
|
||||
import kamkeel.npcs.entity.EntityAbilityLaser;
|
||||
import kamkeel.npcs.entity.EntityAbilityOrb;
|
||||
import kamkeel.npcs.entity.EntityAbilityPanel;
|
||||
import kamkeel.npcs.entity.EntityAbilitySweeper;
|
||||
import kamkeel.npcs.entity.EntityEnergyProjectile;
|
||||
import kamkeel.npcs.entity.EntityEnergySlicer;
|
||||
import net.minecraft.block.Block;
|
||||
import net.minecraft.command.CommandHandler;
|
||||
import net.minecraft.entity.Entity;
|
||||
@@ -126,9 +130,13 @@ import noppes.npcs.scripted.entity.ScriptArrow;
|
||||
import noppes.npcs.scripted.entity.ScriptDBCPlayer;
|
||||
import noppes.npcs.scripted.entity.ScriptEnergyBeam;
|
||||
import noppes.npcs.scripted.entity.ScriptEnergyDisc;
|
||||
import noppes.npcs.scripted.entity.ScriptEnergyDome;
|
||||
import noppes.npcs.scripted.entity.ScriptEnergyLaser;
|
||||
import noppes.npcs.scripted.entity.ScriptEnergyOrb;
|
||||
import noppes.npcs.scripted.entity.ScriptEnergyPanel;
|
||||
import noppes.npcs.scripted.entity.ScriptEnergyProjectile;
|
||||
import noppes.npcs.scripted.entity.ScriptEnergySlicer;
|
||||
import noppes.npcs.scripted.entity.ScriptEnergySweeper;
|
||||
import noppes.npcs.scripted.entity.ScriptEntity;
|
||||
import noppes.npcs.scripted.entity.ScriptEntityItem;
|
||||
import noppes.npcs.scripted.entity.ScriptFishHook;
|
||||
@@ -472,16 +480,16 @@ public class NpcAPI extends AbstractNpcAPI {
|
||||
data = new ScriptEntityData(new ScriptEnergyDisc<>((EntityAbilityDisc) entity));
|
||||
else if (entity instanceof EntityAbilityLaser)
|
||||
data = new ScriptEntityData(new ScriptEnergyLaser<>((EntityAbilityLaser) entity));
|
||||
else if (entity instanceof kamkeel.npcs.entity.EntityEnergySlicer)
|
||||
data = new ScriptEntityData(new noppes.npcs.scripted.entity.ScriptEnergySlicer<>((kamkeel.npcs.entity.EntityEnergySlicer) entity));
|
||||
else if (entity instanceof EntityEnergySlicer)
|
||||
data = new ScriptEntityData(new ScriptEnergySlicer<>((EntityEnergySlicer) entity));
|
||||
else if (entity instanceof EntityEnergyProjectile)
|
||||
data = new ScriptEntityData(new ScriptEnergyProjectile((EntityEnergyProjectile) entity));
|
||||
else if (entity instanceof kamkeel.npcs.entity.EntityEnergyDome)
|
||||
data = new ScriptEntityData(new noppes.npcs.scripted.entity.ScriptEnergyDome<>((kamkeel.npcs.entity.EntityEnergyDome) entity));
|
||||
else if (entity instanceof kamkeel.npcs.entity.EntityEnergyPanel)
|
||||
data = new ScriptEntityData(new noppes.npcs.scripted.entity.ScriptEnergyPanel<>((kamkeel.npcs.entity.EntityEnergyPanel) entity));
|
||||
else if (entity instanceof kamkeel.npcs.entity.EntityAbilitySweeper)
|
||||
data = new ScriptEntityData(new noppes.npcs.scripted.entity.ScriptEnergySweeper<>((kamkeel.npcs.entity.EntityAbilitySweeper) entity));
|
||||
else if (entity instanceof EntityAbilityDome)
|
||||
data = new ScriptEntityData(new ScriptEnergyDome<>((EntityAbilityDome) entity));
|
||||
else if (entity instanceof EntityAbilityPanel)
|
||||
data = new ScriptEntityData(new ScriptEnergyPanel<>((EntityAbilityPanel) entity));
|
||||
else if (entity instanceof EntityAbilitySweeper)
|
||||
data = new ScriptEntityData(new ScriptEnergySweeper<>((EntityAbilitySweeper) entity));
|
||||
else
|
||||
data = new ScriptEntityData(new ScriptEntity<>(entity));
|
||||
entity.registerExtendedProperties("ScriptedObject", data);
|
||||
|
||||
Loaded 100 of 110 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user