Create IAbilityEffect + Concurrent Ability Support for Chained Abilities

This commit is contained in:
Kam committed 2026-02-19 12:55:37 -05:00
1 parent 1e45d96253
commit e54a9a83bb
32 files changed
+1754 -382

No files matched your search

@@ -7,6 +7,7 @@ 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.type.AbilityCharge;
@@ -14,7 +15,7 @@ import kamkeel.npcs.controllers.data.ability.type.AbilityCutter;
import kamkeel.npcs.controllers.data.ability.type.AbilityDash;
import kamkeel.npcs.controllers.data.ability.type.AbilityGuard;
import kamkeel.npcs.controllers.data.ability.type.AbilityHazard;
import kamkeel.npcs.controllers.data.ability.type.AbilityHeal;
import kamkeel.npcs.controllers.data.ability.type.AbilityEffect;
import kamkeel.npcs.controllers.data.ability.type.AbilityHeavyHit;
import kamkeel.npcs.controllers.data.ability.type.AbilityProjectile;
import kamkeel.npcs.controllers.data.ability.type.AbilityShockwave;
@@ -79,6 +80,9 @@ public class AbilityController implements IAbilityHandler {
private final Map<String, ChainedAbility> chainedAbilitiesById = new LinkedHashMap<>(); // UUID → ChainedAbility
private int chainedAbilityRevision = 0;
// ── Effect Action Registry ──────────────────────────────────────────────
private final Map<String, IEffectAction> effectActions = new LinkedHashMap<>();
// ── Derived State ────────────────────────────────────────────────────────
private final Set<String> builtInTypeIds = new HashSet<>();
@@ -143,7 +147,7 @@ public class AbilityController implements IAbilityHandler {
registerType("cnpc:shockwave", AbilityShockwave::new);
registerType("cnpc:guard", AbilityGuard::new);
registerType("cnpc:heal", AbilityHeal::new);
registerType("cnpc:effect", AbilityEffect::new);
registerType("cnpc:hazard", AbilityHazard::new);
registerType("cnpc:trap", AbilityTrap::new);
@@ -926,6 +930,37 @@ public class AbilityController implements IAbilityHandler {
return builtInTypeIds.contains(typeId);
}
public boolean isConcurrentCapableType(String typeId) {
Supplier<Ability> factory = abilityTypes.get(typeId);
if (factory == null) return false;
return factory.get().isConcurrentCapable();
}
// ═══════════════════════════════════════════════════════════════════════════
// EFFECT ACTION REGISTRY
// ═══════════════════════════════════════════════════════════════════════════
public void registerEffectAction(IEffectAction action) {
if (action == null || action.getId() == null) return;
effectActions.put(action.getId(), action);
}
public IEffectAction getEffectAction(String id) {
return effectActions.get(id);
}
public String[] getEffectActionIds() {
return effectActions.keySet().toArray(new String[0]);
}
public java.util.Collection<IEffectAction> getEffectActions() {
return effectActions.values();
}
public boolean hasEffectActions() {
return !effectActions.isEmpty();
}
@Override
public boolean hasType(String typeId) {
return abilityTypes.containsKey(typeId);
@@ -236,6 +236,15 @@ public abstract class Ability implements IAbility, IAbilityAction {
return false;
}
/**
* Whether this ability can run concurrently alongside the primary ability in a chain.
* Override to return true for passive/effect abilities that don't need exclusive animations.
* Concurrent abilities skip animations entirely and run their tick/execute logic independently.
*/
public boolean isConcurrentCapable() {
return false;
}
// ═══════════════════════════════════════════════════════════════════
// TOGGLE CALLBACKS (optional overrides for toggleable abilities)
// ═══════════════════════════════════════════════════════════════════
@@ -569,8 +578,7 @@ public abstract class Ability implements IAbility, IAbilityAction {
defs.add(FieldDef.stringField("gui.displayName", this::getRawDisplayName, this::setDisplayName)
.tab("General"));
defs.add(FieldDef.labelField("ability.validFor", () ->
StatCollector.translateToLocal("ability.validFor") + ": \u00A7e"
+ StatCollector.translateToLocal("ability.userType." + getAllowedBy().name()))
"\u00A7e" + StatCollector.translateToLocal("ability.userType." + getAllowedBy().name()))
.tab("General"));
defs.add(FieldDef.row(
FieldDef.intField("ability.weight", this::getWeight, this::setWeight).range(1, 1000),
@@ -0,0 +1,94 @@
package kamkeel.npcs.controllers.data.ability;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.nbt.NBTTagCompound;
import noppes.npcs.controllers.CustomEffectController;
/**
* Represents a custom effect reference that can be applied by abilities.
* Wraps the CustomEffectController system (player-only effects with script callbacks).
*/
public class AbilityCustomEffect {
private int effectId = -1;
private int durationTicks = 60;
private byte level = 0;
public AbilityCustomEffect() {
}
public AbilityCustomEffect(int effectId, int durationTicks, byte level) {
this.effectId = effectId;
this.durationTicks = Math.max(1, durationTicks);
this.level = (byte) Math.max(0, Math.min(10, level));
}
public AbilityCustomEffect copy() {
return new AbilityCustomEffect(effectId, durationTicks, level);
}
/**
* Applies this custom effect to the given entity.
* Only works on players (CustomEffectController is player-only).
*/
public void apply(EntityLivingBase entity) {
if (entity == null || effectId <= 0) return;
if (entity instanceof EntityPlayer) {
CustomEffectController.getInstance().applyEffect(
(EntityPlayer) entity, effectId, durationTicks, level);
}
}
public boolean isValid() {
return effectId > 0;
}
// ── NBT ──
public NBTTagCompound writeNBT() {
NBTTagCompound nbt = new NBTTagCompound();
nbt.setInteger("effectId", effectId);
nbt.setInteger("duration", durationTicks);
nbt.setByte("level", level);
return nbt;
}
public void readNBT(NBTTagCompound nbt) {
this.effectId = nbt.getInteger("effectId");
this.durationTicks = nbt.getInteger("duration");
this.level = nbt.getByte("level");
}
public static AbilityCustomEffect fromNBT(NBTTagCompound nbt) {
AbilityCustomEffect e = new AbilityCustomEffect();
e.readNBT(nbt);
return e;
}
// ── Getters/Setters ──
public int getEffectId() {
return effectId;
}
public void setEffectId(int effectId) {
this.effectId = effectId;
}
public int getDurationTicks() {
return durationTicks;
}
public void setDurationTicks(int durationTicks) {
this.durationTicks = Math.max(1, durationTicks);
}
public byte getLevel() {
return level;
}
public void setLevel(byte level) {
this.level = (byte) Math.max(0, Math.min(10, level));
}
}
@@ -0,0 +1,86 @@
package kamkeel.npcs.controllers.data.ability;
import kamkeel.npcs.controllers.AbilityController;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.nbt.NBTTagCompound;
/**
* A configured instance of an {@link IEffectAction} stored on an ability.
* Holds the action ID and its configuration NBT.
*/
public class AbilityEffectActionEntry {
private String actionId = "";
private NBTTagCompound config = new NBTTagCompound();
public AbilityEffectActionEntry() {
}
public AbilityEffectActionEntry(String actionId) {
this.actionId = actionId != null ? actionId : "";
IEffectAction action = AbilityController.Instance.getEffectAction(this.actionId);
if (action != null) {
this.config = action.createDefaultConfig();
}
}
public AbilityEffectActionEntry copy() {
AbilityEffectActionEntry copy = new AbilityEffectActionEntry();
copy.actionId = this.actionId;
copy.config = (NBTTagCompound) this.config.copy();
return copy;
}
/**
* Apply this action to a target entity.
*/
public void apply(EntityLivingBase caster, EntityLivingBase target) {
if (actionId.isEmpty()) return;
IEffectAction action = AbilityController.Instance.getEffectAction(actionId);
if (action != null) {
action.apply(caster, target, config);
}
}
public boolean isValid() {
return !actionId.isEmpty() && AbilityController.Instance.getEffectAction(actionId) != null;
}
// ── NBT ──
public NBTTagCompound writeNBT() {
NBTTagCompound nbt = new NBTTagCompound();
nbt.setString("actionId", actionId);
nbt.setTag("config", config);
return nbt;
}
public void readNBT(NBTTagCompound nbt) {
this.actionId = nbt.getString("actionId");
this.config = nbt.hasKey("config") ? nbt.getCompoundTag("config") : new NBTTagCompound();
}
public static AbilityEffectActionEntry fromNBT(NBTTagCompound nbt) {
AbilityEffectActionEntry entry = new AbilityEffectActionEntry();
entry.readNBT(nbt);
return entry;
}
// ── Getters/Setters ──
public String getActionId() {
return actionId;
}
public void setActionId(String actionId) {
this.actionId = actionId != null ? actionId : "";
}
public NBTTagCompound getConfig() {
return config;
}
public void setConfig(NBTTagCompound config) {
this.config = config != null ? config : new NBTTagCompound();
}
}
@@ -0,0 +1,103 @@
package kamkeel.npcs.controllers.data.ability;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.player.EntityPlayer;
import noppes.npcs.controllers.PartyController;
import noppes.npcs.controllers.data.Party;
import noppes.npcs.controllers.data.PlayerData;
import noppes.npcs.entity.EntityNPCInterface;
/**
* Utility class for determining friend/foe relationships between entities.
* Extracted from EntityEnergyProjectile.shouldIgnoreEntity() for reuse
* across all AoE abilities and AbilityEffect targeting.
*/
public class AbilityTargetHelper {
/**
* Determines if target is an ally of caster.
* <ul>
* <li>NPC vs NPC: same faction ID = ally</li>
* <li>NPC vs Player: faction friendly to player = ally</li>
* <li>Player vs NPC: NPC's faction friendly to player = ally</li>
* <li>Player vs Player: same party (if exists) = ally</li>
* <li>Passive NPCs are always considered allies (never enemies)</li>
* </ul>
*/
public static boolean isAlly(EntityLivingBase caster, Entity target) {
if (target == caster) return true;
// NPC target checks
if (target instanceof EntityNPCInterface) {
EntityNPCInterface targetNpc = (EntityNPCInterface) target;
// Passive NPCs are always considered allies
if (targetNpc.faction.isPassive) return true;
// NPC caster: same faction = ally
if (caster instanceof EntityNPCInterface) {
EntityNPCInterface casterNpc = (EntityNPCInterface) caster;
if (casterNpc.faction.id == targetNpc.faction.id) return true;
}
// Player caster: friendly faction = ally
if (caster instanceof EntityPlayer) {
if (targetNpc.faction.isFriendlyToPlayer((EntityPlayer) caster)) return true;
}
return false;
}
// Player target checks
if (target instanceof EntityPlayer && caster instanceof EntityNPCInterface) {
// NPC caster vs Player target: faction friendly to player = ally
EntityNPCInterface casterNpc = (EntityNPCInterface) caster;
return casterNpc.faction.isFriendlyToPlayer((EntityPlayer) target);
}
if (target instanceof EntityPlayer && caster instanceof EntityPlayer) {
// Player vs Player: same party = ally
EntityPlayer casterPlayer = (EntityPlayer) caster;
EntityPlayer targetPlayer = (EntityPlayer) target;
PlayerData casterData = PlayerData.get(casterPlayer);
PlayerData targetData = PlayerData.get(targetPlayer);
if (casterData.partyUUID != null && casterData.partyUUID.equals(targetData.partyUUID)) {
Party party = PartyController.Instance().getParty(casterData.partyUUID);
if (party != null && !party.friendlyFire()) return true;
}
return false;
}
// Unknown entity types: not an ally
return false;
}
/**
* Determines if a target should be affected by an ability, given the
* filter mode and includeSelf setting.
*
* @param caster The entity using the ability
* @param target The potential target entity
* @param filter ALLIES, ENEMIES, or ALL
* @param includeSelf Whether to include the caster themselves
* @return true if the target should be affected
*/
public static boolean shouldAffect(EntityLivingBase caster, Entity target,
TargetFilter filter, boolean includeSelf) {
if (target == caster) return includeSelf;
if (!(target instanceof EntityLivingBase)) return false;
if (!target.isEntityAlive()) return false;
switch (filter) {
case ALLIES:
return isAlly(caster, target);
case ENEMIES:
return !isAlly(caster, target);
case ALL:
return true;
default:
return false;
}
}
}
@@ -31,6 +31,12 @@ public class ChainedAbilityEntry {
*/
private int delayTicks = 0;
/**
* Whether this entry should execute concurrently (alongside the previous ability)
* rather than sequentially. Only takes effect if the resolved ability isConcurrentCapable().
*/
private boolean concurrentEnabled = true;
public ChainedAbilityEntry() {
}
@@ -104,6 +110,14 @@ public class ChainedAbilityEntry {
this.delayTicks = Math.max(0, delayTicks);
}
public boolean isConcurrentEnabled() {
return concurrentEnabled;
}
public void setConcurrentEnabled(boolean concurrentEnabled) {
this.concurrentEnabled = concurrentEnabled;
}
// ═══════════════════════════════════════════════════════════════════
// RESOLUTION
// ═══════════════════════════════════════════════════════════════════
@@ -157,6 +171,7 @@ public class ChainedAbilityEntry {
copy.entryType = this.entryType;
copy.abilityReference = this.abilityReference;
copy.delayTicks = this.delayTicks;
copy.concurrentEnabled = this.concurrentEnabled;
if (this.inlineAbility != null) {
copy.inlineAbility = AbilityController.Instance.fromNBT(this.inlineAbility.writeNBT());
}
@@ -170,6 +185,7 @@ public class ChainedAbilityEntry {
public NBTTagCompound writeNBT() {
NBTTagCompound nbt = new NBTTagCompound();
nbt.setInteger("Delay", delayTicks);
nbt.setBoolean("Concurrent", concurrentEnabled);
if (entryType == EntryType.INLINE && inlineAbility != null) {
nbt.setTag("InlineAbility", inlineAbility.writeNBT());
@@ -184,6 +200,7 @@ public class ChainedAbilityEntry {
ChainedAbilityEntry entry = new ChainedAbilityEntry();
entry.delayTicks = Math.max(0, nbt.getInteger("Delay"));
entry.concurrentEnabled = nbt.hasKey("Concurrent") ? nbt.getBoolean("Concurrent") : true;
// Inline entry (new format)
if (nbt.hasKey("InlineAbility")) {
@@ -0,0 +1,109 @@
package kamkeel.npcs.controllers.data.ability;
import net.minecraft.entity.EntityLivingBase;
/**
* Wraps a concurrent ability execution with its own independent lifecycle.
* Concurrent abilities skip animations, sounds, and movement/rotation locks.
* They run their execute/tick logic in parallel with the primary ability.
* <p>
* Used by the chain system when an entry is concurrent-capable and concurrent-enabled.
*/
public class ConcurrentSlot {
private final Ability ability;
private boolean started = false;
private boolean completed = false;
public ConcurrentSlot(Ability ability) {
this.ability = ability;
}
public Ability getAbility() {
return ability;
}
public boolean isCompleted() {
return completed;
}
/**
* Start the concurrent ability. Skips windup — goes straight to ACTIVE.
* Called once when the slot is activated.
*/
public void start(EntityLivingBase caster, EntityLivingBase target) {
// Skip windup for concurrent execution — fire immediately
ability.setWindUpTicks(0);
ability.start(target);
started = true;
// Ability should now be in ACTIVE phase (0 windup → immediate)
if (ability.getPhase() == AbilityPhase.ACTIVE) {
ability.onExecute(caster, target);
}
// Check if ability completed during onExecute (instant abilities like signalCompletion)
if (ability.getPhase() == AbilityPhase.IDLE) {
completed = true;
}
}
/**
* Tick the concurrent ability. Called every game tick from AbstractDataAbilities.
* Handles phase transitions including burst delay → re-execute cycles.
*/
public void tick(EntityLivingBase caster, EntityLivingBase target) {
if (completed || !started) return;
AbilityPhase oldPhase = ability.getPhase();
boolean phaseChanged = ability.tick();
AbilityPhase newPhase = ability.getPhase();
switch (newPhase) {
case ACTIVE:
if (phaseChanged && oldPhase == AbilityPhase.BURST_DELAY) {
// Re-entering ACTIVE after burst delay → re-execute (burst re-fire)
ability.onExecute(caster, target);
if (ability.getPhase() == AbilityPhase.IDLE) {
completed = true;
return;
}
}
// Normal active tick
ability.onActiveTick(caster, target, ability.getCurrentTick());
if (ability.getPhase() == AbilityPhase.IDLE) {
completed = true;
}
break;
case BURST_DELAY:
// Waiting between bursts — nothing to do, tick() handles countdown
break;
case WINDUP:
// Burst replay with windup — for concurrent, skip it by advancing
// (windUpTicks was set to 0 at start, but burst replay may re-enter WINDUP)
// The next tick() call will transition to ACTIVE
break;
case IDLE:
completed = true;
break;
case DAZED:
// Concurrent abilities don't get dazed — treat as completed
completed = true;
break;
}
}
/**
* Force cleanup on interrupt. Called when the NPC is interrupted or combat ends.
*/
public void interrupt() {
if (!completed) {
ability.interrupt();
completed = true;
}
}
}
@@ -0,0 +1,42 @@
package kamkeel.npcs.controllers.data.ability;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.nbt.NBTTagCompound;
/**
* Interface for mod-registered effect actions that can be applied by AbilityEffect.
* <p>
* Mods register implementations via {@code Register.EffectActions} or
* {@code AbilityController.Instance.registerEffectAction()}.
* Each action has a unique ID, display name, and apply logic.
* Actions can optionally provide custom configuration fields for the GUI.
*/
public interface IEffectAction {
/**
* Unique identifier, e.g. "dbc:kiRestore", "mymod:buffSpeed".
*/
String getId();
/**
* Localized display name shown in the GUI selector.
*/
String getDisplayName();
/**
* Apply this action to a target entity.
* Called once per affected entity during ability execution.
*
* @param caster The entity that used the ability
* @param target The entity being affected
* @param config Action-specific configuration NBT (from GUI)
*/
void apply(EntityLivingBase caster, EntityLivingBase target, NBTTagCompound config);
/**
* Create default configuration NBT for a new instance of this action.
*/
default NBTTagCompound createDefaultConfig() {
return new NBTTagCompound();
}
}
@@ -0,0 +1,32 @@
package kamkeel.npcs.controllers.data.ability;
/**
* Filter for determining which entities an ability should affect in AOE mode.
*/
public enum TargetFilter {
ALLIES,
ENEMIES,
ALL;
@Override
public String toString() {
switch (this) {
case ALLIES:
return "ability.targetFilter.allies";
case ENEMIES:
return "ability.targetFilter.enemies";
case ALL:
return "ability.targetFilter.all";
default:
return name();
}
}
public static TargetFilter fromString(String name) {
try {
return valueOf(name);
} catch (Exception e) {
return ALLIES;
}
}
}
@@ -2,9 +2,14 @@ package kamkeel.npcs.controllers.data.ability.gui;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
import kamkeel.npcs.controllers.AbilityController;
import kamkeel.npcs.controllers.data.ability.AbilityCustomEffect;
import kamkeel.npcs.controllers.data.ability.AbilityEffectActionEntry;
import kamkeel.npcs.controllers.data.ability.AbilityPotionEffect;
import kamkeel.npcs.controllers.data.ability.IEffectAction;
import net.minecraft.client.gui.FontRenderer;
import net.minecraft.client.gui.GuiButton;
import noppes.npcs.client.gui.advanced.SubGuiCustomEffectSelect;
import noppes.npcs.client.gui.builder.FieldDef;
import noppes.npcs.client.gui.builder.FieldType;
import noppes.npcs.client.gui.builder.GuiFieldBuilder;
@@ -13,23 +18,36 @@ import noppes.npcs.client.gui.util.GuiNpcButton;
import noppes.npcs.client.gui.util.GuiNpcLabel;
import noppes.npcs.client.gui.util.GuiNpcTextField;
import noppes.npcs.constants.EnumPotionType;
import noppes.npcs.controllers.CustomEffectController;
import noppes.npcs.controllers.data.CustomEffect;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
/**
* Ability-specific extension of {@link GuiFieldBuilder} that handles
* the EFFECTS_LIST field type.
* the EFFECTS_LIST, CUSTOM_EFFECTS_LIST, and EFFECT_ACTIONS_LIST field types.
*/
@SideOnly(Side.CLIENT)
public class AbilityFieldBuilder extends GuiFieldBuilder {
// Effects list metadata: widgetId -> [effectIndex, action]
// action: 0=type, 1=duration(text), 2=amp, 3=delete, 4=add, 5=manualId(text)
// Unified metadata: widgetId -> [index, action]
// EFFECTS_LIST actions: 0=type, 1=duration(text), 2=amp, 3=delete, 4=add, 5=manualId(text)
// CUSTOM_EFFECTS_LIST actions: 0=effectName, 1=duration(text), 2=level, 3=delete, 4=add
// EFFECT_ACTIONS_LIST actions: 0=actionSelector, 3=delete, 4=add
private final Map<Integer, int[]> effectWidgetMeta = new HashMap<>();
// Cached sorted custom effect data for GUI selectors
private int[] sortedCustomEffectIds;
private String[] sortedCustomEffectNames;
// Cached effect action data for GUI selectors
private String[] effectActionIds;
private String[] effectActionDisplayNames;
public AbilityFieldBuilder(GuiNPCInterface parent, FontRenderer fontRenderer) {
super(parent, fontRenderer);
}
@@ -37,6 +55,10 @@ public class AbilityFieldBuilder extends GuiFieldBuilder {
@Override
protected int build(List<FieldDef> fields) {
effectWidgetMeta.clear();
sortedCustomEffectIds = null;
sortedCustomEffectNames = null;
effectActionIds = null;
effectActionDisplayNames = null;
return super.build(fields);
}
@@ -45,12 +67,21 @@ public class AbilityFieldBuilder extends GuiFieldBuilder {
if (def.getType() == FieldType.EFFECTS_LIST) {
return renderEffectsList(def, y);
}
if (def.getType() == FieldType.CUSTOM_EFFECTS_LIST) {
return renderCustomEffectsList(def, y);
}
if (def.getType() == FieldType.EFFECT_ACTIONS_LIST) {
return renderEffectActionsList(def, y);
}
return -1; // not handled
}
// ═══════════════════════════════════════════════════════════════════
// POTION EFFECTS LIST (existing)
// ═══════════════════════════════════════════════════════════════════
@SuppressWarnings("unchecked")
private int renderEffectsList(FieldDef def, int y) {
// Section header
y += 3;
sw.addLabel(new GuiNpcLabel(labelId++, def.getLabel(), colLLabel, y + 2, 0xFFFF55));
y += 15;
@@ -64,7 +95,6 @@ public class AbilityFieldBuilder extends GuiFieldBuilder {
for (int e = 0; e < effects.size() && e < 5; e++) {
AbilityPotionEffect effect = effects.get(e);
// Type selector button (index offset by -1 since None is excluded)
int typeIdx = effect.getType().ordinal() - 1;
GuiNpcButton typeBtn = new GuiNpcButton(widgetId, colLLabel, y, 100, 20, typeNames, Math.max(0, typeIdx));
sw.addButton(typeBtn);
@@ -72,7 +102,6 @@ public class AbilityFieldBuilder extends GuiFieldBuilder {
effectWidgetMeta.put(widgetId, new int[]{e, 0});
widgetId++;
// Duration text field
GuiNpcTextField durField = new GuiNpcTextField(widgetId, parent, fontRenderer,
colLLabel + 104, y, 50, 20, String.valueOf(effect.getDurationTicks()));
durField.setIntegersOnly();
@@ -83,17 +112,15 @@ public class AbilityFieldBuilder extends GuiFieldBuilder {
widgetId++;
if (effect.getType() != EnumPotionType.Fire) {
// Amplifier selector (0-10) — not applicable to Fire
GuiNpcButton ampBtn = new GuiNpcButton(widgetId, colLLabel + 158, y, 40, 20, ampValues, effect.getAmplifier());
sw.addButton(ampBtn);
buttonFieldMap.put(widgetId, def);
effectWidgetMeta.put(widgetId, new int[]{e, 2});
widgetId++;
} else {
widgetId++; // keep widgetId in sync
widgetId++;
}
// Delete button
GuiNpcButton delBtn = new GuiNpcButton(clearId, colLLabel + 202, y, 20, 20, "X");
sw.addButton(delBtn);
clearFieldMap.put(clearId, def);
@@ -102,7 +129,6 @@ public class AbilityFieldBuilder extends GuiFieldBuilder {
y += rowHeight;
// Manual potion ID field (shown on next row when type is Manual)
if (effect.getType() == EnumPotionType.Manual) {
sw.addLabel(new GuiNpcLabel(labelId++, "effect.potionid", colLLabel, y + 5, 0xFFFFFF));
GuiNpcTextField idField = new GuiNpcTextField(widgetId, parent, fontRenderer,
@@ -117,7 +143,6 @@ public class AbilityFieldBuilder extends GuiFieldBuilder {
}
}
// Add button (if < 5 effects)
if (effects.size() < 5) {
GuiNpcButton addBtn = new GuiNpcButton(widgetId, colLLabel, y, 50, 20, "gui.add");
sw.addButton(addBtn);
@@ -131,6 +156,184 @@ public class AbilityFieldBuilder extends GuiFieldBuilder {
return y;
}
// ═══════════════════════════════════════════════════════════════════
// CUSTOM EFFECTS LIST
// ═══════════════════════════════════════════════════════════════════
private void ensureCustomEffectCache() {
if (sortedCustomEffectIds != null) return;
HashMap<Integer, CustomEffect> allEffects = CustomEffectController.getInstance().getCustomEffects();
// Sort by name for consistent ordering
TreeMap<String, Integer> nameToId = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
for (CustomEffect ce : allEffects.values()) {
if (ce.getName() != null && !ce.getName().isEmpty()) {
nameToId.put(ce.getName(), ce.id);
}
}
sortedCustomEffectIds = new int[nameToId.size()];
sortedCustomEffectNames = new String[nameToId.size()];
int i = 0;
for (Map.Entry<String, Integer> entry : nameToId.entrySet()) {
sortedCustomEffectIds[i] = entry.getValue();
sortedCustomEffectNames[i] = entry.getKey();
i++;
}
}
private String getCustomEffectName(int effectId) {
HashMap<Integer, CustomEffect> allEffects = CustomEffectController.getInstance().getCustomEffects();
if (allEffects != null) {
CustomEffect ce = allEffects.get(effectId);
if (ce != null && ce.getName() != null && !ce.getName().isEmpty()) {
return ce.getName();
}
}
return "?";
}
@SuppressWarnings("unchecked")
private int renderCustomEffectsList(FieldDef def, int y) {
ensureCustomEffectCache();
y += 3;
sw.addLabel(new GuiNpcLabel(labelId++, def.getLabel(), colLLabel, y + 2, 0xFFFF55));
y += 15;
if (sortedCustomEffectNames.length == 0) {
sw.addLabel(new GuiNpcLabel(labelId++, "ability.noCustomEffects", colLLabel, y + 5, 0x888888));
y += rowHeight;
return y;
}
List<AbilityCustomEffect> effects = (List<AbilityCustomEffect>) def.getValue();
if (effects == null) effects = new ArrayList<>();
String[] levelValues = {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10"};
for (int e = 0; e < effects.size() && e < 5; e++) {
AbilityCustomEffect effect = effects.get(e);
// Effect name button — opens SubGui picker
String effectName = getCustomEffectName(effect.getEffectId());
GuiNpcButton nameBtn = new GuiNpcButton(widgetId, colLLabel, y, 100, 20, effectName);
sw.addButton(nameBtn);
buttonFieldMap.put(widgetId, def);
effectWidgetMeta.put(widgetId, new int[]{e, 0});
widgetId++;
// Duration text field
GuiNpcTextField durField = new GuiNpcTextField(widgetId, parent, fontRenderer,
colLLabel + 104, y, 50, 20, String.valueOf(effect.getDurationTicks()));
durField.setIntegersOnly();
durField.setMinMaxDefault(1, 12000, 60);
sw.addTextField(durField);
textFieldMap.put(widgetId, def);
effectWidgetMeta.put(widgetId, new int[]{e, 1});
widgetId++;
// Level selector (0-10)
GuiNpcButton lvlBtn = new GuiNpcButton(widgetId, colLLabel + 158, y, 40, 20, levelValues, effect.getLevel());
sw.addButton(lvlBtn);
buttonFieldMap.put(widgetId, def);
effectWidgetMeta.put(widgetId, new int[]{e, 2});
widgetId++;
// Delete button
GuiNpcButton delBtn = new GuiNpcButton(clearId, colLLabel + 202, y, 20, 20, "X");
sw.addButton(delBtn);
clearFieldMap.put(clearId, def);
effectWidgetMeta.put(clearId, new int[]{e, 3});
clearId++;
y += rowHeight;
}
if (effects.size() < 5) {
GuiNpcButton addBtn = new GuiNpcButton(widgetId, colLLabel, y, 50, 20, "gui.add");
sw.addButton(addBtn);
buttonFieldMap.put(widgetId, def);
effectWidgetMeta.put(widgetId, new int[]{effects.size(), 4});
widgetId++;
clearId++;
y += rowHeight;
}
return y;
}
// ═══════════════════════════════════════════════════════════════════
// EFFECT ACTIONS LIST
// ═══════════════════════════════════════════════════════════════════
private void ensureEffectActionCache() {
if (effectActionIds != null) return;
String[] ids = AbilityController.Instance.getEffectActionIds();
effectActionIds = ids;
effectActionDisplayNames = new String[ids.length];
for (int i = 0; i < ids.length; i++) {
IEffectAction action = AbilityController.Instance.getEffectAction(ids[i]);
effectActionDisplayNames[i] = action != null ? action.getDisplayName() : ids[i];
}
}
private int findEffectActionIndex(String actionId) {
ensureEffectActionCache();
for (int i = 0; i < effectActionIds.length; i++) {
if (effectActionIds[i].equals(actionId)) return i;
}
return -1;
}
@SuppressWarnings("unchecked")
private int renderEffectActionsList(FieldDef def, int y) {
ensureEffectActionCache();
if (effectActionIds.length == 0) return y;
y += 3;
sw.addLabel(new GuiNpcLabel(labelId++, def.getLabel(), colLLabel, y + 2, 0xFFFF55));
y += 15;
List<AbilityEffectActionEntry> entries = (List<AbilityEffectActionEntry>) def.getValue();
if (entries == null) entries = new ArrayList<>();
for (int e = 0; e < entries.size() && e < 5; e++) {
AbilityEffectActionEntry entry = entries.get(e);
// Action selector
int selectedIdx = Math.max(0, findEffectActionIndex(entry.getActionId()));
GuiNpcButton actionBtn = new GuiNpcButton(widgetId, colLLabel, y, 180, 20, effectActionDisplayNames, selectedIdx);
sw.addButton(actionBtn);
buttonFieldMap.put(widgetId, def);
effectWidgetMeta.put(widgetId, new int[]{e, 0});
widgetId++;
// Delete button
GuiNpcButton delBtn = new GuiNpcButton(clearId, colLLabel + 202, y, 20, 20, "X");
sw.addButton(delBtn);
clearFieldMap.put(clearId, def);
effectWidgetMeta.put(clearId, new int[]{e, 3});
clearId++;
y += rowHeight;
}
if (entries.size() < 5) {
GuiNpcButton addBtn = new GuiNpcButton(widgetId, colLLabel, y, 50, 20, "gui.add");
sw.addButton(addBtn);
buttonFieldMap.put(widgetId, def);
effectWidgetMeta.put(widgetId, new int[]{entries.size(), 4});
widgetId++;
clearId++;
y += rowHeight;
}
return y;
}
// ═══════════════════════════════════════════════════════════════════
// EVENT HANDLING OVERRIDES
// ═══════════════════════════════════════════════════════════════════
@@ -138,36 +341,96 @@ public class AbilityFieldBuilder extends GuiFieldBuilder {
@Override
@SuppressWarnings("unchecked")
public boolean handleButtonEvent(int buttonId, GuiButton button) {
// Check effects list buttons via metadata
int[] meta = effectWidgetMeta.get(buttonId);
if (meta != null) {
FieldDef def = buttonFieldMap.get(buttonId);
if (def == null) def = clearFieldMap.get(buttonId);
if (def != null && def.getType() == FieldType.EFFECTS_LIST) {
if (def == null) return false;
int idx = meta[0];
int action = meta[1];
// ── Potion Effects ──
if (def.getType() == FieldType.EFFECTS_LIST) {
List<AbilityPotionEffect> effects = (List<AbilityPotionEffect>) def.getValue();
if (effects == null) return false;
int effectIdx = meta[0];
int action = meta[1];
switch (action) {
case 0: // Type changed
if (effectIdx < effects.size()) {
effects.get(effectIdx).setType(EnumPotionType.fromIndexNoNone(((GuiNpcButton) button).getValue()));
case 0:
if (idx < effects.size())
effects.get(idx).setType(EnumPotionType.fromIndexNoNone(((GuiNpcButton) button).getValue()));
return true;
case 2:
if (idx < effects.size())
effects.get(idx).setAmplifier(((GuiNpcButton) button).getValue());
return true;
case 3:
if (idx < effects.size()) effects.remove(idx);
return true;
case 4:
if (effects.size() < 5) effects.add(new AbilityPotionEffect(EnumPotionType.Slowness, 60, 0));
return true;
}
}
// ── Custom Effects ──
if (def.getType() == FieldType.CUSTOM_EFFECTS_LIST) {
List<AbilityCustomEffect> effects = (List<AbilityCustomEffect>) def.getValue();
if (effects == null) return false;
ensureCustomEffectCache();
switch (action) {
case 0: // Open effect picker SubGui
if (idx < effects.size()) {
int currentId = effects.get(idx).getEffectId();
parent.setSubGuiWithResult(new SubGuiCustomEffectSelect(currentId), sub -> {
int selectedId = ((SubGuiCustomEffectSelect) sub).getSelectedEffectId();
if (selectedId >= 0 && idx < effects.size()) {
effects.get(idx).setEffectId(selectedId);
}
});
}
return true;
case 2: // Amp changed
if (effectIdx < effects.size()) {
effects.get(effectIdx).setAmplifier(((GuiNpcButton) button).getValue());
case 2: // Level changed
if (idx < effects.size())
effects.get(idx).setLevel((byte) ((GuiNpcButton) button).getValue());
return true;
case 3: // Delete
if (idx < effects.size()) effects.remove(idx);
return true;
case 4: // Add
if (effects.size() < 5 && sortedCustomEffectIds.length > 0) {
parent.setSubGuiWithResult(new SubGuiCustomEffectSelect(-1), sub -> {
int selectedId = ((SubGuiCustomEffectSelect) sub).getSelectedEffectId();
if (selectedId >= 0 && effects.size() < 5) {
effects.add(new AbilityCustomEffect(selectedId, 60, (byte) 0));
}
});
}
return true;
}
}
// ── Effect Actions ──
if (def.getType() == FieldType.EFFECT_ACTIONS_LIST) {
List<AbilityEffectActionEntry> entries = (List<AbilityEffectActionEntry>) def.getValue();
if (entries == null) return false;
ensureEffectActionCache();
switch (action) {
case 0: // Action selector changed
if (idx < entries.size()) {
int btnVal = ((GuiNpcButton) button).getValue();
if (btnVal >= 0 && btnVal < effectActionIds.length) {
entries.get(idx).setActionId(effectActionIds[btnVal]);
IEffectAction ea = AbilityController.Instance.getEffectAction(effectActionIds[btnVal]);
if (ea != null) entries.get(idx).setConfig(ea.createDefaultConfig());
}
}
return true;
case 3: // Delete
if (effectIdx < effects.size()) {
effects.remove(effectIdx);
}
if (idx < entries.size()) entries.remove(idx);
return true;
case 4: // Add
if (effects.size() < 5) {
effects.add(new AbilityPotionEffect(EnumPotionType.Slowness, 60, 0));
if (entries.size() < 5 && effectActionIds.length > 0) {
entries.add(new AbilityEffectActionEntry(effectActionIds[0]));
}
return true;
}
@@ -183,14 +446,26 @@ public class AbilityFieldBuilder extends GuiFieldBuilder {
int[] meta = effectWidgetMeta.get(textFieldId);
if (meta != null) {
FieldDef def = textFieldMap.get(textFieldId);
if (def != null && def.getType() == FieldType.EFFECTS_LIST) {
if (def == null) return false;
int idx = meta[0];
int action = meta[1];
// ── Potion Effects ──
if (def.getType() == FieldType.EFFECTS_LIST) {
List<AbilityPotionEffect> effects = (List<AbilityPotionEffect>) def.getValue();
if (effects != null && meta[0] < effects.size()) {
if (meta[1] == 1) { // duration field
effects.get(meta[0]).setDurationTicks(field.getInteger());
} else if (meta[1] == 5) { // manual potion ID field
effects.get(meta[0]).setManualPotionId(field.getInteger());
}
if (effects != null && idx < effects.size()) {
if (action == 1) effects.get(idx).setDurationTicks(field.getInteger());
else if (action == 5) effects.get(idx).setManualPotionId(field.getInteger());
}
return true;
}
// ── Custom Effects ──
if (def.getType() == FieldType.CUSTOM_EFFECTS_LIST) {
List<AbilityCustomEffect> effects = (List<AbilityCustomEffect>) def.getValue();
if (effects != null && idx < effects.size()) {
if (action == 1) effects.get(idx).setDurationTicks(field.getInteger());
}
return true;
}
@@ -2,6 +2,8 @@ package kamkeel.npcs.controllers.data.ability.gui;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
import kamkeel.npcs.controllers.data.ability.AbilityCustomEffect;
import kamkeel.npcs.controllers.data.ability.AbilityEffectActionEntry;
import kamkeel.npcs.controllers.data.ability.AbilityPotionEffect;
import noppes.npcs.client.gui.builder.FieldDef;
import noppes.npcs.client.gui.builder.FieldType;
@@ -24,4 +26,17 @@ public class AbilityFieldDefs {
v -> setter.accept((List<AbilityPotionEffect>) v));
}
@SuppressWarnings("unchecked")
public static FieldDef customEffectsListField(String label, Supplier<List<AbilityCustomEffect>> getter, Consumer<List<AbilityCustomEffect>> setter) {
return FieldDef.custom(label, FieldType.CUSTOM_EFFECTS_LIST,
() -> getter.get(),
v -> setter.accept((List<AbilityCustomEffect>) v));
}
@SuppressWarnings("unchecked")
public static FieldDef effectActionsListField(String label, Supplier<List<AbilityEffectActionEntry>> getter, Consumer<List<AbilityEffectActionEntry>> setter) {
return FieldDef.custom(label, FieldType.EFFECT_ACTIONS_LIST,
() -> getter.get(),
v -> setter.accept((List<AbilityEffectActionEntry>) v));
}
}
@@ -2,7 +2,9 @@ package kamkeel.npcs.controllers.data.ability.type;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
import kamkeel.npcs.controllers.data.ability.AbilityTargetHelper;
import kamkeel.npcs.controllers.data.ability.LockMovementType;
import kamkeel.npcs.controllers.data.ability.TargetFilter;
import kamkeel.npcs.controllers.data.ability.TargetingMode;
import kamkeel.npcs.controllers.data.ability.gui.AbilityFieldDefs;
import kamkeel.npcs.controllers.data.telegraph.Telegraph;
@@ -137,6 +139,7 @@ public class AbilityCharge extends AbilityMovement implements IAbilityCharge {
if (!(entity instanceof EntityLivingBase)) continue;
if (entity == caster) continue;
if (hitEntities.contains(entity.getEntityId())) continue;
if (!AbilityTargetHelper.shouldAffect(caster, entity, TargetFilter.ENEMIES, false)) continue;
EntityLivingBase livingEntity = (EntityLivingBase) entity;
@@ -3,7 +3,9 @@ package kamkeel.npcs.controllers.data.ability.type;
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.AbilityTargetHelper;
import kamkeel.npcs.controllers.data.ability.LockMovementType;
import kamkeel.npcs.controllers.data.ability.TargetFilter;
import kamkeel.npcs.controllers.data.ability.TargetingMode;
import kamkeel.npcs.controllers.data.ability.gui.AbilityFieldDefs;
import kamkeel.npcs.controllers.data.telegraph.Telegraph;
@@ -247,6 +249,7 @@ public class AbilityCutter extends Ability implements IAbilityCutter {
for (EntityLivingBase entity : entities) {
if (entity == caster) continue;
if (hitEntities.contains(entity.getEntityId())) continue;
if (!AbilityTargetHelper.shouldAffect(caster, entity, TargetFilter.ENEMIES, false)) continue;
// If not piercing, stop after hitting one entity this sweep
if (!piercing && !hitEntities.isEmpty()) break;
@@ -0,0 +1,502 @@
package kamkeel.npcs.controllers.data.ability.type;
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.AbilityCustomEffect;
import kamkeel.npcs.controllers.data.ability.AbilityEffectActionEntry;
import kamkeel.npcs.controllers.data.ability.AbilityTargetHelper;
import kamkeel.npcs.controllers.data.ability.AbilityVariant;
import kamkeel.npcs.controllers.data.ability.LockMovementType;
import kamkeel.npcs.controllers.data.ability.TargetFilter;
import kamkeel.npcs.controllers.data.ability.TargetingMode;
import kamkeel.npcs.controllers.data.ability.gui.AbilityFieldDefs;
import kamkeel.npcs.controllers.data.telegraph.TelegraphType;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.nbt.NBTTagList;
import net.minecraft.util.AxisAlignedBB;
import net.minecraft.world.World;
import noppes.npcs.api.ability.type.IAbilityEffect;
import noppes.npcs.client.gui.builder.FieldDef;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* Effect ability: Apply healing, potion effects, custom effects, and mod-registered
* effect actions to self or nearby entities.
* <p>
* Supports:
* <ul>
* <li>SELF or AOE_SELF targeting modes</li>
* <li>AOE target filtering: ALLIES, ENEMIES, or ALL</li>
* <li>Healing (fixed amount + percentage)</li>
* <li>Potion effects via base Ability.effects list</li>
* <li>Custom effects from CustomEffectController (player-only)</li>
* <li>Mod-registered effect actions via IEffectAction registry</li>
* <li>Burst system for repeated reapplication (auras, debuffs)</li>
* <li>Concurrent execution alongside other abilities in chains</li>
* </ul>
*/
public class AbilityEffect extends Ability implements IAbilityEffect {
// Type-specific parameters
private int durationTicks = 60;
private float healAmount = 10.0f;
private float healPercent = 0.0f;
private boolean includeSelf = true;
private float radius = 8.0f;
private boolean instantHeal = true;
private TargetFilter targetFilter = TargetFilter.ALLIES;
// Custom effects (from CustomEffectController — player-only)
private List<AbilityCustomEffect> customEffects = new ArrayList<>();
// Mod-registered effect actions
private List<AbilityEffectActionEntry> effectActions = new ArrayList<>();
// Runtime state
private transient List<EntityLivingBase> affectedEntities;
private List<EntityLivingBase> getAffectedEntities() {
if (affectedEntities == null) {
affectedEntities = new ArrayList<>();
}
return affectedEntities;
}
public AbilityEffect() {
this.typeId = "ability.cnpc.effect";
this.name = "Effect";
this.targetingMode = TargetingMode.SELF;
this.lockMovement = LockMovementType.WINDUP;
this.cooldownTicks = 0;
this.windUpTicks = 30;
this.telegraphType = TelegraphType.NONE;
this.showTelegraph = false;
}
// ==================== ABILITY TYPE OVERRIDES ====================
@Override
public boolean hasDamage() {
return false;
}
@Override
public boolean allowBurst() {
return true;
}
@Override
public boolean isTargetingModeLocked() {
return false;
}
@Override
public TargetingMode[] getAllowedTargetingModes() {
return new TargetingMode[]{TargetingMode.SELF, TargetingMode.AOE_SELF};
}
@Override
public boolean isConcurrentCapable() {
return true;
}
@Override
public float getTelegraphRadius() {
return targetingMode == TargetingMode.AOE_SELF && radius > 0 ? radius : 0;
}
// ==================== EXECUTION ====================
@Override
public void onExecute(EntityLivingBase caster, EntityLivingBase target) {
if (caster.worldObj.isRemote && !isPreview()) return;
if (!isPreview()) {
getAffectedEntities().clear();
if (targetingMode == TargetingMode.AOE_SELF && radius > 0) {
findEntitiesInRadius(caster, caster.worldObj);
} else {
if (includeSelf) {
getAffectedEntities().add(caster);
}
}
if (instantHeal) {
for (EntityLivingBase entity : getAffectedEntities()) {
healEntity(entity);
applyAllEffects(caster, entity);
spawnHealParticles(caster.worldObj, entity);
}
}
}
if (instantHeal) {
signalCompletion();
}
}
@Override
public void onActiveTick(EntityLivingBase caster, EntityLivingBase target, int tick) {
if ((caster.worldObj.isRemote && !isPreview()) || instantHeal) return;
if (tick % 10 == 0) {
float tickHealFixed = (healAmount / (float) durationTicks) * 10;
for (EntityLivingBase entity : getAffectedEntities()) {
if (entity.isDead) continue;
float totalTickHeal = tickHealFixed;
if (healPercent > 0) {
totalTickHeal += (entity.getMaxHealth() * healPercent / (float) durationTicks) * 10;
}
if (totalTickHeal > 0) {
entity.heal(totalTickHeal);
}
if (tick % 20 == 0) {
applyAllEffects(caster, entity);
spawnHealParticles(caster.worldObj, entity);
}
}
}
if (tick >= durationTicks) {
signalCompletion();
}
}
// ==================== EFFECT APPLICATION ====================
/**
* Applies all configured effect types to a single entity:
* vanilla potion effects, custom effects, and mod-registered effect actions.
*/
private void applyAllEffects(EntityLivingBase caster, EntityLivingBase entity) {
applyEffects(entity);
applyCustomEffects(entity);
applyEffectActions(caster, entity);
}
private void applyCustomEffects(EntityLivingBase entity) {
for (AbilityCustomEffect ce : customEffects) {
if (ce.isValid()) {
ce.apply(entity);
}
}
}
private void applyEffectActions(EntityLivingBase caster, EntityLivingBase entity) {
for (AbilityEffectActionEntry ea : effectActions) {
if (ea.isValid()) {
ea.apply(caster, entity);
}
}
}
// ==================== TARGET GATHERING ====================
@SuppressWarnings("unchecked")
private void findEntitiesInRadius(EntityLivingBase caster, World world) {
AxisAlignedBB aabb = AxisAlignedBB.getBoundingBox(
caster.posX - radius, caster.posY - 2, caster.posZ - radius,
caster.posX + radius, caster.posY + 3, caster.posZ + radius
);
List<Entity> entities = world.getEntitiesWithinAABB(EntityLivingBase.class, aabb);
for (Entity entity : entities) {
if (!(entity instanceof EntityLivingBase)) continue;
EntityLivingBase living = (EntityLivingBase) entity;
float dist = caster.getDistanceToEntity(living);
if (dist > radius) continue;
if (!AbilityTargetHelper.shouldAffect(caster, living, targetFilter, includeSelf)) continue;
getAffectedEntities().add(living);
}
}
private void healEntity(EntityLivingBase entity) {
float totalHeal = healAmount;
if (healPercent > 0) {
totalHeal += entity.getMaxHealth() * healPercent;
}
if (totalHeal > 0) {
entity.heal(totalHeal);
}
}
private void spawnHealParticles(World world, EntityLivingBase entity) {
for (int i = 0; i < 10; i++) {
double offsetX = (world.rand.nextDouble() - 0.5) * entity.width;
double offsetY = world.rand.nextDouble() * entity.height;
double offsetZ = (world.rand.nextDouble() - 0.5) * entity.width;
world.spawnParticle("happyVillager",
entity.posX + offsetX,
entity.posY + offsetY,
entity.posZ + offsetZ,
0, 0.1, 0);
}
}
// ==================== LIFECYCLE ====================
@Override
public void resetForBurst() {
getAffectedEntities().clear();
}
@Override
public void cleanup() {
getAffectedEntities().clear();
}
// ==================== VARIANTS ====================
@Override
public List<AbilityVariant> getVariants() {
return Arrays.asList(
new AbilityVariant("ability.variant.selfHeal", a -> {
AbilityEffect e = (AbilityEffect) a;
a.setName("Self Heal");
e.setTargetingMode(TargetingMode.SELF);
e.setIncludeSelf(true);
e.setInstantHeal(true);
}),
new AbilityVariant("ability.variant.healingAura", a -> {
AbilityEffect e = (AbilityEffect) a;
a.setName("Healing Aura");
e.setTargetingMode(TargetingMode.AOE_SELF);
e.setTargetFilter(TargetFilter.ALLIES);
e.setIncludeSelf(true);
e.setRadius(8.0f);
e.setBurstEnabled(true);
e.setBurstAmount(5);
e.setBurstDelay(20);
}),
new AbilityVariant("ability.variant.poisonDebuff", a -> {
AbilityEffect e = (AbilityEffect) a;
a.setName("Poison Debuff");
e.setTargetingMode(TargetingMode.AOE_SELF);
e.setTargetFilter(TargetFilter.ENEMIES);
e.setIncludeSelf(false);
e.setHealAmount(0);
e.setHealPercent(0);
e.setRadius(6.0f);
e.setBurstEnabled(true);
e.setBurstAmount(3);
e.setBurstDelay(40);
})
);
}
// ==================== NBT ====================
@Override
public void writeTypeNBT(NBTTagCompound nbt) {
nbt.setInteger("durationTicks", durationTicks);
nbt.setFloat("healAmount", healAmount);
nbt.setFloat("healPercent", healPercent);
nbt.setBoolean("includeSelf", includeSelf);
nbt.setFloat("radius", radius);
nbt.setBoolean("instantHeal", instantHeal);
nbt.setString("targetFilter", targetFilter.name());
// Custom effects
NBTTagList ceList = new NBTTagList();
for (AbilityCustomEffect ce : customEffects) {
ceList.appendTag(ce.writeNBT());
}
nbt.setTag("customEffects", ceList);
// Effect actions
NBTTagList eaList = new NBTTagList();
for (AbilityEffectActionEntry ea : effectActions) {
eaList.appendTag(ea.writeNBT());
}
nbt.setTag("effectActions", eaList);
}
@Override
public void readTypeNBT(NBTTagCompound nbt) {
this.durationTicks = nbt.getInteger("durationTicks");
this.healAmount = nbt.getFloat("healAmount");
this.healPercent = nbt.getFloat("healPercent");
this.includeSelf = nbt.getBoolean("includeSelf");
this.radius = nbt.getFloat("radius");
this.instantHeal = nbt.getBoolean("instantHeal");
this.targetFilter = TargetFilter.fromString(nbt.getString("targetFilter"));
// Custom effects
customEffects.clear();
if (nbt.hasKey("customEffects")) {
NBTTagList ceList = nbt.getTagList("customEffects", 10);
for (int i = 0; i < ceList.tagCount(); i++) {
AbilityCustomEffect ce = AbilityCustomEffect.fromNBT(ceList.getCompoundTagAt(i));
if (ce.isValid()) customEffects.add(ce);
}
}
// Effect actions
effectActions.clear();
if (nbt.hasKey("effectActions")) {
NBTTagList eaList = nbt.getTagList("effectActions", 10);
for (int i = 0; i < eaList.tagCount(); i++) {
AbilityEffectActionEntry ea = AbilityEffectActionEntry.fromNBT(eaList.getCompoundTagAt(i));
effectActions.add(ea);
}
}
}
// ==================== GUI ====================
@SideOnly(Side.CLIENT)
@Override
public void getAbilityDefinitions(List<FieldDef> defs) {
defs.addAll(Arrays.asList(
FieldDef.boolField("ability.instantHeal", this::isInstantHeal, this::setInstantHeal)
.hover("ability.hover.instant"),
FieldDef.intField("ability.duration", this::getDurationTicks, this::setDurationTicks)
.range(1, 1000).visibleWhen(() -> !this.isInstantHeal()),
FieldDef.section("ability.section.healing"),
FieldDef.row(
FieldDef.floatField("ability.healAmount", this::getHealAmount, this::setHealAmount),
FieldDef.floatField("ability.healPercent", this::getHealPercent, this::setHealPercent)
),
FieldDef.section("ability.section.targeting")
.tab("Target").visibleWhen(() -> this.targetingMode == TargetingMode.AOE_SELF),
FieldDef.enumField("ability.targetFilter", TargetFilter.class,
this::getTargetFilter, this::setTargetFilter)
.tab("Target").visibleWhen(() -> this.targetingMode == TargetingMode.AOE_SELF),
FieldDef.row(
FieldDef.boolField("ability.includeSelf", this::isIncludeSelf, this::setIncludeSelf)
.visibleWhen(() -> this.targetingMode == TargetingMode.AOE_SELF),
FieldDef.floatField("gui.radius", this::getRadius, this::setRadius)
.visibleWhen(() -> this.targetingMode == TargetingMode.AOE_SELF)
).tab("Target"),
AbilityFieldDefs.effectsListField("ability.effects", this::getEffects, this::setEffects),
AbilityFieldDefs.customEffectsListField("ability.customEffects", this::getCustomEffects, this::setCustomEffects),
AbilityFieldDefs.effectActionsListField("ability.effectActions", this::getEffectActionEntries, this::setEffectActionEntries)
.visibleWhen(() -> AbilityController.Instance.hasEffectActions())
));
}
// ==================== GETTERS & SETTERS ====================
@Override
public int getDurationTicks() {
return durationTicks;
}
@Override
public void setDurationTicks(int durationTicks) {
this.durationTicks = Math.max(1, durationTicks);
}
@Override
public float getHealAmount() {
return healAmount;
}
@Override
public void setHealAmount(float healAmount) {
this.healAmount = healAmount;
}
@Override
public float getHealPercent() {
return healPercent;
}
@Override
public void setHealPercent(float healPercent) {
this.healPercent = healPercent;
}
@Override
public boolean isIncludeSelf() {
return includeSelf;
}
@Override
public void setIncludeSelf(boolean includeSelf) {
this.includeSelf = includeSelf;
}
@Override
public float getRadius() {
return radius;
}
@Override
public void setRadius(float radius) {
this.radius = radius;
}
@Override
public boolean isInstantHeal() {
return instantHeal;
}
@Override
public void setInstantHeal(boolean instantHeal) {
this.instantHeal = instantHeal;
}
public TargetFilter getTargetFilter() {
return targetFilter;
}
public void setTargetFilter(TargetFilter targetFilter) {
this.targetFilter = targetFilter;
}
@Override
public int getTargetFilterType() {
return targetFilter.ordinal();
}
@Override
public void setTargetFilterType(int filter) {
TargetFilter[] values = TargetFilter.values();
if (filter >= 0 && filter < values.length) {
this.targetFilter = values[filter];
}
}
public List<AbilityCustomEffect> getCustomEffects() {
return customEffects;
}
public void setCustomEffects(List<AbilityCustomEffect> customEffects) {
this.customEffects = customEffects != null ? customEffects : new ArrayList<>();
}
@Override
public int getCustomEffectCount() {
return customEffects.size();
}
public List<AbilityEffectActionEntry> getEffectActionEntries() {
return effectActions;
}
public void setEffectActionEntries(List<AbilityEffectActionEntry> effectActions) {
this.effectActions = effectActions != null ? effectActions : new ArrayList<>();
}
@Override
public int getEffectActionCount() {
return effectActions.size();
}
}
@@ -1,316 +0,0 @@
package kamkeel.npcs.controllers.data.ability.type;
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.LockMovementType;
import kamkeel.npcs.controllers.data.ability.TargetingMode;
import kamkeel.npcs.controllers.data.telegraph.TelegraphType;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.util.AxisAlignedBB;
import net.minecraft.world.World;
import noppes.npcs.api.ability.type.IAbilityHeal;
import noppes.npcs.client.gui.builder.FieldDef;
import noppes.npcs.entity.EntityNPCInterface;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* Heal ability: Restore health to self or allies.
* Can heal a fixed amount or percentage of max health.
*/
public class AbilityHeal extends Ability implements IAbilityHeal {
// Type-specific parameters
private int durationTicks = 60;
private float healAmount = 10.0f;
private float healPercent = 0.0f;
private boolean healSelf = true;
private boolean healAllies = false;
private float healRadius = 0.0f;
private boolean instantHeal = true;
// Runtime state
private transient List<EntityLivingBase> healedAllies;
private List<EntityLivingBase> getHealedAllies() {
if (healedAllies == null) {
healedAllies = new ArrayList<>();
}
return healedAllies;
}
public AbilityHeal() {
this.typeId = "ability.cnpc.heal";
this.name = "Heal";
this.targetingMode = TargetingMode.SELF;
this.lockMovement = LockMovementType.WINDUP;
this.cooldownTicks = 0;
this.windUpTicks = 30;
// No telegraph for heal - it's a self/ally buff
this.telegraphType = TelegraphType.NONE;
this.showTelegraph = false;
}
@Override
public boolean hasDamage() {
return false;
}
@Override
public boolean allowBurst() {
return false;
}
@Override
public boolean isTargetingModeLocked() {
return true;
}
@Override
public TargetingMode[] getAllowedTargetingModes() {
return new TargetingMode[]{TargetingMode.SELF};
}
@Override
public void onExecute(EntityLivingBase caster, EntityLivingBase target) {
if (caster.worldObj.isRemote && !isPreview()) return;
if (!isPreview()) {
getHealedAllies().clear();
// Always find allies if we're healing them (needed for both instant and HoT)
if (healAllies && healRadius > 0) {
findAlliesInRadius(caster, caster.worldObj);
}
if (instantHeal) {
// Instant heal - apply all healing now
if (healSelf) {
healEntity(caster);
spawnHealParticles(caster.worldObj, caster);
}
for (EntityLivingBase ally : getHealedAllies()) {
healEntity(ally);
spawnHealParticles(caster.worldObj, ally);
}
}
}
if (instantHeal) {
// Instant heal completes immediately
signalCompletion();
}
// If not instant, HoT healing is applied in onActiveTick
}
@Override
public void onActiveTick(EntityLivingBase caster, EntityLivingBase target, int tick) {
if ((caster.worldObj.isRemote && !isPreview()) || instantHeal) return;
// Heal over time - distribute heal across duration ticks
if (tick % 10 == 0) {
// Calculate tick-based heal for fixed amount
float tickHeal = (healAmount / (float) durationTicks) * 10;
if (healSelf) {
float selfTickHeal = tickHeal;
// Add percentage-based heal portion
if (healPercent > 0) {
selfTickHeal += (caster.getMaxHealth() * healPercent / (float) durationTicks) * 10;
}
caster.heal(selfTickHeal);
if (tick % 20 == 0) {
spawnHealParticles(caster.worldObj, caster);
}
}
if (healAllies && healRadius > 0) {
for (EntityLivingBase ally : getHealedAllies()) {
if (!ally.isDead) {
float allyTickHeal = tickHeal;
// Add percentage-based heal portion for each ally
if (healPercent > 0) {
allyTickHeal += (ally.getMaxHealth() * healPercent / (float) durationTicks) * 10;
}
ally.heal(allyTickHeal);
if (tick % 20 == 0) {
spawnHealParticles(caster.worldObj, ally);
}
}
}
}
}
// Check if heal duration has ended
if (tick >= durationTicks) {
signalCompletion();
}
}
/**
* Find all allies in radius and add them to healedAllies list.
*/
private void findAlliesInRadius(EntityLivingBase caster, World world) {
AxisAlignedBB aabb = AxisAlignedBB.getBoundingBox(
caster.posX - healRadius, caster.posY - 2, caster.posZ - healRadius,
caster.posX + healRadius, caster.posY + 3, caster.posZ + healRadius
);
@SuppressWarnings("unchecked")
List<Entity> entities = world.getEntitiesWithinAABB(EntityLivingBase.class, aabb);
for (Entity entity : entities) {
if (!(entity instanceof EntityLivingBase)) continue;
if (entity == caster) continue;
EntityLivingBase living = (EntityLivingBase) entity;
// Only heal other NPCs (allies)
if (living instanceof EntityNPCInterface) {
float dist = caster.getDistanceToEntity(living);
if (dist <= healRadius) {
getHealedAllies().add(living);
}
}
}
}
private void healEntity(EntityLivingBase entity) {
float totalHeal = healAmount;
if (healPercent > 0) {
totalHeal += entity.getMaxHealth() * healPercent;
}
entity.heal(totalHeal);
}
private void spawnHealParticles(World world, EntityLivingBase entity) {
for (int i = 0; i < 10; i++) {
double offsetX = (world.rand.nextDouble() - 0.5) * entity.width;
double offsetY = world.rand.nextDouble() * entity.height;
double offsetZ = (world.rand.nextDouble() - 0.5) * entity.width;
world.spawnParticle("happyVillager",
entity.posX + offsetX,
entity.posY + offsetY,
entity.posZ + offsetZ,
0, 0.1, 0);
}
}
@Override
public void cleanup() {
getHealedAllies().clear();
}
@Override
public float getTelegraphRadius() {
return healRadius > 0 ? healRadius : 0;
}
@Override
public void writeTypeNBT(NBTTagCompound nbt) {
nbt.setInteger("durationTicks", durationTicks);
nbt.setFloat("healAmount", healAmount);
nbt.setFloat("healPercent", healPercent);
nbt.setBoolean("healSelf", healSelf);
nbt.setBoolean("healAllies", healAllies);
nbt.setFloat("healRadius", healRadius);
nbt.setBoolean("instantHeal", instantHeal);
}
@Override
public void readTypeNBT(NBTTagCompound nbt) {
this.durationTicks = nbt.getInteger("durationTicks");
this.healAmount = nbt.getFloat("healAmount");
this.healPercent = nbt.getFloat("healPercent");
this.healSelf = nbt.getBoolean("healSelf");
this.healAllies = nbt.getBoolean("healAllies");
this.healRadius = nbt.getFloat("healRadius");
this.instantHeal = nbt.getBoolean("instantHeal");
}
// Getters & Setters
public int getDurationTicks() {
return durationTicks;
}
public void setDurationTicks(int durationTicks) {
this.durationTicks = Math.max(1, durationTicks);
}
public float getHealAmount() {
return healAmount;
}
public void setHealAmount(float healAmount) {
this.healAmount = healAmount;
}
public float getHealPercent() {
return healPercent;
}
public void setHealPercent(float healPercent) {
this.healPercent = healPercent;
}
public boolean isHealSelf() {
return healSelf;
}
public void setHealSelf(boolean healSelf) {
this.healSelf = healSelf;
}
public boolean isHealAllies() {
return healAllies;
}
public void setHealAllies(boolean healAllies) {
this.healAllies = healAllies;
}
public float getHealRadius() {
return healRadius;
}
public void setHealRadius(float healRadius) {
this.healRadius = healRadius;
}
public boolean isInstantHeal() {
return instantHeal;
}
public void setInstantHeal(boolean instantHeal) {
this.instantHeal = instantHeal;
}
@SideOnly(Side.CLIENT)
@Override
public void getAbilityDefinitions(List<FieldDef> defs) {
defs.addAll(Arrays.asList(
FieldDef.boolField("ability.instantHeal", this::isInstantHeal, this::setInstantHeal)
.hover("ability.hover.instant"),
FieldDef.intField("ability.duration", this::getDurationTicks, this::setDurationTicks)
.range(1, 1000).visibleWhen(() -> !this.isInstantHeal()),
FieldDef.section("ability.section.healing"),
FieldDef.row(
FieldDef.floatField("ability.healAmount", this::getHealAmount, this::setHealAmount),
FieldDef.floatField("ability.healPercent", this::getHealPercent, this::setHealPercent)
),
FieldDef.floatField("ability.healRadius", this::getHealRadius, this::setHealRadius),
FieldDef.row(
FieldDef.boolField("ability.healSelf", this::isHealSelf, this::setHealSelf)
.hover("ability.hover.healSelf"),
FieldDef.boolField("ability.healAllies", this::isHealAllies, this::setHealAllies)
.hover("ability.hover.healAllies")
)
));
}
}
@@ -3,7 +3,9 @@ package kamkeel.npcs.controllers.data.ability.type;
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.AbilityTargetHelper;
import kamkeel.npcs.controllers.data.ability.LockMovementType;
import kamkeel.npcs.controllers.data.ability.TargetFilter;
import kamkeel.npcs.controllers.data.ability.TargetingMode;
import kamkeel.npcs.controllers.data.ability.gui.AbilityFieldDefs;
import kamkeel.npcs.controllers.data.telegraph.TelegraphType;
@@ -106,6 +108,7 @@ public class AbilityHeavyHit extends Ability implements IAbilityHeavyHit {
for (Entity entity : entities) {
if (!(entity instanceof EntityLivingBase) || entity == caster) continue;
EntityLivingBase livingTarget = (EntityLivingBase) entity;
if (!AbilityTargetHelper.shouldAffect(caster, livingTarget, TargetFilter.ENEMIES, false)) continue;
double dx = livingTarget.posX - caster.posX;
double dz = livingTarget.posZ - caster.posZ;
@@ -3,7 +3,9 @@ package kamkeel.npcs.controllers.data.ability.type;
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.AbilityTargetHelper;
import kamkeel.npcs.controllers.data.ability.LockMovementType;
import kamkeel.npcs.controllers.data.ability.TargetFilter;
import kamkeel.npcs.controllers.data.ability.TargetingMode;
import kamkeel.npcs.controllers.data.ability.gui.AbilityFieldDefs;
import kamkeel.npcs.controllers.data.telegraph.TelegraphType;
@@ -72,6 +74,7 @@ public class AbilityShockwave extends Ability implements IAbilityShockwave {
for (EntityLivingBase entity : entities) {
if (entity == caster) continue;
if (entity.isDead) continue;
if (!AbilityTargetHelper.shouldAffect(caster, entity, TargetFilter.ENEMIES, false)) continue;
double dist = caster.getDistanceToEntity(entity);
if (dist > pushRadius) continue;
@@ -3,7 +3,9 @@ package kamkeel.npcs.controllers.data.ability.type;
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.AbilityTargetHelper;
import kamkeel.npcs.controllers.data.ability.LockMovementType;
import kamkeel.npcs.controllers.data.ability.TargetFilter;
import kamkeel.npcs.controllers.data.ability.TargetingMode;
import kamkeel.npcs.controllers.data.ability.gui.AbilityFieldDefs;
import kamkeel.npcs.controllers.data.telegraph.Telegraph;
@@ -360,13 +362,17 @@ public class AbilitySlam extends Ability implements IAbilitySlam {
for (Entity entity : entities) {
if (entity instanceof EntityLivingBase && entity != caster) {
EntityLivingBase livingTarget = (EntityLivingBase) entity;
if (!AbilityTargetHelper.shouldAffect(caster, livingTarget, TargetFilter.ENEMIES, false)) continue;
// Check if actually within radius (bounding box is a cube, we want a circle)
double dx = livingTarget.posX - caster.posX;
double dz = livingTarget.posZ - caster.posZ;
if (dx * dx + dz * dz <= radius * radius) {
// Apply damage with scripted event support
applyAbilityDamage(caster, livingTarget, damage, knockbackStrength);
boolean wasHit = applyAbilityDamage(caster, livingTarget, damage, knockbackStrength);
if (wasHit) {
applyEffects(livingTarget);
}
}
}
}
@@ -3,7 +3,9 @@ package kamkeel.npcs.controllers.data.ability.type;
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.AbilityTargetHelper;
import kamkeel.npcs.controllers.data.ability.LockMovementType;
import kamkeel.npcs.controllers.data.ability.TargetFilter;
import kamkeel.npcs.controllers.data.ability.TargetingMode;
import kamkeel.npcs.controllers.data.ability.gui.AbilityFieldDefs;
import kamkeel.npcs.controllers.data.telegraph.TelegraphType;
@@ -91,6 +93,7 @@ public class AbilityVortex extends Ability implements IAbilityVortex {
for (EntityLivingBase entity : entities) {
if (entity == caster) continue;
if (entity.isDead) continue;
if (!AbilityTargetHelper.shouldAffect(caster, entity, TargetFilter.ENEMIES, false)) continue;
double dist = caster.getDistanceToEntity(entity);
if (dist <= pullRadius) {
@@ -7,6 +7,8 @@ import cpw.mods.fml.relauncher.SideOnly;
import io.netty.buffer.ByteBuf;
import kamkeel.npcs.controllers.data.ability.Ability;
import kamkeel.npcs.controllers.data.ability.AbilityPotionEffect;
import kamkeel.npcs.controllers.data.ability.AbilityTargetHelper;
import kamkeel.npcs.controllers.data.ability.TargetFilter;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.player.EntityPlayer;
@@ -357,6 +359,7 @@ public class EntityAbilityZone extends Entity implements IEntityAdditionalSpawnD
if (owner != null && entity == owner) continue;
if (entity.isDead) continue;
if (maxTriggers == 1 && triggeredEntities.contains(entity.getUniqueID())) continue;
if (owner instanceof EntityLivingBase && !AbilityTargetHelper.shouldAffect((EntityLivingBase) owner, entity, TargetFilter.ENEMIES, false)) continue;
double dx = entity.posX - posX;
double dz = entity.posZ - posZ;
@@ -391,6 +394,7 @@ public class EntityAbilityZone extends Entity implements IEntityAdditionalSpawnD
for (EntityLivingBase entity : entities) {
if (owner != null && entity == owner) continue;
if (owner instanceof EntityLivingBase && !AbilityTargetHelper.shouldAffect((EntityLivingBase) owner, entity, TargetFilter.ENEMIES, false)) continue;
double dx = entity.posX - posX;
double dz = entity.posZ - posZ;
if (shape == ZoneShape.SQUARE) {
@@ -464,6 +468,7 @@ public class EntityAbilityZone extends Entity implements IEntityAdditionalSpawnD
for (EntityLivingBase entity : entities) {
if (owner != null && entity == owner && !affectsCaster) continue;
if (damagedThisTick.contains(entity.getEntityId())) continue;
if (entity != owner && owner instanceof EntityLivingBase && !AbilityTargetHelper.shouldAffect((EntityLivingBase) owner, entity, TargetFilter.ENEMIES, false)) continue;
if (!isInZone(entity)) continue;
if (damagePerSecond > 0) {
@@ -3,6 +3,7 @@ package kamkeel.npcs.util;
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 noppes.npcs.LogWriter;
import noppes.npcs.controllers.AnimationController;
import noppes.npcs.controllers.data.Animation;
@@ -173,4 +174,37 @@ public class Register<T> {
return new Register.Animations(modClass, animationsPath, namespace);
}
}
public static class EffectActions extends Register<IEffectAction> {
private EffectActions(String namespace) {
super("effect_action", namespace);
}
public IEffectAction register(String name, IEffectAction action) {
String key = namespace + ":" + name.trim().toLowerCase().replaceAll(" ", "_");
entries.put(key, () -> action);
return action;
}
public void register() {
for (Map.Entry<String, Supplier<IEffectAction>> entry : entries.entrySet()) {
AbilityController.Instance.registerEffectAction(entry.getValue().get());
}
}
public static Register.EffectActions create(String namespace, String displayName) {
if (!REGISTERED_NAMESPACES.containsKey("effect_action"))
REGISTERED_NAMESPACES.put("effect_action", new ArrayList<>());
if (REGISTERED_NAMESPACES.get("effect_action").contains(namespace)) {
LogWriter.error("REGISTER EFFECT ACTIONS: Namespace " + namespace + " already registered!");
}
REGISTERED_NAMESPACES.get("effect_action").add(namespace);
NAMESPACE_DISPLAY_NAMES.put(namespace, displayName);
return new Register.EffectActions(namespace);
}
}
}
@@ -5,6 +5,7 @@ import kamkeel.npcs.controllers.data.ability.Ability;
import kamkeel.npcs.controllers.data.ability.AbilityPhase;
import kamkeel.npcs.controllers.data.ability.ChainedAbility;
import kamkeel.npcs.controllers.data.ability.ChainedAbilityEntry;
import kamkeel.npcs.controllers.data.ability.ConcurrentSlot;
import kamkeel.npcs.controllers.data.ability.ToggleEntry;
import kamkeel.npcs.controllers.data.telegraph.TelegraphInstance;
import net.minecraft.entity.EntityLivingBase;
@@ -13,6 +14,7 @@ import noppes.npcs.controllers.AnimationController;
import noppes.npcs.controllers.data.Animation;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
@@ -74,6 +76,12 @@ public abstract class AbstractDataAbilities {
*/
protected boolean interruptCooldownRolled = false;
/**
* Concurrent ability execution slots. Ticked independently alongside the primary ability.
* Concurrent abilities skip animations, sounds, and movement/rotation locks.
*/
protected List<ConcurrentSlot> concurrentSlots = new ArrayList<>();
// ═══════════════════════════════════════════════════════════════════
// ABSTRACT METHODS - Subclasses must implement
// ═══════════════════════════════════════════════════════════════════
@@ -606,8 +614,12 @@ public abstract class AbstractDataAbilities {
return;
}
}
startChainEntry(chainTarget);
if (startChainEntry(chainTarget)) {
launchConsecutiveConcurrentEntries(chainTarget);
}
}
// Tick concurrent slots even during chain delay
tickConcurrentSlots();
return;
}
@@ -747,6 +759,9 @@ public abstract class AbstractDataAbilities {
// Post-phase hook (NPC: hit scan + movement control)
onPostPhaseTick(currentAbility, target);
// Tick concurrent slots independently
tickConcurrentSlots();
}
// ═══════════════════════════════════════════════════════════════════
@@ -784,6 +799,10 @@ public abstract class AbstractDataAbilities {
int delay = completedEntry.getDelayTicks();
chainEntryIndex++;
// Skip any consecutive concurrent entries — launch them to concurrent slots
launchConsecutiveConcurrentEntries(target);
if (chainEntryIndex < currentChain.getEntries().size()) {
// Check if target died and retarget
if (target != null && target.isDead) {
@@ -884,6 +903,9 @@ public abstract class AbstractDataAbilities {
chainDelayRemaining = -1;
}
// Interrupt all concurrent slots
interruptConcurrentSlots();
// Let subclass handle cleanup
onInterruptComplete();
}
@@ -915,7 +937,11 @@ public abstract class AbstractDataAbilities {
chainDelayRemaining = -1;
// AFTER semantics: no delay before first entry (delay applies after each entry completes)
return startChainEntry(target);
boolean started = startChainEntry(target);
if (started) {
launchConsecutiveConcurrentEntries(target);
}
return started;
}
/**
@@ -983,8 +1009,74 @@ public abstract class AbstractDataAbilities {
return true;
}
// ═══════════════════════════════════════════════════════════════════
// CONCURRENT SLOT MANAGEMENT
// ═══════════════════════════════════════════════════════════════════
/**
* Tick all active concurrent slots. Remove completed ones.
* Called from tickCurrentAbility() and during chain delay countdown.
*/
protected void tickConcurrentSlots() {
if (concurrentSlots.isEmpty()) return;
EntityLivingBase entity = getEntity();
EntityLivingBase target = getTarget();
Iterator<ConcurrentSlot> it = concurrentSlots.iterator();
while (it.hasNext()) {
ConcurrentSlot slot = it.next();
slot.tick(entity, target);
if (slot.isCompleted()) {
it.remove();
}
}
}
/**
* After starting a primary chain entry, scan forward and launch any consecutive
* concurrent entries (with delay=0) to concurrent slots immediately.
* This enables simultaneous execution of Effect abilities alongside the primary.
*/
protected void launchConsecutiveConcurrentEntries(EntityLivingBase target) {
if (currentChain == null) return;
List<ChainedAbilityEntry> entries = currentChain.getEntries();
while (chainEntryIndex + 1 < entries.size()) {
ChainedAbilityEntry nextEntry = entries.get(chainEntryIndex + 1);
Ability resolved = nextEntry.resolve();
if (resolved == null || !resolved.isConcurrentCapable()
|| !nextEntry.isConcurrentEnabled()) break;
// Only auto-launch concurrent entries with 0 delay
if (nextEntry.getDelayTicks() > 0) break;
// Advance past this entry in the chain (it runs concurrently, not sequentially)
chainEntryIndex++;
// Deep copy the ability so it has its own state
Ability concurrentCopy = AbilityController.Instance.fromNBT(resolved.writeNBT());
if (concurrentCopy == null) continue;
ConcurrentSlot slot = new ConcurrentSlot(concurrentCopy);
concurrentSlots.add(slot);
slot.start(getEntity(), target);
}
}
/**
* Interrupt all active concurrent slots. Called on ability interrupt or combat reset.
*/
protected void interruptConcurrentSlots() {
for (ConcurrentSlot slot : concurrentSlots) {
slot.interrupt();
}
concurrentSlots.clear();
}
/**
* Complete the chain execution. Rolls chain cooldown and clears all chain state.
* NOTE: Does NOT clear concurrent slots — they outlive the chain and tick independently.
*/
protected void completeChain() {
if (currentChain != null) {
+3 -1
View File
@@ -326,10 +326,11 @@ public class DataAbilities extends AbstractDataAbilities {
if (rotationLocked || hitScanActive) releaseRotationControl();
if (positionLocked) releaseLockedPosition();
}
// Clear chain state
// Clear chain and concurrent state
currentChain = null;
chainEntryIndex = -1;
chainDelayRemaining = -1;
interruptConcurrentSlots();
return;
}
@@ -724,6 +725,7 @@ public class DataAbilities extends AbstractDataAbilities {
public void reset() {
stopCurrentAbility();
clearActiveToggles();
interruptConcurrentSlots();
// Roll cooldown so NPC doesn't immediately attack after reset
rollCooldownOnReset();
@@ -34,6 +34,7 @@ import noppes.npcs.constants.EnumScrollData;
import noppes.npcs.entity.EntityNPCInterface;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
@@ -187,7 +188,7 @@ public class GuiNPCAbilities extends GuiNPCInterface2 implements IScrollData, IC
}
availableTypesScroll.guiLeft = guiLeft + 5;
availableTypesScroll.guiTop = y + 12;
availableTypesScroll.setList(getFilteredTypeList());
availableTypesScroll.setUnsortedList(getFilteredTypeList());
addScroll(availableTypesScroll);
// Search bar for types
@@ -541,7 +542,7 @@ public class GuiNPCAbilities extends GuiNPCInterface2 implements IScrollData, IC
filteredAbilityTypes.putAll(getFilteredData(allAbilityTypes));
if (availableTypesScroll != null) {
availableTypesScroll.setList(getFilteredTypeList());
availableTypesScroll.setUnsortedList(getFilteredTypeList());
}
} else if (type == EnumScrollData.CUSTOM_ABILITIES) {
existingPresetNames.clear();
@@ -605,7 +606,7 @@ public class GuiNPCAbilities extends GuiNPCInterface2 implements IScrollData, IC
if (search.equals(getTextField(TF_SEARCH).getText()))
return;
search = getTextField(TF_SEARCH).getText().toLowerCase();
availableTypesScroll.setList(getFilteredTypeList());
availableTypesScroll.setUnsortedList(getFilteredTypeList());
availableTypesScroll.resetScroll();
}
}
@@ -640,16 +641,21 @@ public class GuiNPCAbilities extends GuiNPCInterface2 implements IScrollData, IC
displayNameToTypeId.clear();
for (String typeId : filteredAbilityTypes.keySet()) {
String displayName = I18n.format(typeId);
// Search matches either the display name or the typeId
if (search.isEmpty() || displayName.toLowerCase().contains(search) || typeId.toLowerCase().contains(search)) {
// Gray out built-in types to distinguish them from configurable types
if (AbilityController.Instance.isBuiltInType(typeId)) {
// Search matches either the display name or the typeId (strip color codes for matching)
String stripped = displayName.replaceAll("\u00A7.", "");
if (search.isEmpty() || stripped.toLowerCase().contains(search) || typeId.toLowerCase().contains(search)) {
// Yellow for concurrent-capable types, gray for other built-in types
if (AbilityController.Instance.isConcurrentCapableType(typeId)) {
displayName = "\u00A7e" + displayName;
} else if (AbilityController.Instance.isBuiltInType(typeId)) {
displayName = "\u00A77" + displayName;
}
list.add(displayName);
displayNameToTypeId.put(displayName, typeId);
}
}
Collections.sort(list, (a, b) -> String.CASE_INSENSITIVE_ORDER.compare(
a.replaceAll("\u00A7.", ""), b.replaceAll("\u00A7.", "")));
return list;
}
@@ -144,9 +144,12 @@ public class SubGuiAbilityConfig extends SubGuiInterface implements ITextfieldLi
int y = 5;
int labelCounter = LABEL_ID_START;
// General tab: type label at top — need to reserve space before building
// General tab: type label + optional concurrent label at top — reserve space
if (activeTab == TAB_GENERAL) {
y += ROW_H;
if (ability.isConcurrentCapable()) {
y += 15;
}
}
// Build declarative fields into an auto-created scroll window
@@ -157,10 +160,15 @@ public class SubGuiAbilityConfig extends SubGuiInterface implements ITextfieldLi
GuiScrollWindow sw = builder.buildScrollWindow(tabFields, swX, swY, swW, swH);
// General tab: add type label at top of scroll window
// General tab: add type label + optional concurrent label at top of scroll window
if (activeTab == TAB_GENERAL) {
sw.addLabel(new GuiNpcLabel(builder.getNextLabelId(), "gui.type", 5, 5 + 5, 0xFFFFFF));
sw.addLabel(new GuiNpcLabel(builder.getNextLabelId() + 1, ability.getTypeId(), 55, 5 + 5, 0xFFFFFF));
int baseId = builder.getNextLabelId();
sw.addLabel(new GuiNpcLabel(baseId, "gui.type", 5, 10, 0xFFFFFF));
sw.addLabel(new GuiNpcLabel(baseId + 1, ability.getTypeId(), 55, 10, 0xFFFFFF));
if (ability.isConcurrentCapable()) {
sw.addLabel(new GuiNpcLabel(baseId + 2,
StatCollector.translateToLocal("ability.concurrentInfo"), 5, 25, 0x55FF55));
}
}
// Conditions on target tab — appended after field defs
@@ -11,6 +11,7 @@ import noppes.npcs.client.gui.util.ITextfieldListener;
import noppes.npcs.client.gui.util.SubGuiInterface;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@@ -47,7 +48,7 @@ public class SubGuiAbilityTypeSelect extends SubGuiInterface implements ICustomS
addScroll(scroll);
buildAllTypes();
scroll.setList(getFilteredTypeList());
scroll.setUnsortedList(getFilteredTypeList());
addButton(new GuiNpcButton(0, guiLeft + 5, guiTop + 188, 90, 20, "gui.add"));
getButton(0).setEnabled(scroll.hasSelected());
@@ -59,6 +60,9 @@ public class SubGuiAbilityTypeSelect extends SubGuiInterface implements ICustomS
String[] types = AbilityController.Instance.getTypes();
for (String typeId : types) {
String displayName = I18n.format(typeId);
if (AbilityController.Instance.isConcurrentCapableType(typeId)) {
displayName = "\u00A7e" + displayName;
}
allDisplayNameToTypeId.put(displayName, typeId);
}
}
@@ -68,11 +72,14 @@ public class SubGuiAbilityTypeSelect extends SubGuiInterface implements ICustomS
displayNameToTypeId.clear();
for (Map.Entry<String, String> entry : allDisplayNameToTypeId.entrySet()) {
String displayName = entry.getKey();
if (search.isEmpty() || displayName.toLowerCase().contains(search) || entry.getValue().toLowerCase().contains(search)) {
String stripped = displayName.replaceAll("\u00A7.", "");
if (search.isEmpty() || stripped.toLowerCase().contains(search) || entry.getValue().toLowerCase().contains(search)) {
list.add(displayName);
displayNameToTypeId.put(displayName, entry.getValue());
}
}
Collections.sort(list, (a, b) -> String.CASE_INSENSITIVE_ORDER.compare(
a.replaceAll("\u00A7.", ""), b.replaceAll("\u00A7.", "")));
return list;
}
@@ -144,7 +144,7 @@ public class SubGuiChainedAbilityConfig extends SubGuiInterface implements IText
// Computed "Valid For" label (derived from child abilities)
fieldDefs.add(FieldDef.labelField("ability.validFor", () -> {
UserType ut = computeAllowedBy();
return StatCollector.translateToLocal("ability.validFor") + ": \u00A7e" + StatCollector.translateToLocal("ability.userType." + ut.name());
return "\u00A7e" + StatCollector.translateToLocal("ability.userType." + ut.name());
}).tab("General"));
fieldDefs.add(FieldDef.boolField("gui.enabled", chain::isEnabled, chain::setEnabled).tab("General"));
fieldDefs.add(FieldDef.intField("ability.weight", chain::getWeight, chain::setWeight).range(1, 100).tab("General"));
@@ -325,12 +325,22 @@ public class SubGuiChainedAbilityConfig extends SubGuiInterface implements IText
sw.addButton(entryBtn);
if (!readOnlyEntries) {
// Check if this entry is concurrent-active (delay disabled)
Ability resolvedAbility = entry.resolve();
boolean isConcurrentActive = resolvedAbility != null
&& resolvedAbility.isConcurrentCapable()
&& entry.isConcurrentEnabled();
// Delay label + field
sw.addLabel(new GuiNpcLabel(labelCounter++, "ability.delay", L_LABEL_X + 160, y + 5, 0xAAAAAA));
sw.addLabel(new GuiNpcLabel(labelCounter++, "ability.delay", L_LABEL_X + 160, y + 5,
isConcurrentActive ? 0x555555 : 0xAAAAAA));
GuiNpcTextField delayField = new GuiNpcTextField(ENTRY_BASE + i * ENTRY_STRIDE + 1, this, fontRendererObj,
L_LABEL_X + 195, y, 40, 20, String.valueOf(entry.getDelayTicks()));
delayField.setIntegersOnly();
delayField.setMinMaxDefault(0, 6000, 0);
if (isConcurrentActive) {
delayField.setEnabled(false);
}
sw.addTextField(delayField);
// Up button
@@ -343,8 +353,16 @@ public class SubGuiChainedAbilityConfig extends SubGuiInterface implements IText
sw.addButton(new GuiNpcButton(ENTRY_BASE + i * ENTRY_STRIDE + 3, L_LABEL_X + 263, y, 20, 20, "\u2193"));
}
// Concurrent toggle (only shown if resolved ability is concurrent-capable, never for first entry)
if (i > 0 && resolvedAbility != null && resolvedAbility.isConcurrentCapable()) {
String cLabel = entry.isConcurrentEnabled() ? "\u00A7aC" : "\u00A77C";
GuiNpcButton cBtn = new GuiNpcButton(ENTRY_BASE + i * ENTRY_STRIDE + 5, L_LABEL_X + 288, y, 20, 20, cLabel);
cBtn.setHoverText("ability.hover.concurrent");
sw.addButton(cBtn);
}
// Delete button
sw.addButton(new GuiNpcButton(ENTRY_BASE + i * ENTRY_STRIDE + 4, L_LABEL_X + 288, y, 20, 20, "X"));
sw.addButton(new GuiNpcButton(ENTRY_BASE + i * ENTRY_STRIDE + 4, L_LABEL_X + 313, y, 20, 20, "X"));
} else {
// Read-only: show delay as label only
int delay = entry.getDelayTicks();
@@ -549,6 +567,10 @@ public class SubGuiChainedAbilityConfig extends SubGuiInterface implements IText
if (entryIndex > 0) {
ChainedAbilityEntry entry = entries.remove(entryIndex);
entries.add(entryIndex - 1, entry);
// Can't be concurrent at position 0
if (entryIndex - 1 == 0) {
entry.setConcurrentEnabled(false);
}
initGui();
}
return true;
@@ -563,6 +585,15 @@ public class SubGuiChainedAbilityConfig extends SubGuiInterface implements IText
entries.remove(entryIndex);
initGui();
return true;
case 5: // Concurrent toggle
ChainedAbilityEntry toggleEntry = entries.get(entryIndex);
boolean newState = !toggleEntry.isConcurrentEnabled();
toggleEntry.setConcurrentEnabled(newState);
if (newState) {
toggleEntry.setDelayTicks(0);
}
initGui();
return true;
}
}
@@ -0,0 +1,149 @@
package noppes.npcs.client.gui.advanced;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
import net.minecraft.client.gui.GuiButton;
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.CustomEffectController;
import noppes.npcs.controllers.data.CustomEffect;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* SubGui for selecting a custom effect from CustomEffectController.
*/
@SideOnly(Side.CLIENT)
public class SubGuiCustomEffectSelect extends SubGuiInterface implements ICustomScrollListener, ITextfieldListener {
private GuiCustomScroll scroll;
private final HashMap<String, Integer> displayNameToId = new HashMap<>();
private final HashMap<String, Integer> allDisplayNameToId = new HashMap<>();
private int selectedEffectId = -1;
private String search = "";
private final int preselectedId;
public SubGuiCustomEffectSelect(int preselectedId) {
this.preselectedId = preselectedId;
setBackground("menubg.png");
xSize = 200;
ySize = 216;
}
@Override
public void initGui() {
super.initGui();
addTextField(new GuiNpcTextField(10, this, fontRendererObj, guiLeft + 5, guiTop + 5, 190, 18, search));
if (scroll == null) {
scroll = new GuiCustomScroll(this, 0);
scroll.setSize(190, 145);
}
scroll.guiLeft = guiLeft + 5;
scroll.guiTop = guiTop + 26;
addScroll(scroll);
buildAllEffects();
List<String> filtered = getFilteredList();
scroll.setUnsortedList(filtered);
// Pre-select current effect
if (preselectedId >= 0 && !scroll.hasSelected()) {
for (String name : filtered) {
Integer id = displayNameToId.get(name);
if (id != null && id == preselectedId) {
scroll.setSelected(name);
break;
}
}
}
addButton(new GuiNpcButton(0, guiLeft + 5, guiTop + 188, 90, 20, "gui.select"));
getButton(0).setEnabled(scroll.hasSelected());
addButton(new GuiNpcButton(1, guiLeft + 105, guiTop + 188, 90, 20, "gui.cancel"));
}
private void buildAllEffects() {
allDisplayNameToId.clear();
HashMap<Integer, CustomEffect> effects = CustomEffectController.getInstance().getCustomEffects();
if (effects == null) return;
for (CustomEffect ce : effects.values()) {
if (ce.getName() != null && !ce.getName().isEmpty()) {
allDisplayNameToId.put(ce.getName(), ce.id);
}
}
}
private List<String> getFilteredList() {
List<String> list = new ArrayList<>();
displayNameToId.clear();
for (Map.Entry<String, Integer> entry : allDisplayNameToId.entrySet()) {
String name = entry.getKey();
if (search.isEmpty() || name.toLowerCase().contains(search)) {
list.add(name);
displayNameToId.put(name, entry.getValue());
}
}
Collections.sort(list, String.CASE_INSENSITIVE_ORDER);
return list;
}
@Override
public void buttonEvent(GuiButton guibutton) {
if (guibutton.id == 0 && scroll.hasSelected()) {
String name = scroll.getSelected();
Integer id = displayNameToId.get(name);
selectedEffectId = id != null ? id : -1;
close();
} else if (guibutton.id == 1) {
selectedEffectId = -1;
close();
}
}
@Override
public void customScrollClicked(int i, int j, int k, GuiCustomScroll guiCustomScroll) {
if (guiCustomScroll.id == 0) {
getButton(0).setEnabled(scroll.hasSelected());
}
}
@Override
public void customScrollDoubleClicked(String selection, GuiCustomScroll guiCustomScroll) {
if (guiCustomScroll.id == 0 && selection != null) {
Integer id = displayNameToId.get(selection);
selectedEffectId = id != null ? id : -1;
close();
}
}
@Override
public void keyTyped(char c, int i) {
super.keyTyped(c, i);
if (getTextField(10) != null && getTextField(10).isFocused()) {
String newSearch = getTextField(10).getText().toLowerCase();
if (!search.equals(newSearch)) {
search = newSearch;
scroll.setUnsortedList(getFilteredList());
scroll.resetScroll();
}
}
}
@Override
public void unFocused(GuiNpcTextField textField) {
}
public int getSelectedEffectId() {
return selectedEffectId;
}
}
@@ -15,5 +15,7 @@ public enum FieldType {
SECTION_HEADER,
LABEL,
EFFECTS_LIST,
CUSTOM_EFFECTS_LIST,
EFFECT_ACTIONS_LIST,
ROW
}
@@ -635,10 +635,11 @@ public class PlayerAbilityData extends AbstractDataAbilities implements IPlayerA
releaseLockedPosition();
}
// Clear chain state
// Clear chain and concurrent state
currentChain = null;
chainEntryIndex = -1;
chainDelayRemaining = -1;
interruptConcurrentSlots();
// Clear all transient state
currentAbility = null;