mirror of
https://github.com/KAMKEEL/CustomNPC-Plus.git
synced 2026-11-18 13:49:05 +00:00
Create IAbilityEffect + Concurrent Ability Support for Chained Abilities
This commit is contained in:
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) {
|
||||
|
||||
@@ -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;
|
||||
|
||||
Reference in new issue
Block a user