mirror of
https://github.com/KAMKEEL/CustomNPC-Plus.git
synced 2026-11-18 12:39:05 +00:00
Merge branch 'ability' into dev
This commit is contained in:
commit
276465a175
82 files changed
+11914
-11
No files matched your search
@@ -69,6 +69,7 @@ import noppes.npcs.controllers.SpawnController;
|
||||
import noppes.npcs.controllers.TagController;
|
||||
import noppes.npcs.controllers.TransportController;
|
||||
import noppes.npcs.enchants.EnchantInterface;
|
||||
import kamkeel.npcs.controllers.data.ability.AbilityController;
|
||||
import noppes.npcs.entity.EntityChairMount;
|
||||
import noppes.npcs.entity.EntityCustomNpc;
|
||||
import noppes.npcs.entity.EntityMagicProjectile;
|
||||
@@ -270,6 +271,8 @@ public class CustomNpcs {
|
||||
new SpawnController();
|
||||
new LinkedNpcController();
|
||||
new AnimationController();
|
||||
new AbilityController();
|
||||
AbilityController.Instance.load();
|
||||
|
||||
LinkedItemController.getInstance().load();
|
||||
|
||||
|
||||
@@ -47,7 +47,8 @@ public class CustomNpcsPermissions {
|
||||
public static final Permission NPC_ADVANCED_TRANSPORT = new Permission("customnpcs.npc.advanced.transport");
|
||||
public static final Permission NPC_ADVANCED_TRANSFORM = new Permission("customnpcs.npc.advanced.transform");
|
||||
public static final Permission NPC_ADVANCED_LINKED = new Permission("customnpcs.npc.advanced.linked");
|
||||
public static final Permission NPC_ADVANCED_MAGIC = new Permission("customnpcs.npc.advanced.linked");
|
||||
public static final Permission NPC_ADVANCED_MAGIC = new Permission("customnpcs.npc.advanced.magic");
|
||||
public static final Permission NPC_ADVANCED_ABILITIES = new Permission("customnpcs.npc.advanced.abilities");
|
||||
public static final Permission NPC_ADVANCED_TAGS = new Permission("customnpcs.npc.advanced.tags");
|
||||
|
||||
public static final Permission GLOBAL_REMOTE = new Permission("customnpcs.global.remote");
|
||||
|
||||
@@ -0,0 +1,725 @@
|
||||
package noppes.npcs;
|
||||
|
||||
import kamkeel.npcs.controllers.data.ability.Ability;
|
||||
import kamkeel.npcs.controllers.data.ability.AbilityPhase;
|
||||
import kamkeel.npcs.controllers.data.ability.AbilityController;
|
||||
import kamkeel.npcs.controllers.data.ability.telegraph.TelegraphInstance;
|
||||
import kamkeel.npcs.network.packets.data.ability.TelegraphRemovePacket;
|
||||
import kamkeel.npcs.network.packets.data.ability.TelegraphSpawnPacket;
|
||||
import net.minecraft.entity.EntityLivingBase;
|
||||
import net.minecraft.nbt.NBTTagCompound;
|
||||
import net.minecraft.nbt.NBTTagList;
|
||||
import net.minecraft.util.DamageSource;
|
||||
import noppes.npcs.controllers.AnimationController;
|
||||
import noppes.npcs.controllers.data.Animation;
|
||||
import noppes.npcs.entity.EntityNPCInterface;
|
||||
import noppes.npcs.scripted.NpcAPI;
|
||||
import noppes.npcs.scripted.event.AbilityEvent;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.Random;
|
||||
|
||||
/**
|
||||
* Manages NPC abilities - storage, selection, execution, and cooldowns.
|
||||
* Follows the DataStats/DataAI pattern for NPC data management.
|
||||
*/
|
||||
public class DataAbilities {
|
||||
|
||||
private final EntityNPCInterface npc;
|
||||
private final Random random = new Random();
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
// CONFIGURATION (saved to NBT)
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
|
||||
/** List of abilities this NPC can use */
|
||||
private List<Ability> abilities = new ArrayList<>();
|
||||
|
||||
/** Whether the ability system is enabled for this NPC */
|
||||
public boolean enabled = false;
|
||||
|
||||
/** Minimum ticks between ability selections (global cooldown) */
|
||||
public int globalCooldown = 20;
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
// RUNTIME STATE (not saved)
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
|
||||
/** Currently executing ability (null if none) */
|
||||
private transient Ability currentAbility;
|
||||
|
||||
/** Per-ability cooldown timers (ability ID -> world time when cooldown ends) */
|
||||
private transient Map<String, Long> cooldowns = new HashMap<>();
|
||||
|
||||
/** Ticks until next ability can be selected (global cooldown timer) */
|
||||
private transient int globalCooldownTimer = 0;
|
||||
|
||||
/** Last target used for ability execution */
|
||||
private transient EntityLivingBase lastTarget;
|
||||
|
||||
/** Recent hit timestamps for hit count condition */
|
||||
private transient List<Long> recentHitTimes = new ArrayList<>();
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
// CONSTRUCTOR
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
|
||||
public DataAbilities(EntityNPCInterface npc) {
|
||||
this.npc = npc;
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
// TICK - Called from EntityNPCInterface.onLivingUpdate()
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
|
||||
/**
|
||||
* Main tick method - handles ability execution and cooldown management.
|
||||
* Should be called every tick from onLivingUpdate().
|
||||
*/
|
||||
public void tick() {
|
||||
if (!enabled || npc.worldObj.isRemote || npc.isKilled()) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Tick global cooldown
|
||||
if (globalCooldownTimer > 0) {
|
||||
globalCooldownTimer--;
|
||||
}
|
||||
|
||||
// Tick current ability if executing
|
||||
if (currentAbility != null && currentAbility.isExecuting()) {
|
||||
tickCurrentAbility();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Tick the currently executing ability.
|
||||
*/
|
||||
private void tickCurrentAbility() {
|
||||
EntityLivingBase target = lastTarget != null ? lastTarget : npc.getAttackTarget();
|
||||
AbilityPhase oldPhase = currentAbility.getPhase();
|
||||
|
||||
// Tick advances time and possibly changes phase
|
||||
boolean phaseChanged = currentAbility.tick();
|
||||
|
||||
// Fire tick event for scripts
|
||||
fireTickEvent(currentAbility, target);
|
||||
|
||||
// Handle phase-specific logic
|
||||
switch (currentAbility.getPhase()) {
|
||||
case WINDUP:
|
||||
currentAbility.onWindUpTick(npc, target, npc.worldObj, currentAbility.getCurrentTick());
|
||||
break;
|
||||
|
||||
case ACTIVE:
|
||||
if (phaseChanged && oldPhase == AbilityPhase.WINDUP) {
|
||||
// Just entered ACTIVE phase - lock telegraph position if it was following
|
||||
// This commits the ability to its current target position
|
||||
TelegraphInstance telegraph = currentAbility.getTelegraphInstance();
|
||||
if (telegraph != null) {
|
||||
telegraph.lockPosition();
|
||||
}
|
||||
|
||||
// Remove telegraph - it has served its purpose
|
||||
removeTelegraph(currentAbility);
|
||||
|
||||
// Play active sound and animation
|
||||
playAbilitySound(currentAbility.getActiveSound());
|
||||
playAbilityAnimation(currentAbility.getActiveAnimationId());
|
||||
|
||||
// Fire execute event (cancelable)
|
||||
AbilityEvent.ExecuteEvent executeEvent = new AbilityEvent.ExecuteEvent(
|
||||
npc.wrappedNPC, currentAbility, target);
|
||||
if (NpcAPI.EVENT_BUS.post(executeEvent)) {
|
||||
// Event was cancelled - skip execution but continue to recovery
|
||||
return;
|
||||
}
|
||||
|
||||
// Call onExecute
|
||||
currentAbility.onExecute(npc, target, npc.worldObj);
|
||||
}
|
||||
currentAbility.onActiveTick(npc, target, npc.worldObj, currentAbility.getCurrentTick());
|
||||
break;
|
||||
|
||||
case RECOVERY:
|
||||
// Recovery phase - just wait
|
||||
break;
|
||||
|
||||
case IDLE:
|
||||
// Ability completed
|
||||
currentAbility.onComplete(npc, target);
|
||||
|
||||
// Fire complete event
|
||||
AbilityEvent.CompleteEvent completeEvent = new AbilityEvent.CompleteEvent(
|
||||
npc.wrappedNPC, currentAbility, target);
|
||||
NpcAPI.EVENT_BUS.post(completeEvent);
|
||||
|
||||
onAbilityComplete();
|
||||
break;
|
||||
}
|
||||
|
||||
// Clear AI pathfinding if ability is controlling movement
|
||||
// But DON'T zero motion - let the ability set it if needed
|
||||
if (currentAbility != null && currentAbility.isExecuting()) {
|
||||
if (isAbilityControllingMovement()) {
|
||||
// Clear navigator so AI doesn't fight with ability movement
|
||||
npc.getNavigator().clearPathEntity();
|
||||
|
||||
// Only zero motion if lockMovement is true AND ability doesn't have its own movement
|
||||
// This allows stationary abilities to freeze the NPC, while movement abilities can set their own motion
|
||||
if (currentAbility.isLockMovement() && !currentAbility.hasAbilityMovement()) {
|
||||
npc.motionX = 0;
|
||||
npc.motionZ = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Called when an ability completes.
|
||||
*/
|
||||
private void onAbilityComplete() {
|
||||
if (currentAbility != null) {
|
||||
// Stop any ability animation
|
||||
stopAbilityAnimation();
|
||||
|
||||
// Start per-ability cooldown
|
||||
startCooldown(currentAbility);
|
||||
currentAbility = null;
|
||||
lastTarget = null;
|
||||
|
||||
// Start global cooldown
|
||||
globalCooldownTimer = globalCooldown;
|
||||
}
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
// ABILITY SELECTION - Called from CombatHandler
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
|
||||
/**
|
||||
* Try to select and start an ability for the given target.
|
||||
* Called by CombatHandler when NPC is in combat and ready for an ability.
|
||||
*
|
||||
* @param target The combat target
|
||||
* @return true if an ability was started
|
||||
*/
|
||||
public boolean trySelectAndStart(EntityLivingBase target) {
|
||||
if (!canSelectAbility()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
Ability selected = selectAbility(target);
|
||||
if (selected == null) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return startAbility(selected, target);
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if an ability can be selected right now.
|
||||
*/
|
||||
public boolean canSelectAbility() {
|
||||
if (!enabled || abilities.isEmpty()) {
|
||||
return false;
|
||||
}
|
||||
if (currentAbility != null && currentAbility.isExecuting()) {
|
||||
return false;
|
||||
}
|
||||
if (globalCooldownTimer > 0) {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Select an ability using weighted random from eligible abilities.
|
||||
*/
|
||||
private Ability selectAbility(EntityLivingBase target) {
|
||||
List<Ability> eligible = new ArrayList<>();
|
||||
int totalWeight = 0;
|
||||
|
||||
for (Ability ability : abilities) {
|
||||
if (isAbilityEligible(ability, target)) {
|
||||
eligible.add(ability);
|
||||
totalWeight += ability.getWeight();
|
||||
}
|
||||
}
|
||||
|
||||
if (eligible.isEmpty() || totalWeight <= 0) {
|
||||
return null;
|
||||
}
|
||||
|
||||
// Weighted random selection
|
||||
int roll = random.nextInt(totalWeight);
|
||||
int cumulative = 0;
|
||||
for (Ability ability : eligible) {
|
||||
cumulative += ability.getWeight();
|
||||
if (roll < cumulative) {
|
||||
return ability;
|
||||
}
|
||||
}
|
||||
|
||||
return eligible.get(eligible.size() - 1);
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if a specific ability is eligible for use.
|
||||
*/
|
||||
private boolean isAbilityEligible(Ability ability, EntityLivingBase target) {
|
||||
// Check enabled
|
||||
if (!ability.isEnabled()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Check cooldown
|
||||
if (isOnCooldown(ability)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Check if already executing
|
||||
if (ability.isExecuting()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Check range
|
||||
if (target != null) {
|
||||
float distance = npc.getDistanceToEntity(target);
|
||||
if (distance < ability.getMinRange() || distance > ability.getMaxRange()) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Check conditions
|
||||
if (!ability.checkConditions(npc, target)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Start executing an ability.
|
||||
*/
|
||||
private boolean startAbility(Ability ability, EntityLivingBase target) {
|
||||
// Fire start event (cancelable)
|
||||
AbilityEvent.StartEvent startEvent = new AbilityEvent.StartEvent(
|
||||
npc.wrappedNPC, ability, target);
|
||||
if (NpcAPI.EVENT_BUS.post(startEvent)) {
|
||||
// Event was cancelled - don't start the ability
|
||||
return false;
|
||||
}
|
||||
|
||||
currentAbility = ability;
|
||||
lastTarget = target;
|
||||
ability.start(target);
|
||||
|
||||
// Spawn telegraph and send to clients
|
||||
spawnTelegraph(ability, target);
|
||||
|
||||
// Play wind up sound if configured
|
||||
playAbilitySound(ability.getWindUpSound());
|
||||
|
||||
// Play wind up animation if configured
|
||||
playAbilityAnimation(ability.getWindUpAnimationId());
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Play a sound at the NPC's location.
|
||||
*/
|
||||
private void playAbilitySound(String sound) {
|
||||
if (sound != null && !sound.isEmpty()) {
|
||||
npc.worldObj.playSoundAtEntity(npc, sound, 1.0f, 1.0f);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Play an animation on the NPC by ID.
|
||||
*/
|
||||
private void playAbilityAnimation(int animationId) {
|
||||
if (animationId < 0) return;
|
||||
if (AnimationController.Instance == null) return;
|
||||
|
||||
Animation animation = AnimationController.Instance.animations.get(animationId);
|
||||
if (animation != null) {
|
||||
npc.display.animationData.setEnabled(true);
|
||||
npc.display.animationData.setAnimation(animation);
|
||||
npc.display.animationData.updateClient();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Stop any currently playing ability animation.
|
||||
*/
|
||||
private void stopAbilityAnimation() {
|
||||
npc.display.animationData.setAnimation(null);
|
||||
npc.display.animationData.updateClient();
|
||||
}
|
||||
|
||||
/**
|
||||
* Spawn and send telegraph for an ability.
|
||||
*/
|
||||
private void spawnTelegraph(Ability ability, EntityLivingBase target) {
|
||||
TelegraphInstance telegraph = ability.createTelegraph(npc, target);
|
||||
if (telegraph != null) {
|
||||
ability.setTelegraphInstance(telegraph);
|
||||
// Send to all nearby players
|
||||
TelegraphSpawnPacket.sendToTracking(telegraph, npc);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Remove telegraph when ability ends or is interrupted.
|
||||
*/
|
||||
private void removeTelegraph(Ability ability) {
|
||||
TelegraphInstance telegraph = ability.getTelegraphInstance();
|
||||
if (telegraph != null) {
|
||||
TelegraphRemovePacket.sendToTracking(telegraph.getInstanceId(), npc);
|
||||
ability.setTelegraphInstance(null);
|
||||
}
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
// COOLDOWN MANAGEMENT
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
|
||||
/**
|
||||
* Check if an ability is on cooldown.
|
||||
*/
|
||||
public boolean isOnCooldown(Ability ability) {
|
||||
Long endTime = cooldowns.get(ability.getId());
|
||||
if (endTime == null) {
|
||||
return false;
|
||||
}
|
||||
return npc.worldObj.getTotalWorldTime() < endTime;
|
||||
}
|
||||
|
||||
/**
|
||||
* Start cooldown for an ability.
|
||||
*/
|
||||
private void startCooldown(Ability ability) {
|
||||
long endTime = npc.worldObj.getTotalWorldTime() + ability.getCooldownTicks();
|
||||
cooldowns.put(ability.getId(), endTime);
|
||||
}
|
||||
|
||||
/**
|
||||
* Reset cooldown for a specific ability.
|
||||
*/
|
||||
public void resetCooldown(String abilityId) {
|
||||
cooldowns.remove(abilityId);
|
||||
}
|
||||
|
||||
/**
|
||||
* Reset all cooldowns.
|
||||
*/
|
||||
public void resetAllCooldowns() {
|
||||
cooldowns.clear();
|
||||
globalCooldownTimer = 0;
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
// INTERRUPTION - Called from CombatHandler on damage
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
|
||||
/**
|
||||
* Handle damage taken - may interrupt current ability.
|
||||
*
|
||||
* @param source The damage source
|
||||
* @param amount The damage amount
|
||||
* @return true if ability was interrupted
|
||||
*/
|
||||
public boolean onDamage(DamageSource source, float amount) {
|
||||
// Track hit for hit count condition
|
||||
recordHit();
|
||||
|
||||
if (currentAbility == null || !currentAbility.isExecuting()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (currentAbility.canInterrupt(source)) {
|
||||
interruptCurrentAbility(source, amount);
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Record a hit for the hit count condition.
|
||||
*/
|
||||
private void recordHit() {
|
||||
recentHitTimes.add(npc.worldObj.getTotalWorldTime());
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the number of hits received within the specified tick window.
|
||||
*
|
||||
* @param withinTicks The time window in ticks
|
||||
* @return Number of hits in that window
|
||||
*/
|
||||
public int getRecentHitCount(int withinTicks) {
|
||||
long currentTime = npc.worldObj.getTotalWorldTime();
|
||||
long cutoff = currentTime - withinTicks;
|
||||
|
||||
// Clean up old entries and count
|
||||
int count = 0;
|
||||
recentHitTimes.removeIf(time -> time < cutoff);
|
||||
for (Long time : recentHitTimes) {
|
||||
if (time >= cutoff) {
|
||||
count++;
|
||||
}
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
/**
|
||||
* Interrupt the currently executing ability.
|
||||
*/
|
||||
public void interruptCurrentAbility(DamageSource source, float damage) {
|
||||
if (currentAbility != null) {
|
||||
// Remove telegraph early
|
||||
removeTelegraph(currentAbility);
|
||||
|
||||
// Stop any ability animation
|
||||
stopAbilityAnimation();
|
||||
|
||||
// Fire interrupt event
|
||||
AbilityEvent.InterruptEvent interruptEvent = new AbilityEvent.InterruptEvent(
|
||||
npc.wrappedNPC, currentAbility, lastTarget, source, damage);
|
||||
NpcAPI.EVENT_BUS.post(interruptEvent);
|
||||
|
||||
currentAbility.onInterrupt(npc, source, damage);
|
||||
currentAbility.interrupt();
|
||||
currentAbility = null;
|
||||
lastTarget = null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Force stop the current ability (no interrupt event).
|
||||
*/
|
||||
public void stopCurrentAbility() {
|
||||
if (currentAbility != null) {
|
||||
removeTelegraph(currentAbility);
|
||||
stopAbilityAnimation();
|
||||
currentAbility.interrupt();
|
||||
currentAbility = null;
|
||||
lastTarget = null;
|
||||
}
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
// SCRIPT EVENTS
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
|
||||
/**
|
||||
* Fire the ability tick event for scripts.
|
||||
*/
|
||||
private void fireTickEvent(Ability ability, EntityLivingBase target) {
|
||||
AbilityEvent.TickEvent event = new AbilityEvent.TickEvent(
|
||||
npc.wrappedNPC, ability, target,
|
||||
ability.getPhase().ordinal(), ability.getCurrentTick());
|
||||
NpcAPI.EVENT_BUS.post(event);
|
||||
}
|
||||
|
||||
/**
|
||||
* Fire an ability hit event. Called by abilities when they hit an entity.
|
||||
* Returns null if the event was cancelled, otherwise returns the (possibly modified) event.
|
||||
*
|
||||
* @param ability The ability doing the hit
|
||||
* @param target The original target of the ability
|
||||
* @param hitEntity The entity being hit
|
||||
* @param damage The damage amount
|
||||
* @param knockback The horizontal knockback
|
||||
* @param knockbackUp The vertical knockback (deprecated, ignored)
|
||||
* @return The event (with possibly modified values), or null if cancelled
|
||||
*/
|
||||
public AbilityEvent.HitEvent fireHitEvent(Ability ability, EntityLivingBase target,
|
||||
EntityLivingBase hitEntity, float damage,
|
||||
float knockback, float knockbackUp) {
|
||||
AbilityEvent.HitEvent event = new AbilityEvent.HitEvent(
|
||||
npc.wrappedNPC, ability, target, hitEntity, damage, knockback, knockbackUp);
|
||||
if (NpcAPI.EVENT_BUS.post(event)) {
|
||||
return null; // Cancelled
|
||||
}
|
||||
return event;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the NPC this DataAbilities belongs to.
|
||||
*/
|
||||
public EntityNPCInterface getNpc() {
|
||||
return npc;
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
// RESET - Called on NPC death/respawn
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
|
||||
/**
|
||||
* Reset all runtime state (cooldowns, current ability).
|
||||
* Called when NPC respawns or combat ends.
|
||||
*/
|
||||
public void reset() {
|
||||
stopCurrentAbility();
|
||||
resetAllCooldowns();
|
||||
|
||||
// Reset execution state on all abilities
|
||||
for (Ability ability : abilities) {
|
||||
ability.reset();
|
||||
}
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
// ABILITY LIST MANAGEMENT
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
|
||||
public List<Ability> getAbilities() {
|
||||
return abilities;
|
||||
}
|
||||
|
||||
public void addAbility(Ability ability) {
|
||||
abilities.add(ability);
|
||||
}
|
||||
|
||||
public void removeAbility(int index) {
|
||||
if (index >= 0 && index < abilities.size()) {
|
||||
abilities.remove(index);
|
||||
}
|
||||
}
|
||||
|
||||
public void removeAbility(String id) {
|
||||
abilities.removeIf(a -> a.getId().equals(id));
|
||||
}
|
||||
|
||||
public Ability getAbility(String id) {
|
||||
for (Ability ability : abilities) {
|
||||
if (ability.getId().equals(id)) {
|
||||
return ability;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public void clearAbilities() {
|
||||
abilities.clear();
|
||||
}
|
||||
|
||||
public boolean isEmpty() {
|
||||
return abilities.isEmpty();
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
// STATE QUERIES
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
|
||||
/**
|
||||
* Check if NPC is currently executing an ability.
|
||||
*/
|
||||
public boolean isExecutingAbility() {
|
||||
return currentAbility != null && currentAbility.isExecuting();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the currently executing ability.
|
||||
*/
|
||||
public Ability getCurrentAbility() {
|
||||
return currentAbility;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if ability is controlling NPC movement (AI pathfinding should be blocked).
|
||||
* Called by AI tasks to determine if they should try to path.
|
||||
*
|
||||
* Rules:
|
||||
* - WINDUP phase: Block AI if lockMovement is true
|
||||
* - ACTIVE phase: Block AI if lockMovement OR hasAbilityMovement is true
|
||||
* - RECOVERY phase: Block AI if lockMovement is true
|
||||
*/
|
||||
public boolean isAbilityControllingMovement() {
|
||||
if (currentAbility == null || !currentAbility.isExecuting()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
AbilityPhase phase = currentAbility.getPhase();
|
||||
|
||||
switch (phase) {
|
||||
case WINDUP:
|
||||
// During windup, only block if lockMovement is set
|
||||
// This allows NPC to keep chasing while winding up if lockMovement=false
|
||||
return currentAbility.isLockMovement();
|
||||
|
||||
case ACTIVE:
|
||||
// During active phase, block if either:
|
||||
// - lockMovement is true (stationary ability)
|
||||
// - hasAbilityMovement is true (ability is moving the NPC itself)
|
||||
return currentAbility.isLockMovement() || currentAbility.hasAbilityMovement();
|
||||
|
||||
case RECOVERY:
|
||||
// During recovery, block if lockMovement is set
|
||||
return currentAbility.isLockMovement();
|
||||
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if NPC movement should be blocked due to ability execution.
|
||||
* @deprecated Use isAbilityControllingMovement() instead
|
||||
*/
|
||||
@Deprecated
|
||||
public boolean isMovementBlocked() {
|
||||
return isAbilityControllingMovement();
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if NPC should skip normal attacks during ability execution.
|
||||
*/
|
||||
public boolean shouldBlockAttack() {
|
||||
if (currentAbility == null || !currentAbility.isExecuting()) {
|
||||
return false;
|
||||
}
|
||||
AbilityPhase phase = currentAbility.getPhase();
|
||||
return phase == AbilityPhase.WINDUP || phase == AbilityPhase.ACTIVE;
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
// NBT SERIALIZATION
|
||||
// ═══════════════════════════════════════════════════════════════════
|
||||
|
||||
public NBTTagCompound writeToNBT(NBTTagCompound compound) {
|
||||
compound.setBoolean("AbilitiesEnabled", enabled);
|
||||
compound.setInteger("AbilityGlobalCooldown", globalCooldown);
|
||||
|
||||
NBTTagList abilityList = new NBTTagList();
|
||||
for (Ability ability : abilities) {
|
||||
abilityList.appendTag(ability.writeNBT());
|
||||
}
|
||||
compound.setTag("Abilities", abilityList);
|
||||
|
||||
return compound;
|
||||
}
|
||||
|
||||
public void readFromNBT(NBTTagCompound compound) {
|
||||
enabled = compound.getBoolean("AbilitiesEnabled");
|
||||
globalCooldown = compound.hasKey("AbilityGlobalCooldown") ?
|
||||
compound.getInteger("AbilityGlobalCooldown") : 20;
|
||||
|
||||
abilities.clear();
|
||||
NBTTagList abilityList = compound.getTagList("Abilities", 10);
|
||||
for (int i = 0; i < abilityList.tagCount(); i++) {
|
||||
NBTTagCompound abilityNBT = abilityList.getCompoundTagAt(i);
|
||||
Ability ability = AbilityController.Instance.fromNBT(abilityNBT);
|
||||
if (ability != null) {
|
||||
abilities.add(ability);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -763,6 +763,18 @@ public class NoppesUtilServer {
|
||||
}
|
||||
}
|
||||
|
||||
public static void sendAbilityTypesInfo(EntityPlayerMP player) {
|
||||
HashMap<String, Integer> map = new HashMap<String, Integer>();
|
||||
kamkeel.npcs.controllers.data.ability.AbilityController controller = kamkeel.npcs.controllers.data.ability.AbilityController.Instance;
|
||||
if (controller != null) {
|
||||
int index = 0;
|
||||
for (String typeId : controller.getTypes()) {
|
||||
map.put(typeId, index++);
|
||||
}
|
||||
}
|
||||
sendScrollData(player, map, EnumScrollData.ABILITY_TYPES);
|
||||
}
|
||||
|
||||
public static DialogOption setNpcDialog(int slot, int dialogId, EntityPlayer player) throws IOException {
|
||||
return setNpcDialog(slot, dialogId, getEditingNpc(player));
|
||||
}
|
||||
|
||||
@@ -42,8 +42,14 @@ public class CombatHandler {
|
||||
return;
|
||||
}
|
||||
combatResetTimer = 0;
|
||||
}
|
||||
|
||||
// Try to select and start an ability if not currently executing one
|
||||
// Ability ticking is handled by DataAbilities in onLivingUpdate
|
||||
EntityLivingBase target = npc.getAttackTarget();
|
||||
if (target != null && npc.abilities.enabled && !npc.abilities.isExecutingAbility()) {
|
||||
npc.abilities.trySelectAndStart(target);
|
||||
}
|
||||
}
|
||||
|
||||
private boolean shouldCombatContinue() {
|
||||
if (npc.getAttackTarget() == null)
|
||||
@@ -72,6 +78,18 @@ public class CombatHandler {
|
||||
}
|
||||
aggressors.put(el, f + damageAmount);
|
||||
}
|
||||
|
||||
// Handle guard counter before interruption
|
||||
if (npc.abilities.getCurrentAbility() instanceof kamkeel.npcs.controllers.data.ability.type.AbilityGuard) {
|
||||
kamkeel.npcs.controllers.data.ability.type.AbilityGuard guard =
|
||||
(kamkeel.npcs.controllers.data.ability.type.AbilityGuard) npc.abilities.getCurrentAbility();
|
||||
if (guard.isGuarding() && e instanceof EntityLivingBase) {
|
||||
guard.onDamageTaken(npc, (EntityLivingBase) e, source, damageAmount);
|
||||
}
|
||||
}
|
||||
|
||||
// Check for ability interruption
|
||||
npc.abilities.onDamage(source, damageAmount);
|
||||
}
|
||||
|
||||
public void start() {
|
||||
@@ -86,6 +104,9 @@ public class CombatHandler {
|
||||
aggressors.clear();
|
||||
recentDamages.clear();
|
||||
npc.setBoolFlag(false, 4);
|
||||
|
||||
// Reset ability state when combat ends
|
||||
npc.abilities.reset();
|
||||
}
|
||||
|
||||
public boolean checkTarget() {
|
||||
@@ -148,4 +169,26 @@ public class CombatHandler {
|
||||
}
|
||||
return newThreat > currentThreat;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if NPC is currently executing an ability.
|
||||
* Used by AI tasks to avoid conflicting with ability execution.
|
||||
*/
|
||||
public boolean isExecutingAbility() {
|
||||
return npc.abilities.isExecutingAbility();
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if NPC movement should be blocked due to ability execution.
|
||||
*/
|
||||
public boolean isMovementBlocked() {
|
||||
return npc.abilities.isMovementBlocked();
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if NPC should skip normal attacks during ability execution.
|
||||
*/
|
||||
public boolean shouldBlockAttack() {
|
||||
return npc.abilities.shouldBlockAttack();
|
||||
}
|
||||
}
|
||||
@@ -50,6 +50,11 @@ public class EntityAIAttackTarget extends EntityAIBase {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Don't start pathfinding if ability is controlling movement
|
||||
if (this.npc.abilities.isAbilityControllingMovement()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
double var2 = this.npc.getDistanceSq(entitylivingbase.posX, entitylivingbase.boundingBox.minY, entitylivingbase.posZ);
|
||||
double var3 = this.npc.ais.distanceToMelee * this.npc.ais.distanceToMelee;
|
||||
|
||||
@@ -115,13 +120,18 @@ public class EntityAIAttackTarget extends EntityAIBase {
|
||||
public void updateTask() {
|
||||
this.npc.getLookHelper().setLookPositionWithEntity(this.entityTarget, 30.0F, 30.0F);
|
||||
|
||||
|
||||
if (!navOverride && --this.field_75445_i <= 0) {
|
||||
// Skip pathfinding updates if ability is controlling movement
|
||||
if (!navOverride && !this.npc.abilities.isAbilityControllingMovement() && --this.field_75445_i <= 0) {
|
||||
this.field_75445_i = 4 + this.npc.getRNG().nextInt(7);
|
||||
this.npc.getNavigator().tryMoveToEntityLiving(this.entityTarget, 1.3f);
|
||||
}
|
||||
this.attackTick = Math.max(this.attackTick - 1, 0);
|
||||
|
||||
// Skip attacks if ability is blocking them
|
||||
if (this.npc.abilities.shouldBlockAttack()) {
|
||||
return;
|
||||
}
|
||||
|
||||
double distance = this.npc.getDistanceSq(this.entityTarget.posX, this.entityTarget.boundingBox.minY, this.entityTarget.posZ);
|
||||
double range = npc.stats.attackRange * npc.stats.attackRange + entityTarget.width;
|
||||
double minRange = this.npc.width * 2.0F * this.npc.width * 2.0F + entityTarget.width;
|
||||
|
||||
@@ -18,6 +18,11 @@ public class EntityAILeapAtTargetNpc extends EntityAIBase {
|
||||
|
||||
@Override
|
||||
public boolean shouldExecute() {
|
||||
// Don't leap if ability is controlling movement
|
||||
if (this.npc.abilities.isAbilityControllingMovement()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
this.leapTarget = this.npc.getAttackTarget();
|
||||
if (this.leapTarget == null) {
|
||||
return false;
|
||||
|
||||
@@ -17,6 +17,11 @@ public class EntityAIPounceTarget extends EntityAIBase {
|
||||
|
||||
@Override
|
||||
public boolean shouldExecute() {
|
||||
// Don't pounce if ability is controlling movement
|
||||
if (this.npc.abilities.isAbilityControllingMovement()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!this.npc.onGround)
|
||||
return false;
|
||||
|
||||
|
||||
@@ -15,6 +15,11 @@ public class EntityAISprintToTarget extends EntityAIBase {
|
||||
|
||||
@Override
|
||||
public boolean shouldExecute() {
|
||||
// Don't sprint if ability is controlling movement
|
||||
if (this.npc.abilities.isAbilityControllingMovement()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
EntityLivingBase runTarget = this.npc.getAttackTarget();
|
||||
|
||||
if (runTarget == null || this.npc.getNavigator().noPath()) {
|
||||
|
||||
@@ -136,6 +136,8 @@ import noppes.npcs.client.renderer.RenderNpcCrystal;
|
||||
import noppes.npcs.client.renderer.RenderNpcDragon;
|
||||
import noppes.npcs.client.renderer.RenderNpcSlime;
|
||||
import noppes.npcs.client.renderer.RenderProjectile;
|
||||
import kamkeel.npcs.client.renderer.TelegraphRenderer;
|
||||
import kamkeel.npcs.controllers.data.ability.telegraph.TelegraphManager;
|
||||
import noppes.npcs.client.renderer.blocks.BlockBannerRenderer;
|
||||
import noppes.npcs.client.renderer.blocks.BlockBarrelRenderer;
|
||||
import noppes.npcs.client.renderer.blocks.BlockBeamRenderer;
|
||||
@@ -306,6 +308,10 @@ public class ClientProxy extends CommonProxy {
|
||||
|
||||
MinecraftForge.EVENT_BUS.register(new ClientEventHandler());
|
||||
|
||||
// Telegraph rendering system
|
||||
TelegraphManager.initClient();
|
||||
MinecraftForge.EVENT_BUS.register(new TelegraphRenderer());
|
||||
|
||||
if (ConfigClient.InventoryGuiEnabled) {
|
||||
MinecraftForge.EVENT_BUS.register(new TabRegistry());
|
||||
if (TabRegistry.getTabList().isEmpty()) {
|
||||
|
||||
@@ -18,6 +18,7 @@ import net.minecraft.world.World;
|
||||
import noppes.npcs.CustomNpcs;
|
||||
import noppes.npcs.client.controllers.MusicController;
|
||||
import noppes.npcs.client.controllers.ScriptSoundController;
|
||||
import kamkeel.npcs.controllers.data.ability.telegraph.TelegraphManager;
|
||||
import noppes.npcs.client.gui.hud.ClientHudManager;
|
||||
import noppes.npcs.client.gui.hud.CompassHudComponent;
|
||||
import noppes.npcs.client.gui.hud.EnumHudComponent;
|
||||
@@ -109,6 +110,11 @@ public class ClientTickHandler {
|
||||
|
||||
MusicController.Instance.onUpdate();
|
||||
ScriptSoundController.Instance.onUpdate();
|
||||
|
||||
// Tick telegraph manager for ability warnings
|
||||
if (TelegraphManager.ClientInstance != null) {
|
||||
TelegraphManager.ClientInstance.tick(mc.theWorld);
|
||||
}
|
||||
if (Minecraft.getMinecraft().thePlayer != null && (prevWidth != mc.displayWidth || prevHeight != mc.displayHeight)) {
|
||||
prevWidth = mc.displayWidth;
|
||||
prevHeight = mc.displayHeight;
|
||||
|
||||
@@ -0,0 +1,437 @@
|
||||
package noppes.npcs.client.gui.advanced;
|
||||
|
||||
import kamkeel.npcs.controllers.data.ability.Ability;
|
||||
import kamkeel.npcs.controllers.data.ability.AbilityController;
|
||||
import kamkeel.npcs.network.PacketClient;
|
||||
import kamkeel.npcs.network.packets.request.ability.AbilitiesGetAllPacket;
|
||||
import kamkeel.npcs.network.packets.request.ability.AbilitiesNpcGetPacket;
|
||||
import kamkeel.npcs.network.packets.request.ability.AbilitiesNpcSavePacket;
|
||||
import net.minecraft.client.gui.GuiButton;
|
||||
import net.minecraft.client.resources.I18n;
|
||||
import net.minecraft.nbt.NBTTagCompound;
|
||||
import net.minecraft.nbt.NBTTagList;
|
||||
import noppes.npcs.client.gui.util.*;
|
||||
import noppes.npcs.constants.EnumScrollData;
|
||||
import noppes.npcs.entity.EntityNPCInterface;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.UUID;
|
||||
import java.util.Vector;
|
||||
|
||||
/**
|
||||
* GUI for managing NPC abilities.
|
||||
* Shows list of assigned abilities with add/remove/edit controls.
|
||||
*/
|
||||
public class GuiNPCAbilities extends GuiNPCInterface2 implements IScrollData, ICustomScrollListener, IGuiData, ITextfieldListener, ISubGuiListener, IAbilityConfigCallback {
|
||||
|
||||
private GuiCustomScroll availableTypesScroll;
|
||||
private GuiCustomScroll npcAbilitiesScroll;
|
||||
|
||||
// All available ability types (typeId -> index)
|
||||
private final HashMap<String, Integer> allAbilityTypes = new HashMap<>();
|
||||
|
||||
// Display name to typeId mapping for the available types scroll
|
||||
private final HashMap<String, String> displayNameToTypeId = new HashMap<>();
|
||||
|
||||
// NPC's current abilities
|
||||
private final List<Ability> npcAbilities = new ArrayList<>();
|
||||
|
||||
// Settings
|
||||
private boolean abilitiesEnabled = false;
|
||||
private int globalCooldown = 20;
|
||||
|
||||
private String search = "";
|
||||
private int selectedAbilityIndex = -1;
|
||||
|
||||
public GuiNPCAbilities(EntityNPCInterface npc) {
|
||||
super(npc);
|
||||
PacketClient.sendClient(new AbilitiesGetAllPacket());
|
||||
PacketClient.sendClient(new AbilitiesNpcGetPacket());
|
||||
}
|
||||
|
||||
@Override
|
||||
public void initGui() {
|
||||
super.initGui();
|
||||
|
||||
int y = guiTop + 10;
|
||||
|
||||
// Enabled checkbox
|
||||
addLabel(new GuiNpcLabel(100, "gui.enabled", guiLeft + 5, y + 5));
|
||||
addButton(new GuiNpcButton(100, guiLeft + 55, y, 50, 20, new String[]{"gui.no", "gui.yes"}, abilitiesEnabled ? 1 : 0));
|
||||
|
||||
// Global cooldown (spaced out since combat only is removed)
|
||||
addLabel(new GuiNpcLabel(101, "ability.globalCooldown", guiLeft + 140, y + 5));
|
||||
GuiNpcTextField cooldownField = new GuiNpcTextField(101, this, fontRendererObj, guiLeft + 230, y, 50, 20, String.valueOf(globalCooldown));
|
||||
cooldownField.setIntegersOnly();
|
||||
cooldownField.setMinMaxDefault(0, 10000, 20);
|
||||
addTextField(cooldownField);
|
||||
|
||||
y += 28;
|
||||
|
||||
// Left scroll: available ability types
|
||||
addLabel(new GuiNpcLabel(1, "ability.availableTypes", guiLeft + 5, y));
|
||||
if (availableTypesScroll == null) {
|
||||
availableTypesScroll = new GuiCustomScroll(this, 0);
|
||||
availableTypesScroll.setSize(140, 130);
|
||||
}
|
||||
availableTypesScroll.guiLeft = guiLeft + 5;
|
||||
availableTypesScroll.guiTop = y + 12;
|
||||
availableTypesScroll.setList(getFilteredTypeList());
|
||||
addScroll(availableTypesScroll);
|
||||
|
||||
// Search bar for types
|
||||
addTextField(new GuiNpcTextField(4, this, fontRendererObj, guiLeft + 5, y + 145, 140, 18, search));
|
||||
|
||||
// Right scroll: NPC's abilities (widened to use available space)
|
||||
addLabel(new GuiNpcLabel(2, "ability.npcAbilities", guiLeft + 210, y));
|
||||
if (npcAbilitiesScroll == null) {
|
||||
npcAbilitiesScroll = new GuiCustomScroll(this, 1);
|
||||
npcAbilitiesScroll.setSize(160, 130);
|
||||
} else {
|
||||
npcAbilitiesScroll.setSize(160, 130);
|
||||
}
|
||||
npcAbilitiesScroll.guiLeft = guiLeft + 210;
|
||||
npcAbilitiesScroll.guiTop = y + 12;
|
||||
updateNpcAbilitiesList();
|
||||
addScroll(npcAbilitiesScroll);
|
||||
|
||||
// Center buttons: Add/Remove
|
||||
int centerX = guiLeft + 158;
|
||||
addButton(new GuiNpcButton(70, centerX, y + 40, 40, 20, ">>>")); // Add
|
||||
addButton(new GuiNpcButton(71, centerX, y + 62, 40, 20, "<<<")); // Remove
|
||||
|
||||
// Load button (under the add/remove arrows)
|
||||
addButton(new GuiNpcButton(75, centerX, y + 90, 40, 20, "gui.load"));
|
||||
|
||||
// Right side buttons: Edit and Up/Down carrots with Save button
|
||||
addButton(new GuiNpcButton(72, guiLeft + 210, y + 145, 55, 20, "gui.edit"));
|
||||
getButton(72).setEnabled(selectedAbilityIndex >= 0);
|
||||
|
||||
// Up/Down carrot buttons
|
||||
addButton(new GuiNpcButton(73, guiLeft + 270, y + 145, 20, 20, "<"));
|
||||
addButton(new GuiNpcButton(74, guiLeft + 292, y + 145, 20, 20, ">"));
|
||||
getButton(73).setEnabled(selectedAbilityIndex > 0);
|
||||
getButton(74).setEnabled(selectedAbilityIndex >= 0 && selectedAbilityIndex < npcAbilities.size() - 1);
|
||||
|
||||
// Save button (to the right of carrots, only enabled when ability is selected)
|
||||
addButton(new GuiNpcButton(76, guiLeft + 320, y + 145, 50, 20, "gui.save"));
|
||||
getButton(76).setEnabled(selectedAbilityIndex >= 0);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void buttonEvent(GuiButton guibutton) {
|
||||
int id = guibutton.id;
|
||||
|
||||
// Enabled toggle
|
||||
if (id == 100) {
|
||||
abilitiesEnabled = ((GuiNpcButton) guibutton).getValue() == 1;
|
||||
save();
|
||||
return;
|
||||
}
|
||||
|
||||
// Add ability
|
||||
if (id == 70) {
|
||||
if (availableTypesScroll.hasSelected()) {
|
||||
String displayName = availableTypesScroll.getSelected();
|
||||
String typeId = displayNameToTypeId.get(displayName);
|
||||
if (typeId != null) {
|
||||
Ability newAbility = AbilityController.Instance.create(typeId);
|
||||
if (newAbility != null) {
|
||||
newAbility.setId(UUID.randomUUID().toString());
|
||||
// Don't set custom name - let it default to type name
|
||||
npcAbilities.add(newAbility);
|
||||
// Auto-select the newly added ability
|
||||
selectedAbilityIndex = npcAbilities.size() - 1;
|
||||
updateNpcAbilitiesList();
|
||||
selectAbilityByIndex(selectedAbilityIndex);
|
||||
initGui();
|
||||
save();
|
||||
}
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
// Remove ability
|
||||
if (id == 71) {
|
||||
if (selectedAbilityIndex >= 0 && selectedAbilityIndex < npcAbilities.size()) {
|
||||
npcAbilities.remove(selectedAbilityIndex);
|
||||
selectedAbilityIndex = -1;
|
||||
updateNpcAbilitiesList();
|
||||
initGui();
|
||||
save();
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
// Edit ability
|
||||
if (id == 72) {
|
||||
if (selectedAbilityIndex >= 0 && selectedAbilityIndex < npcAbilities.size()) {
|
||||
Ability ability = npcAbilities.get(selectedAbilityIndex);
|
||||
setSubGui(ability.createConfigGui(this));
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
// Move up (carrot left = earlier in list)
|
||||
if (id == 73) {
|
||||
if (selectedAbilityIndex > 0) {
|
||||
Ability temp = npcAbilities.get(selectedAbilityIndex);
|
||||
npcAbilities.set(selectedAbilityIndex, npcAbilities.get(selectedAbilityIndex - 1));
|
||||
npcAbilities.set(selectedAbilityIndex - 1, temp);
|
||||
selectedAbilityIndex--;
|
||||
updateNpcAbilitiesList();
|
||||
selectAbilityByIndex(selectedAbilityIndex);
|
||||
initGui();
|
||||
save();
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
// Move down (carrot right = later in list)
|
||||
if (id == 74) {
|
||||
if (selectedAbilityIndex >= 0 && selectedAbilityIndex < npcAbilities.size() - 1) {
|
||||
Ability temp = npcAbilities.get(selectedAbilityIndex);
|
||||
npcAbilities.set(selectedAbilityIndex, npcAbilities.get(selectedAbilityIndex + 1));
|
||||
npcAbilities.set(selectedAbilityIndex + 1, temp);
|
||||
selectedAbilityIndex++;
|
||||
updateNpcAbilitiesList();
|
||||
selectAbilityByIndex(selectedAbilityIndex);
|
||||
initGui();
|
||||
save();
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
// Load ability (opens load dialog to add ability directly to NPC)
|
||||
if (id == 75) {
|
||||
setSubGui(new SubGuiAbilityLoad(this));
|
||||
return;
|
||||
}
|
||||
|
||||
// Save selected ability
|
||||
if (id == 76) {
|
||||
if (selectedAbilityIndex >= 0 && selectedAbilityIndex < npcAbilities.size()) {
|
||||
Ability abilityToSave = npcAbilities.get(selectedAbilityIndex);
|
||||
if (abilityToSave.getName() == null || abilityToSave.getName().isEmpty()) {
|
||||
// Need a name to save - open edit dialog first
|
||||
setSubGui(abilityToSave.createConfigGui(this));
|
||||
} else {
|
||||
setSubGui(new SubGuiAbilitySaveConfirm(abilityToSave));
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
initGui();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setData(Vector<String> list, HashMap<String, Integer> data, EnumScrollData type) {
|
||||
if (type == EnumScrollData.ABILITY_TYPES) {
|
||||
allAbilityTypes.clear();
|
||||
allAbilityTypes.putAll(data);
|
||||
if (availableTypesScroll != null) {
|
||||
availableTypesScroll.setList(getFilteredTypeList());
|
||||
}
|
||||
}
|
||||
initGui();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setGuiData(NBTTagCompound compound) {
|
||||
abilitiesEnabled = compound.getBoolean("AbilitiesEnabled");
|
||||
globalCooldown = compound.hasKey("AbilityGlobalCooldown") ? compound.getInteger("AbilityGlobalCooldown") : 20;
|
||||
|
||||
npcAbilities.clear();
|
||||
NBTTagList abilityList = compound.getTagList("Abilities", 10);
|
||||
for (int i = 0; i < abilityList.tagCount(); i++) {
|
||||
NBTTagCompound abilityNBT = abilityList.getCompoundTagAt(i);
|
||||
Ability ability = AbilityController.Instance.fromNBT(abilityNBT);
|
||||
if (ability != null) {
|
||||
npcAbilities.add(ability);
|
||||
}
|
||||
}
|
||||
|
||||
initGui();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void mouseClicked(int i, int j, int k) {
|
||||
super.mouseClicked(i, j, k);
|
||||
if (k == 0 && availableTypesScroll != null) {
|
||||
availableTypesScroll.mouseClicked(i, j, k);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void keyTyped(char c, int i) {
|
||||
super.keyTyped(c, i);
|
||||
if (getTextField(4) != null && getTextField(4).isFocused()) {
|
||||
if (search.equals(getTextField(4).getText()))
|
||||
return;
|
||||
search = getTextField(4).getText().toLowerCase();
|
||||
availableTypesScroll.setList(getFilteredTypeList());
|
||||
availableTypesScroll.resetScroll();
|
||||
}
|
||||
}
|
||||
|
||||
private List<String> getFilteredTypeList() {
|
||||
List<String> list = new ArrayList<>();
|
||||
displayNameToTypeId.clear();
|
||||
for (String typeId : allAbilityTypes.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)) {
|
||||
list.add(displayName);
|
||||
displayNameToTypeId.put(displayName, typeId);
|
||||
}
|
||||
}
|
||||
return list;
|
||||
}
|
||||
|
||||
private void updateNpcAbilitiesList() {
|
||||
List<String> list = new ArrayList<>();
|
||||
for (int i = 0; i < npcAbilities.size(); i++) {
|
||||
list.add(getAbilityListEntry(i));
|
||||
}
|
||||
if (npcAbilitiesScroll != null) {
|
||||
npcAbilitiesScroll.setList(list);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates the display entry for an ability in the list.
|
||||
* Format: "[●] 1. Custom Name (Type)" or "[●] 1. Type" if no custom name
|
||||
* Circle is green (§a) for enabled, red (§c) for disabled
|
||||
*/
|
||||
private String getAbilityListEntry(int index) {
|
||||
Ability ability = npcAbilities.get(index);
|
||||
String typeName = getDisplayName(ability.getTypeId());
|
||||
String customName = ability.getName();
|
||||
|
||||
// Color prefix: green circle for enabled, red for disabled
|
||||
String colorPrefix = ability.isEnabled() ? "\u00A7a\u25CF\u00A7r " : "\u00A7c\u25CF\u00A7r ";
|
||||
|
||||
if (customName != null && !customName.isEmpty() && !customName.equals(typeName)) {
|
||||
return colorPrefix + (index + 1) + ". " + customName + " (" + typeName + ")";
|
||||
}
|
||||
return colorPrefix + (index + 1) + ". " + typeName;
|
||||
}
|
||||
|
||||
private void selectAbilityByIndex(int index) {
|
||||
if (index >= 0 && index < npcAbilities.size()) {
|
||||
String entry = getAbilityListEntry(index);
|
||||
if (npcAbilitiesScroll != null) {
|
||||
npcAbilitiesScroll.setSelected(entry);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the localized display name for an ability type.
|
||||
* The typeId IS the lang key (e.g., "ability.cnpc.slam").
|
||||
*/
|
||||
private String getDisplayName(String typeId) {
|
||||
return I18n.format(typeId);
|
||||
}
|
||||
|
||||
public void save() {
|
||||
NBTTagCompound compound = new NBTTagCompound();
|
||||
compound.setBoolean("AbilitiesEnabled", abilitiesEnabled);
|
||||
compound.setInteger("AbilityGlobalCooldown", globalCooldown);
|
||||
|
||||
NBTTagList abilityList = new NBTTagList();
|
||||
for (Ability ability : npcAbilities) {
|
||||
abilityList.appendTag(ability.writeNBT());
|
||||
}
|
||||
compound.setTag("Abilities", abilityList);
|
||||
|
||||
PacketClient.sendClient(new AbilitiesNpcSavePacket(compound));
|
||||
}
|
||||
|
||||
/**
|
||||
* Called from SubGuiAbilityLoad when a saved ability is loaded.
|
||||
* Adds the ability to the NPC's ability list.
|
||||
*/
|
||||
public void loadAbility(Ability loadedAbility) {
|
||||
if (loadedAbility != null) {
|
||||
loadedAbility.setId(UUID.randomUUID().toString());
|
||||
npcAbilities.add(loadedAbility);
|
||||
// Auto-select the newly added ability
|
||||
selectedAbilityIndex = npcAbilities.size() - 1;
|
||||
updateNpcAbilitiesList();
|
||||
selectAbilityByIndex(selectedAbilityIndex);
|
||||
initGui();
|
||||
save();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setSelected(String selected) {
|
||||
if (availableTypesScroll != null) {
|
||||
availableTypesScroll.setSelected(selected);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void customScrollClicked(int i, int j, int k, GuiCustomScroll guiCustomScroll) {
|
||||
if (guiCustomScroll == npcAbilitiesScroll) {
|
||||
String selected = npcAbilitiesScroll.getSelected();
|
||||
if (selected != null) {
|
||||
// Parse index from "[●] 1. Name" format - strip color codes first
|
||||
String stripped = selected.replaceAll("\u00A7.", "").trim();
|
||||
// Now format is "● 1. Name" - find the number after the circle
|
||||
int dotIndex = stripped.indexOf(".");
|
||||
if (dotIndex > 0) {
|
||||
try {
|
||||
// Extract just the number portion (skip "● " prefix)
|
||||
String numPart = stripped.substring(0, dotIndex).replaceAll("[^0-9]", "");
|
||||
selectedAbilityIndex = Integer.parseInt(numPart) - 1;
|
||||
} catch (NumberFormatException e) {
|
||||
selectedAbilityIndex = -1;
|
||||
}
|
||||
}
|
||||
}
|
||||
initGui();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void customScrollDoubleClicked(String selection, GuiCustomScroll scroll) {
|
||||
if (scroll == npcAbilitiesScroll && selectedAbilityIndex >= 0 && selectedAbilityIndex < npcAbilities.size()) {
|
||||
Ability ability = npcAbilities.get(selectedAbilityIndex);
|
||||
setSubGui(ability.createConfigGui(this));
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void unFocused(GuiNpcTextField textField) {
|
||||
if (textField.id == 101) {
|
||||
globalCooldown = textField.getInteger();
|
||||
save();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void subGuiClosed(SubGuiInterface subgui) {
|
||||
if (subgui instanceof SubGuiAbilityConfig) {
|
||||
// Ability was saved in the SubGui, refresh list
|
||||
updateNpcAbilitiesList();
|
||||
save();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Called from SubGuiAbilityConfig when ability is saved.
|
||||
*/
|
||||
public void onAbilitySaved(Ability ability) {
|
||||
if (selectedAbilityIndex >= 0 && selectedAbilityIndex < npcAbilities.size()) {
|
||||
npcAbilities.set(selectedAbilityIndex, ability);
|
||||
updateNpcAbilitiesList();
|
||||
save();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,902 @@
|
||||
package noppes.npcs.client.gui.advanced;
|
||||
|
||||
import kamkeel.npcs.controllers.data.ability.Ability;
|
||||
import kamkeel.npcs.controllers.data.ability.Condition;
|
||||
import kamkeel.npcs.controllers.data.ability.TargetingMode;
|
||||
import kamkeel.npcs.controllers.data.ability.telegraph.TelegraphType;
|
||||
import net.minecraft.client.gui.GuiButton;
|
||||
import net.minecraft.nbt.NBTTagCompound;
|
||||
import net.minecraft.util.StatCollector;
|
||||
import noppes.npcs.client.gui.SubGuiColorSelector;
|
||||
import noppes.npcs.client.gui.select.GuiAnimationSelection;
|
||||
import noppes.npcs.client.gui.select.GuiSoundSelection;
|
||||
import noppes.npcs.client.gui.util.*;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Base SubGui for editing ability configuration with tabbed interface.
|
||||
* Uses GuiMenuTopButton for navigation tabs.
|
||||
*
|
||||
* Tabs:
|
||||
* - General: Name, Weight, Lock Movement, Interruptible, Timing
|
||||
* - Type: Type-specific settings per Ability (override in subclasses)
|
||||
* - Target: Min/Max Range, Targeting Mode, Conditions (up to 3)
|
||||
* - Effects: Sounds, Animations, Telegraph settings, Colors
|
||||
*
|
||||
* Subclasses should override initTypeTab() and handleTypeButton()/handleTypeTextField()
|
||||
* to provide type-specific settings UI.
|
||||
*/
|
||||
public class SubGuiAbilityConfig extends SubGuiInterface implements ITextfieldListener, ISubGuiListener {
|
||||
|
||||
// Tab constants
|
||||
protected static final int TAB_GENERAL = 0;
|
||||
protected static final int TAB_TYPE = 1;
|
||||
protected static final int TAB_TARGET = 2;
|
||||
protected static final int TAB_EFFECTS = 3;
|
||||
|
||||
// Core references
|
||||
protected final Ability ability;
|
||||
protected final IAbilityConfigCallback callback;
|
||||
protected int activeTab = TAB_GENERAL;
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════════════
|
||||
// CACHED VALUES - General Tab
|
||||
// ═══════════════════════════════════════════════════════════════════════════
|
||||
protected String name;
|
||||
protected boolean enabled;
|
||||
protected int weight;
|
||||
protected boolean lockMovement;
|
||||
protected boolean interruptible;
|
||||
|
||||
// Timing
|
||||
protected int cooldownTicks;
|
||||
protected int windUpTicks;
|
||||
protected int activeTicks;
|
||||
protected int recoveryTicks;
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════════════
|
||||
// CACHED VALUES - Target Tab
|
||||
// ═══════════════════════════════════════════════════════════════════════════
|
||||
protected float minRange;
|
||||
protected float maxRange;
|
||||
protected TargetingMode targetingMode;
|
||||
protected List<Condition> conditions;
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════════════
|
||||
// CACHED VALUES - Effects Tab
|
||||
// ═══════════════════════════════════════════════════════════════════════════
|
||||
protected String windUpSound;
|
||||
protected String activeSound;
|
||||
protected int windUpAnimationId;
|
||||
protected int activeAnimationId;
|
||||
protected String windUpAnimationName = null;
|
||||
protected String activeAnimationName = null;
|
||||
|
||||
// Telegraph
|
||||
protected boolean showTelegraph;
|
||||
protected int windUpColor;
|
||||
protected int activeColor;
|
||||
|
||||
// Editing state
|
||||
protected int editingColorId = 0;
|
||||
protected int editingSoundId = 0;
|
||||
protected int editingAnimationId = 0;
|
||||
protected int editingConditionIndex = -1;
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════════════
|
||||
// ABILITY TYPE FEATURES
|
||||
// ═══════════════════════════════════════════════════════════════════════════
|
||||
protected final boolean supportsTelegraph;
|
||||
protected final boolean targetingModeLocked;
|
||||
protected final boolean hasTypeSettings;
|
||||
|
||||
public SubGuiAbilityConfig(Ability ability, IAbilityConfigCallback callback) {
|
||||
this.ability = ability;
|
||||
this.callback = callback;
|
||||
|
||||
// Cache values from ability - General
|
||||
this.name = ability.getName() != null ? ability.getName() : "";
|
||||
this.enabled = ability.isEnabled();
|
||||
this.weight = ability.getWeight();
|
||||
this.lockMovement = ability.isLockMovement();
|
||||
this.interruptible = ability.isInterruptible();
|
||||
|
||||
// Timing
|
||||
this.cooldownTicks = ability.getCooldownTicks();
|
||||
this.windUpTicks = ability.getWindUpTicks();
|
||||
this.activeTicks = ability.getActiveTicks();
|
||||
this.recoveryTicks = ability.getRecoveryTicks();
|
||||
|
||||
// Target
|
||||
this.minRange = ability.getMinRange();
|
||||
this.maxRange = ability.getMaxRange();
|
||||
this.targetingMode = ability.getTargetingMode();
|
||||
this.conditions = new ArrayList<>(ability.getConditions());
|
||||
|
||||
// Effects
|
||||
this.windUpSound = ability.getWindUpSound();
|
||||
this.activeSound = ability.getActiveSound();
|
||||
this.windUpAnimationId = ability.getWindUpAnimationId();
|
||||
this.activeAnimationId = ability.getActiveAnimationId();
|
||||
|
||||
// Telegraph
|
||||
this.showTelegraph = ability.isShowTelegraph();
|
||||
this.windUpColor = ability.getWindUpColor();
|
||||
this.activeColor = ability.getActiveColor();
|
||||
|
||||
// Determine ability type features
|
||||
TelegraphType defaultType = ability.getTelegraphType();
|
||||
this.supportsTelegraph = defaultType != null && defaultType != TelegraphType.NONE;
|
||||
this.targetingModeLocked = ability.isTargetingModeLocked();
|
||||
this.hasTypeSettings = ability.hasTypeSettings();
|
||||
|
||||
setBackground("menubg.png");
|
||||
xSize = 356;
|
||||
ySize = 200;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void initGui() {
|
||||
super.initGui();
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════════
|
||||
// TOP TABS using GuiMenuTopButton
|
||||
// ═══════════════════════════════════════════════════════════════════════
|
||||
GuiMenuTopButton generalTab = new GuiMenuTopButton(90, guiLeft + 4, guiTop - 17, "ability.tab.general");
|
||||
generalTab.active = (activeTab == TAB_GENERAL);
|
||||
addTopButton(generalTab);
|
||||
|
||||
GuiMenuTopButton lastTab = generalTab;
|
||||
|
||||
if (hasTypeSettings) {
|
||||
GuiMenuTopButton typeTab = new GuiMenuTopButton(91, lastTab, "ability.tab.type");
|
||||
typeTab.active = (activeTab == TAB_TYPE);
|
||||
addTopButton(typeTab);
|
||||
lastTab = typeTab;
|
||||
}
|
||||
|
||||
GuiMenuTopButton targetTab = new GuiMenuTopButton(92, lastTab, "ability.tab.target");
|
||||
targetTab.active = (activeTab == TAB_TARGET);
|
||||
addTopButton(targetTab);
|
||||
lastTab = targetTab;
|
||||
|
||||
GuiMenuTopButton effectsTab = new GuiMenuTopButton(93, lastTab, "ability.tab.effects");
|
||||
effectsTab.active = (activeTab == TAB_EFFECTS);
|
||||
addTopButton(effectsTab);
|
||||
|
||||
// Close button (X) in top menu bar - use -1000 to avoid any ID conflicts
|
||||
GuiMenuTopButton closeBtn = new GuiMenuTopButton(-1000, guiLeft + xSize - 22, guiTop - 17, "X");
|
||||
addTopButton(closeBtn);
|
||||
|
||||
int contentY = guiTop + 5;
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════════
|
||||
// TAB CONTENT
|
||||
// ═══════════════════════════════════════════════════════════════════════
|
||||
switch (activeTab) {
|
||||
case TAB_GENERAL:
|
||||
initGeneralTab(contentY);
|
||||
break;
|
||||
case TAB_TYPE:
|
||||
initTypeTab(contentY);
|
||||
break;
|
||||
case TAB_TARGET:
|
||||
initTargetTab(contentY);
|
||||
break;
|
||||
case TAB_EFFECTS:
|
||||
initEffectsTab(contentY);
|
||||
break;
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════════
|
||||
// BOTTOM ROW - Enabled toggle
|
||||
// ═══════════════════════════════════════════════════════════════════════
|
||||
addLabel(new GuiNpcLabel(99, "gui.enabled", guiLeft + 8, guiTop + ySize - 18));
|
||||
GuiNpcButton enabledBtn = new GuiNpcButton(2, guiLeft + 55, guiTop + ySize - 24, 40, 20, new String[]{"gui.no", "gui.yes"}, enabled ? 1 : 0);
|
||||
enabledBtn.setTextColor(enabled ? 0x00FF00 : 0xFF0000);
|
||||
addButton(enabledBtn);
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════════════
|
||||
// GENERAL TAB
|
||||
// ═══════════════════════════════════════════════════════════════════════════
|
||||
|
||||
private void initGeneralTab(int startY) {
|
||||
int y = startY;
|
||||
int col1LabelX = guiLeft + 8;
|
||||
int col1FieldX = guiLeft + 70;
|
||||
int col2LabelX = guiLeft + 180;
|
||||
int col2FieldX = guiLeft + 248;
|
||||
|
||||
// Row 1: Type (read-only) + Name
|
||||
addLabel(new GuiNpcLabel(1, "gui.type", col1LabelX, y + 5));
|
||||
addLabel(new GuiNpcLabel(2, ability.getTypeId(), col1FieldX, y + 5));
|
||||
|
||||
addLabel(new GuiNpcLabel(3, "gui.name", col2LabelX, y + 5));
|
||||
GuiNpcTextField nameField = new GuiNpcTextField(1, this, fontRendererObj, col2FieldX, y, 100, 20, name);
|
||||
addTextField(nameField);
|
||||
|
||||
y += 24;
|
||||
|
||||
// Row 2: Weight + Lock Movement
|
||||
addLabel(new GuiNpcLabel(4, "ability.weight", col1LabelX, y + 5));
|
||||
GuiNpcTextField weightField = new GuiNpcTextField(3, this, fontRendererObj, col1FieldX, y, 40, 20, String.valueOf(weight));
|
||||
weightField.setIntegersOnly();
|
||||
weightField.setMinMaxDefault(1, 1000, 10);
|
||||
addTextField(weightField);
|
||||
|
||||
addLabel(new GuiNpcLabel(5, "ability.lockMove", col2LabelX, y + 5));
|
||||
addButton(new GuiNpcButton(16, col2FieldX, y, 40, 20, new String[]{"gui.no", "gui.yes"}, lockMovement ? 1 : 0));
|
||||
|
||||
y += 24;
|
||||
|
||||
// Row 3: Interruptible
|
||||
addLabel(new GuiNpcLabel(6, "ability.interruptible", col1LabelX, y + 5));
|
||||
addButton(new GuiNpcButton(14, guiLeft + 85, y, 40, 20, new String[]{"gui.no", "gui.yes"}, interruptible ? 1 : 0));
|
||||
|
||||
y += 28;
|
||||
|
||||
// Separator - Timing section header
|
||||
addLabel(new GuiNpcLabel(7, "ability.timing", col1LabelX, y));
|
||||
y += 14;
|
||||
|
||||
// Row 4: Windup Ticks + Active Ticks
|
||||
addLabel(new GuiNpcLabel(10, "ability.windup", col1LabelX, y + 5));
|
||||
GuiNpcTextField windupField = new GuiNpcTextField(11, this, fontRendererObj, col1FieldX, y, 40, 20, String.valueOf(windUpTicks));
|
||||
windupField.setIntegersOnly();
|
||||
windupField.setMinMaxDefault(0, 1000, 20);
|
||||
addTextField(windupField);
|
||||
|
||||
addLabel(new GuiNpcLabel(11, "ability.active", col2LabelX, y + 5));
|
||||
GuiNpcTextField activeField = new GuiNpcTextField(12, this, fontRendererObj, col2FieldX, y, 40, 20, String.valueOf(activeTicks));
|
||||
activeField.setIntegersOnly();
|
||||
activeField.setMinMaxDefault(1, 1000, 10);
|
||||
addTextField(activeField);
|
||||
|
||||
y += 24;
|
||||
|
||||
// Row 5: Recovery Ticks + Cooldown Ticks
|
||||
addLabel(new GuiNpcLabel(12, "ability.recovery", col1LabelX, y + 5));
|
||||
GuiNpcTextField recoveryField = new GuiNpcTextField(13, this, fontRendererObj, col1FieldX, y, 40, 20, String.valueOf(recoveryTicks));
|
||||
recoveryField.setIntegersOnly();
|
||||
recoveryField.setMinMaxDefault(0, 1000, 20);
|
||||
addTextField(recoveryField);
|
||||
|
||||
addLabel(new GuiNpcLabel(13, "ability.cooldown", col2LabelX, y + 5));
|
||||
GuiNpcTextField cooldownField = new GuiNpcTextField(10, this, fontRendererObj, col2FieldX, y, 40, 20, String.valueOf(cooldownTicks));
|
||||
cooldownField.setIntegersOnly();
|
||||
cooldownField.setMinMaxDefault(0, 10000, 100);
|
||||
addTextField(cooldownField);
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════════════
|
||||
// TYPE TAB - Override in subclasses for type-specific settings
|
||||
// ═══════════════════════════════════════════════════════════════════════════
|
||||
|
||||
/**
|
||||
* Override this method to render type-specific settings in the Type tab.
|
||||
* Use the helper methods createFloatField(), createIntField(), etc.
|
||||
* Button/TextField IDs should start at 100.
|
||||
*
|
||||
* @param startY The Y position to start rendering from
|
||||
*/
|
||||
protected void initTypeTab(int startY) {
|
||||
// Default: show message that no type settings are available
|
||||
addLabel(new GuiNpcLabel(100, "ability.noTypeSettings", guiLeft + 8, startY + 5));
|
||||
}
|
||||
|
||||
/**
|
||||
* Override this method to handle button clicks for type-specific buttons.
|
||||
* Button IDs 100+ are reserved for type-specific use.
|
||||
*/
|
||||
protected void handleTypeButton(int id, GuiNpcButton button) {
|
||||
// Default: no-op
|
||||
}
|
||||
|
||||
/**
|
||||
* Override this method to handle text field changes for type-specific fields.
|
||||
* Field IDs 100+ are reserved for type-specific use.
|
||||
*/
|
||||
protected void handleTypeTextField(int id, GuiNpcTextField field) {
|
||||
// Default: no-op
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════════════
|
||||
// TARGET TAB
|
||||
// ═══════════════════════════════════════════════════════════════════════════
|
||||
|
||||
private void initTargetTab(int startY) {
|
||||
int y = startY;
|
||||
int col1LabelX = guiLeft + 8;
|
||||
int col1FieldX = guiLeft + 70;
|
||||
int col2LabelX = guiLeft + 180;
|
||||
int col2FieldX = guiLeft + 248;
|
||||
|
||||
// Row 1: Min Range + Max Range
|
||||
addLabel(new GuiNpcLabel(20, "ability.minRange", col1LabelX, y + 5));
|
||||
GuiNpcTextField minRangeField = new GuiNpcTextField(5, this, fontRendererObj, col1FieldX, y, 40, 20, String.valueOf((int) minRange));
|
||||
minRangeField.setIntegersOnly();
|
||||
minRangeField.setMinMaxDefault(0, 100, 0);
|
||||
addTextField(minRangeField);
|
||||
|
||||
addLabel(new GuiNpcLabel(21, "ability.maxRange", col2LabelX, y + 5));
|
||||
GuiNpcTextField maxRangeField = new GuiNpcTextField(6, this, fontRendererObj, col2FieldX, y, 40, 20, String.valueOf((int) maxRange));
|
||||
maxRangeField.setIntegersOnly();
|
||||
maxRangeField.setMinMaxDefault(1, 100, 20);
|
||||
addTextField(maxRangeField);
|
||||
|
||||
y += 24;
|
||||
|
||||
// Row 2: Targeting Mode (if not locked)
|
||||
addLabel(new GuiNpcLabel(22, "ability.targeting", col1LabelX, y + 5));
|
||||
if (!targetingModeLocked) {
|
||||
String[] targetingModes = getAvailableTargetingModes();
|
||||
int selectedIndex = getTargetingModeIndex(targetingMode);
|
||||
addButton(new GuiNpcButton(4, col1FieldX, y, 90, 20, targetingModes, selectedIndex));
|
||||
} else {
|
||||
String modeName = "ability.target." + targetingMode.name().toLowerCase();
|
||||
addLabel(new GuiNpcLabel(23, modeName, col1FieldX, y + 5));
|
||||
}
|
||||
|
||||
y += 28;
|
||||
|
||||
// ─────────────────────────────────────────────────────────────────────
|
||||
// CONDITIONS SECTION (up to 3)
|
||||
// ─────────────────────────────────────────────────────────────────────
|
||||
addLabel(new GuiNpcLabel(24, "ability.conditions", col1LabelX, y));
|
||||
y += 14;
|
||||
|
||||
// Display existing conditions (similar to Marks pattern)
|
||||
for (int i = 0; i < conditions.size() && i < 3; i++) {
|
||||
Condition cond = conditions.get(i);
|
||||
String condName = getConditionDisplayName(cond);
|
||||
|
||||
// Condition type button
|
||||
addButton(new GuiNpcButton(50 + i * 10, col1LabelX, y, 140, 20, condName));
|
||||
|
||||
// Edit button
|
||||
addButton(new GuiNpcButton(51 + i * 10, col1LabelX + 145, y, 40, 20, "gui.edit"));
|
||||
|
||||
// Delete button
|
||||
addButton(new GuiNpcButton(52 + i * 10, col1LabelX + 190, y, 20, 20, "X"));
|
||||
|
||||
y += 22;
|
||||
}
|
||||
|
||||
// Add button (if less than 3 conditions)
|
||||
if (conditions.size() < 3) {
|
||||
addButton(new GuiNpcButton(80, col1LabelX, y, 50, 20, "gui.add"));
|
||||
}
|
||||
}
|
||||
|
||||
private String getConditionDisplayName(Condition cond) {
|
||||
if (cond == null) return "None";
|
||||
String typeId = cond.getTypeId();
|
||||
switch (typeId) {
|
||||
case "hp_above":
|
||||
return StatCollector.translateToLocal("condition.hp_above") + " " + (int)(getConditionThreshold(cond) * 100) + "%";
|
||||
case "hp_below":
|
||||
return StatCollector.translateToLocal("condition.hp_below") + " " + (int)(getConditionThreshold(cond) * 100) + "%";
|
||||
case "target_hp_above":
|
||||
return StatCollector.translateToLocal("condition.target_hp_above") + " " + (int)(getConditionThreshold(cond) * 100) + "%";
|
||||
case "target_hp_below":
|
||||
return StatCollector.translateToLocal("condition.target_hp_below") + " " + (int)(getConditionThreshold(cond) * 100) + "%";
|
||||
case "hit_count":
|
||||
Condition.ConditionHitCount hitCount = (Condition.ConditionHitCount) cond;
|
||||
return StatCollector.translateToLocal("condition.hit_count") + ": " + hitCount.getRequiredHits() + "/" + hitCount.getWithinTicks() + "t";
|
||||
default:
|
||||
return typeId;
|
||||
}
|
||||
}
|
||||
|
||||
private float getConditionThreshold(Condition cond) {
|
||||
// Read threshold from NBT since inner classes don't expose it
|
||||
NBTTagCompound nbt = cond.writeNBT();
|
||||
return nbt.hasKey("threshold") ? nbt.getFloat("threshold") : 0.5f;
|
||||
}
|
||||
|
||||
private String[] getAvailableTargetingModes() {
|
||||
TargetingMode[] modes = ability.getAllowedTargetingModes();
|
||||
if (modes == null) {
|
||||
modes = TargetingMode.values();
|
||||
}
|
||||
String[] result = new String[modes.length];
|
||||
for (int i = 0; i < modes.length; i++) {
|
||||
result[i] = "ability.target." + modes[i].name().toLowerCase();
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
private int getTargetingModeIndex(TargetingMode mode) {
|
||||
TargetingMode[] modes = ability.getAllowedTargetingModes();
|
||||
if (modes == null) {
|
||||
return mode.ordinal();
|
||||
}
|
||||
for (int i = 0; i < modes.length; i++) {
|
||||
if (modes[i] == mode) return i;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════════════
|
||||
// EFFECTS TAB
|
||||
// ═══════════════════════════════════════════════════════════════════════════
|
||||
|
||||
private void initEffectsTab(int startY) {
|
||||
int y = startY;
|
||||
int col1LabelX = guiLeft + 8;
|
||||
int col1FieldX = guiLeft + 85;
|
||||
int col1ClearX = guiLeft + 160;
|
||||
int col2LabelX = guiLeft + 185;
|
||||
int col2FieldX = guiLeft + 255;
|
||||
|
||||
// ─────────────────────────────────────────────────────────────────────
|
||||
// SOUNDS SECTION
|
||||
// ─────────────────────────────────────────────────────────────────────
|
||||
addLabel(new GuiNpcLabel(30, "ability.sounds", col1LabelX, y));
|
||||
y += 14;
|
||||
|
||||
// Wind Up Sound
|
||||
addLabel(new GuiNpcLabel(31, "ability.windUpSound", col1LabelX, y + 5));
|
||||
String windUpSoundDisplay = windUpSound != null && !windUpSound.isEmpty() ? truncateString(windUpSound, 10) : StatCollector.translateToLocal("gui.none");
|
||||
addButton(new GuiNpcButton(30, col1FieldX, y, 70, 20, windUpSoundDisplay));
|
||||
addButton(new GuiNpcButton(35, col1ClearX, y, 20, 20, "X"));
|
||||
|
||||
// Active Sound
|
||||
addLabel(new GuiNpcLabel(32, "ability.activeSound", col2LabelX, y + 5));
|
||||
String activeSoundDisplay = activeSound != null && !activeSound.isEmpty() ? truncateString(activeSound, 10) : StatCollector.translateToLocal("gui.none");
|
||||
addButton(new GuiNpcButton(31, col2FieldX, y, 70, 20, activeSoundDisplay));
|
||||
addButton(new GuiNpcButton(36, col2FieldX + 75, y, 20, 20, "X"));
|
||||
|
||||
y += 26;
|
||||
|
||||
// ─────────────────────────────────────────────────────────────────────
|
||||
// ANIMATIONS SECTION
|
||||
// ─────────────────────────────────────────────────────────────────────
|
||||
addLabel(new GuiNpcLabel(33, "ability.animations", col1LabelX, y));
|
||||
y += 14;
|
||||
|
||||
// Wind Up Animation
|
||||
addLabel(new GuiNpcLabel(34, "ability.windUpAnim", col1LabelX, y + 5));
|
||||
String windUpAnimName = getAnimationName(windUpAnimationId, true);
|
||||
addButton(new GuiNpcButton(32, col1FieldX, y, 70, 20, windUpAnimName));
|
||||
addButton(new GuiNpcButton(37, col1ClearX, y, 20, 20, "X"));
|
||||
|
||||
// Active Animation
|
||||
addLabel(new GuiNpcLabel(35, "ability.activeAnim", col2LabelX, y + 5));
|
||||
String activeAnimName = getAnimationName(activeAnimationId, false);
|
||||
addButton(new GuiNpcButton(33, col2FieldX, y, 70, 20, activeAnimName));
|
||||
addButton(new GuiNpcButton(38, col2FieldX + 75, y, 20, 20, "X"));
|
||||
|
||||
y += 26;
|
||||
|
||||
// ─────────────────────────────────────────────────────────────────────
|
||||
// TELEGRAPH SECTION (only if supported)
|
||||
// ─────────────────────────────────────────────────────────────────────
|
||||
if (supportsTelegraph) {
|
||||
addLabel(new GuiNpcLabel(40, "ability.telegraph", col1LabelX, y));
|
||||
y += 14;
|
||||
|
||||
// Show Telegraph
|
||||
addLabel(new GuiNpcLabel(41, "ability.showTelegraph", col1LabelX, y + 5));
|
||||
addButton(new GuiNpcButton(20, guiLeft + 95, y, 40, 20, new String[]{"gui.no", "gui.yes"}, showTelegraph ? 1 : 0));
|
||||
|
||||
// Telegraph Type (separate column)
|
||||
String typeKey = ability.getTelegraphType().name().toLowerCase();
|
||||
addLabel(new GuiNpcLabel(42, "ability.telegraphType", guiLeft + 200, y + 5));
|
||||
addLabel(new GuiNpcLabel(43, "ability.telegraph." + typeKey, guiLeft + 280, y + 5));
|
||||
|
||||
y += 24;
|
||||
|
||||
// Colors
|
||||
addLabel(new GuiNpcLabel(44, "ability.windUpColor", col1LabelX, y + 5));
|
||||
String windUpHex = String.format("%06X", windUpColor & 0xFFFFFF);
|
||||
GuiNpcButton windUpColorBtn = new GuiNpcButton(22, guiLeft + 95, y, 55, 20, windUpHex);
|
||||
windUpColorBtn.setEnabled(showTelegraph);
|
||||
windUpColorBtn.setTextColor(windUpColor & 0xFFFFFF);
|
||||
addButton(windUpColorBtn);
|
||||
|
||||
addLabel(new GuiNpcLabel(45, "ability.activeColor", guiLeft + 200, y + 5));
|
||||
String activeHex = String.format("%06X", activeColor & 0xFFFFFF);
|
||||
GuiNpcButton activeColorBtn = new GuiNpcButton(24, guiLeft + 280, y, 55, 20, activeHex);
|
||||
activeColorBtn.setEnabled(showTelegraph);
|
||||
activeColorBtn.setTextColor(activeColor & 0xFFFFFF);
|
||||
addButton(activeColorBtn);
|
||||
}
|
||||
}
|
||||
|
||||
private String truncateString(String str, int maxLen) {
|
||||
if (str == null) return "";
|
||||
if (str.length() <= maxLen) return str;
|
||||
int lastSlash = str.lastIndexOf('/');
|
||||
if (lastSlash >= 0 && str.length() - lastSlash <= maxLen) {
|
||||
return "..." + str.substring(lastSlash);
|
||||
}
|
||||
return "..." + str.substring(str.length() - maxLen + 3);
|
||||
}
|
||||
|
||||
private String getAnimationName(int animId, boolean isWindUp) {
|
||||
if (animId < 0) return StatCollector.translateToLocal("gui.none");
|
||||
String cachedName = isWindUp ? windUpAnimationName : activeAnimationName;
|
||||
if (cachedName != null && !cachedName.isEmpty()) {
|
||||
return truncateString(cachedName, 8);
|
||||
}
|
||||
return "ID: " + animId;
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════════════
|
||||
// BUTTON EVENTS
|
||||
// ═══════════════════════════════════════════════════════════════════════════
|
||||
|
||||
@Override
|
||||
public void buttonEvent(GuiButton guibutton) {
|
||||
int id = guibutton.id;
|
||||
|
||||
// Tab switching
|
||||
if (id == 90) {
|
||||
activeTab = TAB_GENERAL;
|
||||
initGui();
|
||||
return;
|
||||
}
|
||||
if (id == 91 && hasTypeSettings) {
|
||||
activeTab = TAB_TYPE;
|
||||
initGui();
|
||||
return;
|
||||
}
|
||||
if (id == 92) {
|
||||
activeTab = TAB_TARGET;
|
||||
initGui();
|
||||
return;
|
||||
}
|
||||
if (id == 93) {
|
||||
activeTab = TAB_EFFECTS;
|
||||
initGui();
|
||||
return;
|
||||
}
|
||||
|
||||
// Enabled button (bottom left)
|
||||
if (id == 2) {
|
||||
enabled = ((GuiNpcButton) guibutton).getValue() == 1;
|
||||
initGui();
|
||||
}
|
||||
|
||||
// General tab buttons
|
||||
else if (id == 14) {
|
||||
interruptible = ((GuiNpcButton) guibutton).getValue() == 1;
|
||||
}
|
||||
else if (id == 16) {
|
||||
lockMovement = ((GuiNpcButton) guibutton).getValue() == 1;
|
||||
}
|
||||
|
||||
// Target tab - Targeting mode
|
||||
else if (id == 4) {
|
||||
TargetingMode[] modes = ability.getAllowedTargetingModes();
|
||||
int idx = ((GuiNpcButton) guibutton).getValue();
|
||||
if (modes != null && idx < modes.length) {
|
||||
targetingMode = modes[idx];
|
||||
} else {
|
||||
targetingMode = TargetingMode.values()[idx];
|
||||
}
|
||||
}
|
||||
|
||||
// Close button (X in top menu) - use -1000 to avoid any ID conflicts
|
||||
else if (id == -1000) {
|
||||
close();
|
||||
return;
|
||||
}
|
||||
|
||||
// Target tab - Condition buttons (50-79)
|
||||
else if (id >= 50 && id < 80) {
|
||||
int condIndex = (id - 50) / 10;
|
||||
int action = (id - 50) % 10;
|
||||
|
||||
if (action == 0 || action == 1) {
|
||||
// Click on condition name or Edit button - open edit subgui
|
||||
if (condIndex < conditions.size()) {
|
||||
editingConditionIndex = condIndex;
|
||||
setSubGui(new SubGuiConditionEdit(conditions.get(condIndex)));
|
||||
}
|
||||
} else if (action == 2) {
|
||||
// Delete button
|
||||
if (condIndex < conditions.size()) {
|
||||
conditions.remove(condIndex);
|
||||
initGui();
|
||||
}
|
||||
}
|
||||
}
|
||||
// Add condition button
|
||||
else if (id == 80) {
|
||||
if (conditions.size() < 3) {
|
||||
editingConditionIndex = conditions.size();
|
||||
setSubGui(new SubGuiConditionEdit(null));
|
||||
}
|
||||
}
|
||||
|
||||
// Effects tab - Telegraph
|
||||
else if (id == 20) {
|
||||
showTelegraph = ((GuiNpcButton) guibutton).getValue() == 1;
|
||||
initGui();
|
||||
}
|
||||
else if (id == 22) {
|
||||
editingColorId = 22;
|
||||
setSubGui(new SubGuiColorSelector(windUpColor));
|
||||
}
|
||||
else if (id == 24) {
|
||||
editingColorId = 24;
|
||||
setSubGui(new SubGuiColorSelector(activeColor));
|
||||
}
|
||||
|
||||
// Effects tab - Sound buttons
|
||||
else if (id == 30) {
|
||||
editingSoundId = 30;
|
||||
setSubGui(new GuiSoundSelection(windUpSound));
|
||||
}
|
||||
else if (id == 31) {
|
||||
editingSoundId = 31;
|
||||
setSubGui(new GuiSoundSelection(activeSound));
|
||||
}
|
||||
// Sound clear buttons
|
||||
else if (id == 35) {
|
||||
windUpSound = "";
|
||||
initGui();
|
||||
}
|
||||
else if (id == 36) {
|
||||
activeSound = "";
|
||||
initGui();
|
||||
}
|
||||
// Animation buttons
|
||||
else if (id == 32) {
|
||||
editingAnimationId = 32;
|
||||
setSubGui(new GuiAnimationSelection(windUpAnimationId));
|
||||
}
|
||||
else if (id == 33) {
|
||||
editingAnimationId = 33;
|
||||
setSubGui(new GuiAnimationSelection(activeAnimationId));
|
||||
}
|
||||
// Animation clear buttons
|
||||
else if (id == 37) {
|
||||
windUpAnimationId = -1;
|
||||
windUpAnimationName = null;
|
||||
initGui();
|
||||
}
|
||||
else if (id == 38) {
|
||||
activeAnimationId = -1;
|
||||
activeAnimationName = null;
|
||||
initGui();
|
||||
}
|
||||
|
||||
// Type-specific buttons (100+) - delegate to subclass
|
||||
else if (id >= 100) {
|
||||
handleTypeButton(id, (GuiNpcButton) guibutton);
|
||||
}
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════════════
|
||||
// TEXT FIELD EVENTS
|
||||
// ═══════════════════════════════════════════════════════════════════════════
|
||||
|
||||
@Override
|
||||
public void unFocused(GuiNpcTextField textField) {
|
||||
int id = textField.id;
|
||||
|
||||
// General tab
|
||||
if (id == 1) {
|
||||
name = textField.getText();
|
||||
} else if (id == 3) {
|
||||
weight = textField.getInteger();
|
||||
}
|
||||
|
||||
// Target tab
|
||||
else if (id == 5) {
|
||||
minRange = textField.getInteger();
|
||||
} else if (id == 6) {
|
||||
maxRange = textField.getInteger();
|
||||
}
|
||||
|
||||
// Timing (General tab)
|
||||
else if (id == 10) {
|
||||
cooldownTicks = textField.getInteger();
|
||||
} else if (id == 11) {
|
||||
windUpTicks = textField.getInteger();
|
||||
} else if (id == 12) {
|
||||
activeTicks = textField.getInteger();
|
||||
} else if (id == 13) {
|
||||
recoveryTicks = textField.getInteger();
|
||||
}
|
||||
|
||||
// Type-specific fields (100+) - delegate to subclass
|
||||
else if (id >= 100) {
|
||||
handleTypeTextField(id, textField);
|
||||
}
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════════════
|
||||
// SUBGUI CLOSED HANDLER
|
||||
// ═══════════════════════════════════════════════════════════════════════════
|
||||
|
||||
@Override
|
||||
public void subGuiClosed(SubGuiInterface subgui) {
|
||||
if (subgui instanceof SubGuiColorSelector) {
|
||||
SubGuiColorSelector colorSelector = (SubGuiColorSelector) subgui;
|
||||
int rgb = colorSelector.color & 0x00FFFFFF;
|
||||
if (editingColorId == 22) {
|
||||
windUpColor = 0x80000000 | rgb;
|
||||
} else if (editingColorId == 24) {
|
||||
activeColor = 0xC0000000 | rgb;
|
||||
}
|
||||
editingColorId = 0;
|
||||
initGui();
|
||||
} else if (subgui instanceof GuiSoundSelection) {
|
||||
GuiSoundSelection soundSelector = (GuiSoundSelection) subgui;
|
||||
if (soundSelector.selectedResource != null) {
|
||||
String sound = soundSelector.selectedResource.toString();
|
||||
if (editingSoundId == 30) {
|
||||
windUpSound = sound;
|
||||
} else if (editingSoundId == 31) {
|
||||
activeSound = sound;
|
||||
}
|
||||
}
|
||||
editingSoundId = 0;
|
||||
initGui();
|
||||
} else if (subgui instanceof GuiAnimationSelection) {
|
||||
GuiAnimationSelection animSelector = (GuiAnimationSelection) subgui;
|
||||
if (editingAnimationId == 32) {
|
||||
windUpAnimationId = animSelector.selectedAnimationId;
|
||||
windUpAnimationName = animSelector.getSelectedName();
|
||||
} else if (editingAnimationId == 33) {
|
||||
activeAnimationId = animSelector.selectedAnimationId;
|
||||
activeAnimationName = animSelector.getSelectedName();
|
||||
}
|
||||
editingAnimationId = 0;
|
||||
initGui();
|
||||
} else if (subgui instanceof SubGuiConditionEdit) {
|
||||
SubGuiConditionEdit condEdit = (SubGuiConditionEdit) subgui;
|
||||
Condition result = condEdit.getResult();
|
||||
if (result != null && editingConditionIndex >= 0) {
|
||||
if (editingConditionIndex < conditions.size()) {
|
||||
conditions.set(editingConditionIndex, result);
|
||||
} else {
|
||||
conditions.add(result);
|
||||
}
|
||||
}
|
||||
editingConditionIndex = -1;
|
||||
initGui();
|
||||
}
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════════════
|
||||
// CLOSE - Save before closing
|
||||
// ═══════════════════════════════════════════════════════════════════════════
|
||||
|
||||
@Override
|
||||
public void close() {
|
||||
// Apply all cached values to the ability before closing
|
||||
applyToAbility();
|
||||
|
||||
// Notify callback that ability was saved
|
||||
callback.onAbilitySaved(ability);
|
||||
|
||||
// Close the GUI
|
||||
super.close();
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════════════
|
||||
// APPLY TO ABILITY
|
||||
// ═══════════════════════════════════════════════════════════════════════════
|
||||
|
||||
protected void applyToAbility() {
|
||||
// General
|
||||
ability.setName(name);
|
||||
ability.setEnabled(enabled);
|
||||
ability.setWeight(weight);
|
||||
ability.setLockMovement(lockMovement);
|
||||
ability.setInterruptible(interruptible);
|
||||
|
||||
// Timing
|
||||
ability.setCooldownTicks(cooldownTicks);
|
||||
ability.setWindUpTicks(windUpTicks);
|
||||
ability.setActiveTicks(activeTicks);
|
||||
ability.setRecoveryTicks(recoveryTicks);
|
||||
|
||||
// Target
|
||||
ability.setMinRange(minRange);
|
||||
ability.setMaxRange(maxRange);
|
||||
ability.setTargetingMode(targetingMode);
|
||||
|
||||
// Conditions
|
||||
ability.getConditions().clear();
|
||||
for (Condition c : conditions) {
|
||||
ability.addCondition(c);
|
||||
}
|
||||
|
||||
// Effects
|
||||
ability.setWindUpSound(windUpSound);
|
||||
ability.setActiveSound(activeSound);
|
||||
ability.setWindUpAnimationId(windUpAnimationId);
|
||||
ability.setActiveAnimationId(activeAnimationId);
|
||||
|
||||
// Telegraph
|
||||
ability.setShowTelegraph(showTelegraph);
|
||||
ability.setWindUpColor(windUpColor);
|
||||
ability.setActiveColor(activeColor);
|
||||
|
||||
// Type-specific values are applied directly in handleTypeTextField and handleTypeButton
|
||||
}
|
||||
|
||||
/**
|
||||
* Called when an ability is loaded from saved presets.
|
||||
*/
|
||||
public void loadAbility(Ability loadedAbility) {
|
||||
if (loadedAbility == null) return;
|
||||
|
||||
// Copy all values from loaded ability to current ability
|
||||
NBTTagCompound nbt = loadedAbility.writeNBT();
|
||||
// Keep the current typeId since we can't change types mid-edit
|
||||
nbt.setString("typeId", ability.getTypeId());
|
||||
ability.readNBT(nbt);
|
||||
|
||||
// Update cached values
|
||||
this.name = ability.getName() != null ? ability.getName() : "";
|
||||
this.enabled = ability.isEnabled();
|
||||
this.weight = ability.getWeight();
|
||||
this.lockMovement = ability.isLockMovement();
|
||||
this.interruptible = ability.isInterruptible();
|
||||
|
||||
this.cooldownTicks = ability.getCooldownTicks();
|
||||
this.windUpTicks = ability.getWindUpTicks();
|
||||
this.activeTicks = ability.getActiveTicks();
|
||||
this.recoveryTicks = ability.getRecoveryTicks();
|
||||
|
||||
this.minRange = ability.getMinRange();
|
||||
this.maxRange = ability.getMaxRange();
|
||||
this.targetingMode = ability.getTargetingMode();
|
||||
this.conditions = new ArrayList<>(ability.getConditions());
|
||||
|
||||
this.showTelegraph = ability.isShowTelegraph();
|
||||
this.windUpColor = ability.getWindUpColor();
|
||||
this.activeColor = ability.getActiveColor();
|
||||
|
||||
initGui();
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════════════
|
||||
// HELPER METHODS FOR SUBCLASSES
|
||||
// ═══════════════════════════════════════════════════════════════════════════
|
||||
|
||||
/**
|
||||
* Creates a float text field for type-specific settings.
|
||||
*/
|
||||
protected GuiNpcTextField createFloatField(int id, int x, int y, int width, float value) {
|
||||
GuiNpcTextField field = new GuiNpcTextField(id, this, fontRendererObj, x, y, width, 20, String.format("%.1f", value));
|
||||
return field;
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates an integer text field for type-specific settings.
|
||||
*/
|
||||
protected GuiNpcTextField createIntField(int id, int x, int y, int width, int value) {
|
||||
GuiNpcTextField field = new GuiNpcTextField(id, this, fontRendererObj, x, y, width, 20, String.valueOf(value));
|
||||
field.setIntegersOnly();
|
||||
return field;
|
||||
}
|
||||
|
||||
/**
|
||||
* Parses a float from a text field with a fallback default value.
|
||||
*/
|
||||
protected float parseFloat(GuiNpcTextField field, float defaultValue) {
|
||||
try {
|
||||
return Float.parseFloat(field.getText());
|
||||
} catch (NumberFormatException e) {
|
||||
return defaultValue;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the ability being edited.
|
||||
*/
|
||||
protected Ability getAbility() {
|
||||
return ability;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,55 @@
|
||||
package noppes.npcs.client.gui.advanced;
|
||||
|
||||
import kamkeel.npcs.controllers.data.ability.AbilityController;
|
||||
import net.minecraft.client.gui.GuiButton;
|
||||
import noppes.npcs.client.gui.util.GuiNpcButton;
|
||||
import noppes.npcs.client.gui.util.GuiNpcLabel;
|
||||
import noppes.npcs.client.gui.util.SubGuiInterface;
|
||||
|
||||
/**
|
||||
* Confirmation dialog for deleting an ability preset.
|
||||
*/
|
||||
public class SubGuiAbilityDeleteConfirm extends SubGuiInterface {
|
||||
|
||||
private final String abilityName;
|
||||
private final SubGuiAbilityLoad loadGui;
|
||||
|
||||
public SubGuiAbilityDeleteConfirm(String abilityName, SubGuiAbilityLoad loadGui) {
|
||||
this.abilityName = abilityName;
|
||||
this.loadGui = loadGui;
|
||||
|
||||
setBackground("menubg.png");
|
||||
xSize = 200;
|
||||
ySize = 100;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void initGui() {
|
||||
super.initGui();
|
||||
|
||||
int y = guiTop + 10;
|
||||
|
||||
addLabel(new GuiNpcLabel(0, "ability.delete.confirm", guiLeft + 10, y));
|
||||
y += 12;
|
||||
addLabel(new GuiNpcLabel(1, "'" + abilityName + "'?", guiLeft + 10, y));
|
||||
|
||||
y += 30;
|
||||
|
||||
addButton(new GuiNpcButton(0, guiLeft + 30, y, 60, 20, "gui.yes"));
|
||||
addButton(new GuiNpcButton(1, guiLeft + 110, y, 60, 20, "gui.no"));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void buttonEvent(GuiButton guibutton) {
|
||||
int id = guibutton.id;
|
||||
|
||||
if (id == 0) {
|
||||
// Delete the ability
|
||||
AbilityController.Instance.deleteAbility(abilityName);
|
||||
loadGui.onAbilityDeleted(abilityName);
|
||||
close();
|
||||
} else if (id == 1) {
|
||||
close();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,134 @@
|
||||
package noppes.npcs.client.gui.advanced;
|
||||
|
||||
import kamkeel.npcs.controllers.data.ability.Ability;
|
||||
import kamkeel.npcs.controllers.data.ability.AbilityController;
|
||||
import net.minecraft.client.gui.GuiButton;
|
||||
import noppes.npcs.client.gui.util.*;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.Set;
|
||||
|
||||
/**
|
||||
* Dialog for loading a saved ability preset.
|
||||
* Can be opened from SubGuiAbilityConfig (to load into editing ability)
|
||||
* or from GuiNPCAbilities (to add ability directly to NPC).
|
||||
*/
|
||||
public class SubGuiAbilityLoad extends SubGuiInterface implements ICustomScrollListener {
|
||||
|
||||
private final SubGuiAbilityConfig parentConfig;
|
||||
private final GuiNPCAbilities parentAbilities;
|
||||
private String selectedName = null;
|
||||
private List<String> abilityNames = new ArrayList<>();
|
||||
|
||||
public SubGuiAbilityLoad(SubGuiAbilityConfig parentConfig) {
|
||||
this.parentConfig = parentConfig;
|
||||
this.parentAbilities = null;
|
||||
|
||||
setBackground("menubg.png");
|
||||
xSize = 220;
|
||||
ySize = 180;
|
||||
}
|
||||
|
||||
public SubGuiAbilityLoad(GuiNPCAbilities parentAbilities) {
|
||||
this.parentConfig = null;
|
||||
this.parentAbilities = parentAbilities;
|
||||
|
||||
setBackground("menubg.png");
|
||||
xSize = 220;
|
||||
ySize = 180;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void initGui() {
|
||||
super.initGui();
|
||||
|
||||
// Load ability names
|
||||
Set<String> names = AbilityController.Instance.getSavedAbilityNames();
|
||||
abilityNames = new ArrayList<>(names);
|
||||
|
||||
int y = guiTop + 5;
|
||||
|
||||
addLabel(new GuiNpcLabel(0, "ability.load.select", guiLeft + 10, y));
|
||||
y += 14;
|
||||
|
||||
// Scroll list of saved abilities
|
||||
GuiCustomScroll scroll = new GuiCustomScroll(this, 0);
|
||||
scroll.setSize(200, 110);
|
||||
scroll.guiLeft = guiLeft + 10;
|
||||
scroll.guiTop = y;
|
||||
scroll.setUnsortedList(abilityNames);
|
||||
if (selectedName != null && abilityNames.contains(selectedName)) {
|
||||
scroll.setSelected(selectedName);
|
||||
}
|
||||
addScroll(scroll);
|
||||
|
||||
y += 115;
|
||||
|
||||
// Buttons
|
||||
addButton(new GuiNpcButton(0, guiLeft + 10, y, 60, 20, "gui.load"));
|
||||
addButton(new GuiNpcButton(1, guiLeft + 80, y, 60, 20, "gui.delete"));
|
||||
addButton(new GuiNpcButton(2, guiLeft + 150, y, 60, 20, "gui.cancel"));
|
||||
|
||||
// Disable load/delete if nothing selected
|
||||
getButton(0).setEnabled(selectedName != null && !selectedName.isEmpty());
|
||||
getButton(1).setEnabled(selectedName != null && !selectedName.isEmpty());
|
||||
}
|
||||
|
||||
@Override
|
||||
public void buttonEvent(GuiButton guibutton) {
|
||||
int id = guibutton.id;
|
||||
|
||||
if (id == 0 && selectedName != null) {
|
||||
// Load the selected ability
|
||||
Ability loaded = AbilityController.Instance.getSavedAbility(selectedName);
|
||||
if (loaded != null) {
|
||||
if (parentConfig != null) {
|
||||
parentConfig.loadAbility(loaded);
|
||||
} else if (parentAbilities != null) {
|
||||
parentAbilities.loadAbility(loaded);
|
||||
}
|
||||
}
|
||||
close();
|
||||
} else if (id == 1 && selectedName != null) {
|
||||
// Delete confirmation
|
||||
setSubGui(new SubGuiAbilityDeleteConfirm(selectedName, this));
|
||||
} else if (id == 2) {
|
||||
close();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void customScrollClicked(int i, int j, int k, GuiCustomScroll scroll) {
|
||||
if (scroll.id == 0) {
|
||||
selectedName = scroll.getSelected();
|
||||
initGui();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void customScrollDoubleClicked(String selection, GuiCustomScroll scroll) {
|
||||
if (scroll.id == 0 && selection != null && !selection.isEmpty()) {
|
||||
// Double-click to load immediately
|
||||
Ability loaded = AbilityController.Instance.getSavedAbility(selection);
|
||||
if (loaded != null) {
|
||||
if (parentConfig != null) {
|
||||
parentConfig.loadAbility(loaded);
|
||||
} else if (parentAbilities != null) {
|
||||
parentAbilities.loadAbility(loaded);
|
||||
}
|
||||
}
|
||||
close();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Called after an ability is deleted to refresh the list.
|
||||
*/
|
||||
public void onAbilityDeleted(String name) {
|
||||
if (name.equals(selectedName)) {
|
||||
selectedName = null;
|
||||
}
|
||||
initGui();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,61 @@
|
||||
package noppes.npcs.client.gui.advanced;
|
||||
|
||||
import kamkeel.npcs.controllers.data.ability.Ability;
|
||||
import kamkeel.npcs.controllers.data.ability.AbilityController;
|
||||
import net.minecraft.client.gui.GuiButton;
|
||||
import noppes.npcs.client.gui.util.GuiNpcButton;
|
||||
import noppes.npcs.client.gui.util.GuiNpcLabel;
|
||||
import noppes.npcs.client.gui.util.SubGuiInterface;
|
||||
|
||||
/**
|
||||
* Confirmation dialog for saving an ability preset.
|
||||
*/
|
||||
public class SubGuiAbilitySaveConfirm extends SubGuiInterface {
|
||||
|
||||
private final Ability ability;
|
||||
private final boolean exists;
|
||||
|
||||
public SubGuiAbilitySaveConfirm(Ability ability) {
|
||||
this.ability = ability;
|
||||
this.exists = AbilityController.Instance.hasSavedAbility(ability.getName());
|
||||
|
||||
setBackground("menubg.png");
|
||||
xSize = 200;
|
||||
ySize = 100;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void initGui() {
|
||||
super.initGui();
|
||||
|
||||
int y = guiTop + 10;
|
||||
|
||||
if (exists) {
|
||||
addLabel(new GuiNpcLabel(0, "ability.save.overwrite", guiLeft + 10, y));
|
||||
y += 12;
|
||||
addLabel(new GuiNpcLabel(1, "'" + ability.getName() + "'?", guiLeft + 10, y));
|
||||
} else {
|
||||
addLabel(new GuiNpcLabel(0, "ability.save.confirm", guiLeft + 10, y));
|
||||
y += 12;
|
||||
addLabel(new GuiNpcLabel(1, "'" + ability.getName() + "'?", guiLeft + 10, y));
|
||||
}
|
||||
|
||||
y += 30;
|
||||
|
||||
addButton(new GuiNpcButton(0, guiLeft + 30, y, 60, 20, "gui.yes"));
|
||||
addButton(new GuiNpcButton(1, guiLeft + 110, y, 60, 20, "gui.no"));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void buttonEvent(GuiButton guibutton) {
|
||||
int id = guibutton.id;
|
||||
|
||||
if (id == 0) {
|
||||
// Save the ability
|
||||
AbilityController.Instance.saveAbility(ability);
|
||||
close();
|
||||
} else if (id == 1) {
|
||||
close();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,181 @@
|
||||
package noppes.npcs.client.gui.advanced;
|
||||
|
||||
import kamkeel.npcs.controllers.data.ability.Condition;
|
||||
import net.minecraft.client.gui.GuiButton;
|
||||
import noppes.npcs.client.gui.util.*;
|
||||
|
||||
/**
|
||||
* SubGui for editing a single ability condition.
|
||||
* Allows selecting condition type and configuring its parameters.
|
||||
*/
|
||||
public class SubGuiConditionEdit extends SubGuiInterface implements ITextfieldListener {
|
||||
|
||||
// Condition types
|
||||
private static final String[] CONDITION_TYPES = {
|
||||
"condition.hp_above",
|
||||
"condition.hp_below",
|
||||
"condition.target_hp_above",
|
||||
"condition.target_hp_below",
|
||||
"condition.hit_count"
|
||||
};
|
||||
|
||||
private static final String[] CONDITION_TYPE_IDS = {
|
||||
"hp_above",
|
||||
"hp_below",
|
||||
"target_hp_above",
|
||||
"target_hp_below",
|
||||
"hit_count"
|
||||
};
|
||||
|
||||
// Current condition being edited
|
||||
private Condition condition;
|
||||
private Condition result;
|
||||
|
||||
// State
|
||||
private int selectedTypeIndex = 0;
|
||||
private float threshold = 0.5f; // For HP conditions (0.0-1.0)
|
||||
private int requiredHits = 3; // For hit_count
|
||||
private int withinTicks = 60; // For hit_count
|
||||
|
||||
public SubGuiConditionEdit(Condition existing) {
|
||||
this.condition = existing;
|
||||
this.result = null;
|
||||
|
||||
if (existing != null) {
|
||||
String typeId = existing.getTypeId();
|
||||
for (int i = 0; i < CONDITION_TYPE_IDS.length; i++) {
|
||||
if (CONDITION_TYPE_IDS[i].equals(typeId)) {
|
||||
selectedTypeIndex = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
loadFromCondition(existing);
|
||||
}
|
||||
|
||||
setBackground("menubg.png");
|
||||
xSize = 220;
|
||||
ySize = 140;
|
||||
}
|
||||
|
||||
private void loadFromCondition(Condition cond) {
|
||||
String typeId = cond.getTypeId();
|
||||
if (typeId.equals("hit_count")) {
|
||||
Condition.ConditionHitCount hitCount = (Condition.ConditionHitCount) cond;
|
||||
requiredHits = hitCount.getRequiredHits();
|
||||
withinTicks = hitCount.getWithinTicks();
|
||||
} else {
|
||||
// HP-based conditions
|
||||
net.minecraft.nbt.NBTTagCompound nbt = cond.writeNBT();
|
||||
threshold = nbt.hasKey("threshold") ? nbt.getFloat("threshold") : 0.5f;
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void initGui() {
|
||||
super.initGui();
|
||||
|
||||
int y = guiTop + 8;
|
||||
int labelX = guiLeft + 8;
|
||||
int fieldX = guiLeft + 90;
|
||||
|
||||
// Title
|
||||
addLabel(new GuiNpcLabel(0, "condition.edit", labelX, y));
|
||||
y += 18;
|
||||
|
||||
// Condition Type selector
|
||||
addLabel(new GuiNpcLabel(1, "gui.type", labelX, y + 5));
|
||||
addButton(new GuiNpcButton(1, fieldX, y, 115, 20, CONDITION_TYPES, selectedTypeIndex));
|
||||
y += 26;
|
||||
|
||||
// Type-specific fields
|
||||
String typeId = CONDITION_TYPE_IDS[selectedTypeIndex];
|
||||
if (typeId.equals("hit_count")) {
|
||||
// Hit count fields
|
||||
addLabel(new GuiNpcLabel(2, "condition.hits", labelX, y + 5));
|
||||
GuiNpcTextField hitsField = new GuiNpcTextField(2, this, fontRendererObj, fieldX, y, 40, 20, String.valueOf(requiredHits));
|
||||
hitsField.setIntegersOnly();
|
||||
hitsField.setMinMaxDefault(1, 100, 3);
|
||||
addTextField(hitsField);
|
||||
y += 24;
|
||||
|
||||
addLabel(new GuiNpcLabel(3, "condition.within", labelX, y + 5));
|
||||
GuiNpcTextField ticksField = new GuiNpcTextField(3, this, fontRendererObj, fieldX, y, 40, 20, String.valueOf(withinTicks));
|
||||
ticksField.setIntegersOnly();
|
||||
ticksField.setMinMaxDefault(1, 1200, 60);
|
||||
addTextField(ticksField);
|
||||
} else {
|
||||
// HP threshold field (as percentage)
|
||||
addLabel(new GuiNpcLabel(2, "condition.percent", labelX, y + 5));
|
||||
int percent = (int)(threshold * 100);
|
||||
GuiNpcTextField thresholdField = new GuiNpcTextField(4, this, fontRendererObj, fieldX, y, 40, 20, String.valueOf(percent));
|
||||
thresholdField.setIntegersOnly();
|
||||
thresholdField.setMinMaxDefault(1, 99, 50);
|
||||
addTextField(thresholdField);
|
||||
addLabel(new GuiNpcLabel(4, "%", fieldX + 45, y + 5));
|
||||
}
|
||||
|
||||
// Bottom buttons
|
||||
addButton(new GuiNpcButton(10, guiLeft + 8, guiTop + ySize - 28, 60, 20, "gui.cancel"));
|
||||
addButton(new GuiNpcButton(11, guiLeft + xSize - 68, guiTop + ySize - 28, 60, 20, "gui.done"));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void buttonEvent(GuiButton guibutton) {
|
||||
int id = guibutton.id;
|
||||
|
||||
if (id == 1) {
|
||||
// Type changed
|
||||
selectedTypeIndex = ((GuiNpcButton) guibutton).getValue();
|
||||
initGui();
|
||||
} else if (id == 10) {
|
||||
// Cancel - close without saving
|
||||
result = null;
|
||||
close();
|
||||
} else if (id == 11) {
|
||||
// Done - create condition and close
|
||||
result = createCondition();
|
||||
close();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void unFocused(GuiNpcTextField textField) {
|
||||
int id = textField.id;
|
||||
|
||||
if (id == 2) {
|
||||
requiredHits = textField.getInteger();
|
||||
} else if (id == 3) {
|
||||
withinTicks = textField.getInteger();
|
||||
} else if (id == 4) {
|
||||
int percent = textField.getInteger();
|
||||
threshold = percent / 100.0f;
|
||||
}
|
||||
}
|
||||
|
||||
private Condition createCondition() {
|
||||
String typeId = CONDITION_TYPE_IDS[selectedTypeIndex];
|
||||
|
||||
switch (typeId) {
|
||||
case "hp_above":
|
||||
return new Condition.ConditionHPAbove(threshold);
|
||||
case "hp_below":
|
||||
return new Condition.ConditionHPBelow(threshold);
|
||||
case "target_hp_above":
|
||||
return new Condition.ConditionTargetHPAbove(threshold);
|
||||
case "target_hp_below":
|
||||
return new Condition.ConditionTargetHPBelow(threshold);
|
||||
case "hit_count":
|
||||
return new Condition.ConditionHitCount(requiredHits, withinTicks);
|
||||
default:
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the resulting condition after dialog closes.
|
||||
* Returns null if cancelled or no valid condition.
|
||||
*/
|
||||
public Condition getResult() {
|
||||
return result;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,92 @@
|
||||
package noppes.npcs.client.gui.advanced.ability;
|
||||
|
||||
import kamkeel.npcs.controllers.data.ability.type.AbilityBeam;
|
||||
import noppes.npcs.client.gui.util.IAbilityConfigCallback;
|
||||
import noppes.npcs.client.gui.advanced.SubGuiAbilityConfig;
|
||||
import noppes.npcs.client.gui.util.GuiNpcButton;
|
||||
import noppes.npcs.client.gui.util.GuiNpcLabel;
|
||||
import noppes.npcs.client.gui.util.GuiNpcTextField;
|
||||
|
||||
/**
|
||||
* GUI for configuring Beam ability type-specific settings.
|
||||
*/
|
||||
public class SubGuiAbilityBeam extends SubGuiAbilityConfig {
|
||||
|
||||
private final AbilityBeam beam;
|
||||
|
||||
public SubGuiAbilityBeam(AbilityBeam ability, IAbilityConfigCallback callback) {
|
||||
super(ability, callback);
|
||||
this.beam = ability;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void initTypeTab(int startY) {
|
||||
int y = startY;
|
||||
int labelX = guiLeft + 8;
|
||||
int fieldX = guiLeft + 85;
|
||||
int col2LabelX = guiLeft + 145;
|
||||
int col2FieldX = guiLeft + 205;
|
||||
|
||||
// Row 1: Damage + Damage Interval
|
||||
addLabel(new GuiNpcLabel(100, "ability.damage", labelX, y + 5));
|
||||
addTextField(createFloatField(100, fieldX, y, 50, beam.getDamage()));
|
||||
|
||||
addLabel(new GuiNpcLabel(101, "ability.dmgInterval", col2LabelX, y + 5));
|
||||
addTextField(createIntField(101, col2FieldX, y, 50, beam.getDamageInterval()));
|
||||
|
||||
y += 24;
|
||||
|
||||
// Row 2: Beam Length + Beam Width
|
||||
addLabel(new GuiNpcLabel(102, "ability.beamLength", labelX, y + 5));
|
||||
addTextField(createFloatField(102, fieldX, y, 50, beam.getBeamLength()));
|
||||
|
||||
addLabel(new GuiNpcLabel(103, "ability.beamWidth", col2LabelX, y + 5));
|
||||
addTextField(createFloatField(103, col2FieldX, y, 50, beam.getBeamWidth()));
|
||||
|
||||
y += 24;
|
||||
|
||||
// Row 3: Sweep Angle + Sweep Speed
|
||||
addLabel(new GuiNpcLabel(104, "ability.sweepAngle", labelX, y + 5));
|
||||
addTextField(createFloatField(104, fieldX, y, 50, beam.getSweepAngle()));
|
||||
|
||||
addLabel(new GuiNpcLabel(105, "ability.sweepSpeed", col2LabelX, y + 5));
|
||||
addTextField(createFloatField(105, col2FieldX, y, 50, beam.getSweepSpeed()));
|
||||
|
||||
y += 24;
|
||||
|
||||
// Row 4: Piercing + Lock On Target
|
||||
addLabel(new GuiNpcLabel(106, "ability.piercing", labelX, y + 5));
|
||||
addButton(new GuiNpcButton(106, fieldX, y, 50, 20, new String[]{"gui.no", "gui.yes"}, beam.isPiercing() ? 1 : 0));
|
||||
|
||||
addLabel(new GuiNpcLabel(107, "ability.lockTarget", col2LabelX, y + 5));
|
||||
addButton(new GuiNpcButton(107, col2FieldX, y, 50, 20, new String[]{"gui.no", "gui.yes"}, beam.isLockOnTarget() ? 1 : 0));
|
||||
|
||||
y += 24;
|
||||
|
||||
// Row 5: Sweep Back & Forth
|
||||
addLabel(new GuiNpcLabel(108, "ability.sweepBackForth", labelX, y + 5));
|
||||
addButton(new GuiNpcButton(108, fieldX, y, 50, 20, new String[]{"gui.no", "gui.yes"}, beam.isSweepBackAndForth() ? 1 : 0));
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void handleTypeButton(int id, GuiNpcButton button) {
|
||||
int value = button.getValue();
|
||||
switch (id) {
|
||||
case 106: beam.setPiercing(value == 1); break;
|
||||
case 107: beam.setLockOnTarget(value == 1); break;
|
||||
case 108: beam.setSweepBackAndForth(value == 1); break;
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void handleTypeTextField(int id, GuiNpcTextField field) {
|
||||
switch (id) {
|
||||
case 100: beam.setDamage(parseFloat(field, beam.getDamage())); break;
|
||||
case 101: beam.setDamageInterval(field.getInteger()); break;
|
||||
case 102: beam.setBeamLength(parseFloat(field, beam.getBeamLength())); break;
|
||||
case 103: beam.setBeamWidth(parseFloat(field, beam.getBeamWidth())); break;
|
||||
case 104: beam.setSweepAngle(parseFloat(field, beam.getSweepAngle())); break;
|
||||
case 105: beam.setSweepSpeed(parseFloat(field, beam.getSweepSpeed())); break;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,59 @@
|
||||
package noppes.npcs.client.gui.advanced.ability;
|
||||
|
||||
import kamkeel.npcs.controllers.data.ability.type.AbilityCharge;
|
||||
import noppes.npcs.client.gui.util.IAbilityConfigCallback;
|
||||
import noppes.npcs.client.gui.advanced.SubGuiAbilityConfig;
|
||||
import noppes.npcs.client.gui.util.GuiNpcLabel;
|
||||
import noppes.npcs.client.gui.util.GuiNpcTextField;
|
||||
|
||||
/**
|
||||
* GUI for configuring Charge ability type-specific settings.
|
||||
*/
|
||||
public class SubGuiAbilityCharge extends SubGuiAbilityConfig {
|
||||
|
||||
private final AbilityCharge charge;
|
||||
|
||||
public SubGuiAbilityCharge(AbilityCharge ability, IAbilityConfigCallback callback) {
|
||||
super(ability, callback);
|
||||
this.charge = ability;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void initTypeTab(int startY) {
|
||||
int y = startY;
|
||||
int labelX = guiLeft + 8;
|
||||
int fieldX = guiLeft + 85;
|
||||
int col2LabelX = guiLeft + 145;
|
||||
int col2FieldX = guiLeft + 205;
|
||||
|
||||
// Row 1: Damage + Speed
|
||||
addLabel(new GuiNpcLabel(100, "ability.damage", labelX, y + 5));
|
||||
addTextField(createFloatField(100, fieldX, y, 50, charge.getDamage()));
|
||||
|
||||
addLabel(new GuiNpcLabel(101, "ability.speed", col2LabelX, y + 5));
|
||||
addTextField(createFloatField(101, col2FieldX, y, 50, charge.getChargeSpeed()));
|
||||
|
||||
y += 24;
|
||||
|
||||
// Row 2: Knockback
|
||||
addLabel(new GuiNpcLabel(102, "ability.knockback", labelX, y + 5));
|
||||
addTextField(createFloatField(102, fieldX, y, 50, charge.getKnockback()));
|
||||
|
||||
y += 24;
|
||||
|
||||
// Row 3: Hit Width
|
||||
addLabel(new GuiNpcLabel(104, "ability.hitWidth", labelX, y + 5));
|
||||
addTextField(createFloatField(104, fieldX, y, 50, charge.getHitWidth()));
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void handleTypeTextField(int id, GuiNpcTextField field) {
|
||||
switch (id) {
|
||||
case 100: charge.setDamage(parseFloat(field, charge.getDamage())); break;
|
||||
case 101: charge.setChargeSpeed(parseFloat(field, charge.getChargeSpeed())); break;
|
||||
case 102: charge.setKnockback(parseFloat(field, charge.getKnockback())); break;
|
||||
case 104: charge.setHitWidth(parseFloat(field, charge.getHitWidth())); break;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,104 @@
|
||||
package noppes.npcs.client.gui.advanced.ability;
|
||||
|
||||
import kamkeel.npcs.controllers.data.ability.type.AbilityCutter;
|
||||
import noppes.npcs.client.gui.util.IAbilityConfigCallback;
|
||||
import noppes.npcs.client.gui.advanced.SubGuiAbilityConfig;
|
||||
import noppes.npcs.client.gui.util.GuiNpcButton;
|
||||
import noppes.npcs.client.gui.util.GuiNpcLabel;
|
||||
import noppes.npcs.client.gui.util.GuiNpcTextField;
|
||||
|
||||
/**
|
||||
* GUI for configuring Cutter ability type-specific settings.
|
||||
*/
|
||||
public class SubGuiAbilityCutter extends SubGuiAbilityConfig {
|
||||
|
||||
private final AbilityCutter cutter;
|
||||
|
||||
public SubGuiAbilityCutter(AbilityCutter ability, IAbilityConfigCallback callback) {
|
||||
super(ability, callback);
|
||||
this.cutter = ability;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void initTypeTab(int startY) {
|
||||
int y = startY;
|
||||
int labelX = guiLeft + 8;
|
||||
int fieldX = guiLeft + 85;
|
||||
int col2LabelX = guiLeft + 145;
|
||||
int col2FieldX = guiLeft + 205;
|
||||
|
||||
// Row 1: Damage + Range
|
||||
addLabel(new GuiNpcLabel(100, "ability.damage", labelX, y + 5));
|
||||
addTextField(createFloatField(100, fieldX, y, 50, cutter.getDamage()));
|
||||
|
||||
addLabel(new GuiNpcLabel(101, "ability.range", col2LabelX, y + 5));
|
||||
addTextField(createFloatField(101, col2FieldX, y, 50, cutter.getRange()));
|
||||
|
||||
y += 24;
|
||||
|
||||
// Row 2: Arc Angle + Inner Radius
|
||||
addLabel(new GuiNpcLabel(102, "ability.arcAngle", labelX, y + 5));
|
||||
addTextField(createFloatField(102, fieldX, y, 50, cutter.getArcAngle()));
|
||||
|
||||
addLabel(new GuiNpcLabel(103, "ability.innerRadius", col2LabelX, y + 5));
|
||||
addTextField(createFloatField(103, col2FieldX, y, 50, cutter.getInnerRadius()));
|
||||
|
||||
y += 24;
|
||||
|
||||
// Row 3: Knockback + Sweep Speed
|
||||
addLabel(new GuiNpcLabel(104, "ability.knockback", labelX, y + 5));
|
||||
addTextField(createFloatField(104, fieldX, y, 50, cutter.getKnockback()));
|
||||
|
||||
addLabel(new GuiNpcLabel(105, "ability.sweepSpeed", col2LabelX, y + 5));
|
||||
addTextField(createFloatField(105, col2FieldX, y, 50, cutter.getSweepSpeed()));
|
||||
|
||||
y += 24;
|
||||
|
||||
// Row 4: Sweep Mode + Piercing
|
||||
addLabel(new GuiNpcLabel(106, "ability.sweepMode", labelX, y + 5));
|
||||
String[] sweepModes = {"Swipe", "Spin"};
|
||||
addButton(new GuiNpcButton(106, fieldX, y, 70, 20, sweepModes, cutter.getSweepMode().ordinal()));
|
||||
|
||||
addLabel(new GuiNpcLabel(107, "ability.piercing", col2LabelX, y + 5));
|
||||
addButton(new GuiNpcButton(107, col2FieldX, y, 50, 20, new String[]{"gui.no", "gui.yes"}, cutter.isPiercing() ? 1 : 0));
|
||||
|
||||
y += 24;
|
||||
|
||||
// Row 5: Stun Duration + Poison Time
|
||||
addLabel(new GuiNpcLabel(108, "ability.stunDuration", labelX, y + 5));
|
||||
addTextField(createIntField(108, fieldX, y, 50, cutter.getStunDuration()));
|
||||
|
||||
addLabel(new GuiNpcLabel(109, "ability.poisonTime", col2LabelX, y + 5));
|
||||
addTextField(createIntField(109, col2FieldX, y, 50, cutter.getPoisonDurationSeconds()));
|
||||
|
||||
y += 24;
|
||||
|
||||
// Row 6: Poison Level
|
||||
addLabel(new GuiNpcLabel(110, "ability.poisonLvl", labelX, y + 5));
|
||||
addTextField(createIntField(110, fieldX, y, 50, cutter.getPoisonLevel()));
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void handleTypeButton(int id, GuiNpcButton button) {
|
||||
int value = button.getValue();
|
||||
switch (id) {
|
||||
case 106: cutter.setSweepMode(AbilityCutter.SweepMode.values()[value]); break;
|
||||
case 107: cutter.setPiercing(value == 1); break;
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void handleTypeTextField(int id, GuiNpcTextField field) {
|
||||
switch (id) {
|
||||
case 100: cutter.setDamage(parseFloat(field, cutter.getDamage())); break;
|
||||
case 101: cutter.setRange(parseFloat(field, cutter.getRange())); break;
|
||||
case 102: cutter.setArcAngle(parseFloat(field, cutter.getArcAngle())); break;
|
||||
case 103: cutter.setInnerRadius(parseFloat(field, cutter.getInnerRadius())); break;
|
||||
case 104: cutter.setKnockback(parseFloat(field, cutter.getKnockback())); break;
|
||||
case 105: cutter.setSweepSpeed(parseFloat(field, cutter.getSweepSpeed())); break;
|
||||
case 108: cutter.setStunDuration(field.getInteger()); break;
|
||||
case 109: cutter.setPoisonDurationSeconds(field.getInteger()); break;
|
||||
case 110: cutter.setPoisonLevel(field.getInteger()); break;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,59 @@
|
||||
package noppes.npcs.client.gui.advanced.ability;
|
||||
|
||||
import kamkeel.npcs.controllers.data.ability.type.AbilityDash;
|
||||
import noppes.npcs.client.gui.util.IAbilityConfigCallback;
|
||||
import noppes.npcs.client.gui.advanced.SubGuiAbilityConfig;
|
||||
import noppes.npcs.client.gui.util.GuiNpcButton;
|
||||
import noppes.npcs.client.gui.util.GuiNpcLabel;
|
||||
import noppes.npcs.client.gui.util.GuiNpcTextField;
|
||||
|
||||
/**
|
||||
* GUI for configuring Dash ability type-specific settings.
|
||||
*/
|
||||
public class SubGuiAbilityDash extends SubGuiAbilityConfig {
|
||||
|
||||
private final AbilityDash dash;
|
||||
|
||||
public SubGuiAbilityDash(AbilityDash ability, IAbilityConfigCallback callback) {
|
||||
super(ability, callback);
|
||||
this.dash = ability;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void initTypeTab(int startY) {
|
||||
int y = startY;
|
||||
int labelX = guiLeft + 8;
|
||||
int fieldX = guiLeft + 85;
|
||||
int col2LabelX = guiLeft + 145;
|
||||
int col2FieldX = guiLeft + 205;
|
||||
|
||||
// Row 1: Dash Mode
|
||||
addLabel(new GuiNpcLabel(100, "ability.dashMode", labelX, y + 5));
|
||||
String[] dashModes = {"Aggressive", "Defensive"};
|
||||
addButton(new GuiNpcButton(100, fieldX, y, 80, 20, dashModes, dash.getDashMode().ordinal()));
|
||||
|
||||
y += 24;
|
||||
|
||||
// Row 2: Dash Distance + Dash Speed
|
||||
addLabel(new GuiNpcLabel(101, "ability.dashDist", labelX, y + 5));
|
||||
addTextField(createFloatField(101, fieldX, y, 50, dash.getDashDistance()));
|
||||
|
||||
addLabel(new GuiNpcLabel(102, "ability.dashSpeed", col2LabelX, y + 5));
|
||||
addTextField(createFloatField(102, col2FieldX, y, 50, dash.getDashSpeed()));
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void handleTypeButton(int id, GuiNpcButton button) {
|
||||
if (id == 100) {
|
||||
dash.setDashMode(AbilityDash.DashMode.values()[button.getValue()]);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void handleTypeTextField(int id, GuiNpcTextField field) {
|
||||
switch (id) {
|
||||
case 101: dash.setDashDistance(parseFloat(field, dash.getDashDistance())); break;
|
||||
case 102: dash.setDashSpeed(parseFloat(field, dash.getDashSpeed())); break;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,96 @@
|
||||
package noppes.npcs.client.gui.advanced.ability;
|
||||
|
||||
import kamkeel.npcs.controllers.data.ability.type.AbilityGuard;
|
||||
import noppes.npcs.client.gui.util.IAbilityConfigCallback;
|
||||
import noppes.npcs.client.gui.advanced.SubGuiAbilityConfig;
|
||||
import noppes.npcs.client.gui.util.GuiNpcButton;
|
||||
import noppes.npcs.client.gui.util.GuiNpcLabel;
|
||||
import noppes.npcs.client.gui.util.GuiNpcTextField;
|
||||
|
||||
/**
|
||||
* GUI for configuring Guard ability type-specific settings.
|
||||
*/
|
||||
public class SubGuiAbilityGuard extends SubGuiAbilityConfig {
|
||||
|
||||
private final AbilityGuard guard;
|
||||
|
||||
public SubGuiAbilityGuard(AbilityGuard ability, IAbilityConfigCallback callback) {
|
||||
super(ability, callback);
|
||||
this.guard = ability;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void initTypeTab(int startY) {
|
||||
int y = startY;
|
||||
int labelX = guiLeft + 8;
|
||||
int fieldX = guiLeft + 105;
|
||||
int col2LabelX = guiLeft + 165;
|
||||
int col2FieldX = guiLeft + 225;
|
||||
|
||||
// Row 1: Damage Reduction
|
||||
addLabel(new GuiNpcLabel(100, "ability.dmgReduce", labelX, y + 5));
|
||||
addTextField(createFloatField(100, fieldX, y, 50, guard.getDamageReduction()));
|
||||
|
||||
y += 24;
|
||||
|
||||
// Row 2: Can Counter + Counter Type
|
||||
addLabel(new GuiNpcLabel(101, "ability.canCounter", labelX, y + 5));
|
||||
addButton(new GuiNpcButton(101, fieldX, y, 50, 20, new String[]{"gui.no", "gui.yes"}, guard.isCanCounter() ? 1 : 0));
|
||||
|
||||
addLabel(new GuiNpcLabel(102, "ability.counterType", col2LabelX, y + 5));
|
||||
String[] types = {"Flat", "Percent"};
|
||||
GuiNpcButton counterTypeButton = new GuiNpcButton(102, col2FieldX, y, 60, 20, types, guard.getCounterType().ordinal());
|
||||
counterTypeButton.setEnabled(guard.isCanCounter());
|
||||
addButton(counterTypeButton);
|
||||
|
||||
y += 24;
|
||||
|
||||
// Row 3: Counter Value + Counter Chance
|
||||
addLabel(new GuiNpcLabel(103, "ability.counterValue", labelX, y + 5));
|
||||
GuiNpcTextField counterValueField = createFloatField(103, fieldX, y, 50, guard.getCounterValue());
|
||||
counterValueField.setEnabled(guard.isCanCounter());
|
||||
addTextField(counterValueField);
|
||||
|
||||
addLabel(new GuiNpcLabel(104, "ability.counterChance", col2LabelX, y + 5));
|
||||
GuiNpcTextField counterChanceField = createFloatField(104, col2FieldX, y, 50, guard.getCounterChance());
|
||||
counterChanceField.setEnabled(guard.isCanCounter());
|
||||
addTextField(counterChanceField);
|
||||
|
||||
y += 24;
|
||||
|
||||
// Row 4: Counter Sound + Counter Animation
|
||||
addLabel(new GuiNpcLabel(105, "ability.counterSound", labelX, y + 5));
|
||||
GuiNpcTextField counterSoundField = new GuiNpcTextField(105, this, fontRendererObj, fieldX, y, 100, 20, guard.getCounterSound());
|
||||
counterSoundField.setEnabled(guard.isCanCounter());
|
||||
addTextField(counterSoundField);
|
||||
|
||||
addLabel(new GuiNpcLabel(106, "ability.counterAnim", col2LabelX, y + 5));
|
||||
GuiNpcTextField counterAnimField = createIntField(106, col2FieldX, y, 50, guard.getCounterAnimationId());
|
||||
counterAnimField.setEnabled(guard.isCanCounter());
|
||||
addTextField(counterAnimField);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void handleTypeButton(int id, GuiNpcButton button) {
|
||||
switch (id) {
|
||||
case 101:
|
||||
guard.setCanCounter(button.getValue() == 1);
|
||||
initGui();
|
||||
break;
|
||||
case 102:
|
||||
guard.setCounterType(AbilityGuard.CounterType.values()[button.getValue()]);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void handleTypeTextField(int id, GuiNpcTextField field) {
|
||||
switch (id) {
|
||||
case 100: guard.setDamageReduction(parseFloat(field, guard.getDamageReduction())); break;
|
||||
case 103: guard.setCounterValue(parseFloat(field, guard.getCounterValue())); break;
|
||||
case 104: guard.setCounterChance(parseFloat(field, guard.getCounterChance())); break;
|
||||
case 105: guard.setCounterSound(field.getText()); break;
|
||||
case 106: guard.setCounterAnimationId(field.getInteger()); break;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,98 @@
|
||||
package noppes.npcs.client.gui.advanced.ability;
|
||||
|
||||
import kamkeel.npcs.controllers.data.ability.type.AbilityHazard;
|
||||
import noppes.npcs.client.gui.util.IAbilityConfigCallback;
|
||||
import noppes.npcs.client.gui.advanced.SubGuiAbilityConfig;
|
||||
import noppes.npcs.client.gui.util.GuiNpcButton;
|
||||
import noppes.npcs.client.gui.util.GuiNpcLabel;
|
||||
import noppes.npcs.client.gui.util.GuiNpcTextField;
|
||||
|
||||
/**
|
||||
* GUI for configuring Hazard ability type-specific settings.
|
||||
*/
|
||||
public class SubGuiAbilityHazard extends SubGuiAbilityConfig {
|
||||
|
||||
private final AbilityHazard hazard;
|
||||
|
||||
public SubGuiAbilityHazard(AbilityHazard ability, IAbilityConfigCallback callback) {
|
||||
super(ability, callback);
|
||||
this.hazard = ability;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void initTypeTab(int startY) {
|
||||
int y = startY;
|
||||
int labelX = guiLeft + 8;
|
||||
int fieldX = guiLeft + 85;
|
||||
int col2LabelX = guiLeft + 145;
|
||||
int col2FieldX = guiLeft + 205;
|
||||
|
||||
// Row 1: Shape + Placement
|
||||
addLabel(new GuiNpcLabel(100, "ability.shape", labelX, y + 5));
|
||||
String[] shapes = {"Circle", "Ring", "Cone"};
|
||||
addButton(new GuiNpcButton(100, fieldX, y, 55, 20, shapes, hazard.getShape().ordinal()));
|
||||
|
||||
addLabel(new GuiNpcLabel(101, "ability.placement", col2LabelX, y + 5));
|
||||
String[] placements = {"Caster", "Target", "FollowCast", "FollowTgt"};
|
||||
addButton(new GuiNpcButton(101, col2FieldX, y, 60, 20, placements, hazard.getPlacement().ordinal()));
|
||||
|
||||
y += 24;
|
||||
|
||||
// Row 2: Radius + Inner Radius
|
||||
addLabel(new GuiNpcLabel(102, "ability.radius", labelX, y + 5));
|
||||
addTextField(createFloatField(102, fieldX, y, 50, hazard.getRadius()));
|
||||
|
||||
addLabel(new GuiNpcLabel(103, "ability.innerRadius", col2LabelX, y + 5));
|
||||
addTextField(createFloatField(103, col2FieldX, y, 50, hazard.getInnerRadius()));
|
||||
|
||||
y += 24;
|
||||
|
||||
// Row 3: Damage Per Tick + Damage Interval
|
||||
addLabel(new GuiNpcLabel(104, "ability.dmgPerTick", labelX, y + 5));
|
||||
addTextField(createFloatField(104, fieldX, y, 50, hazard.getDamagePerTick()));
|
||||
|
||||
addLabel(new GuiNpcLabel(105, "ability.dmgInterval", col2LabelX, y + 5));
|
||||
addTextField(createIntField(105, col2FieldX, y, 50, hazard.getDamageInterval()));
|
||||
|
||||
y += 24;
|
||||
|
||||
// Row 4: Slowness Level + Debuff Duration
|
||||
addLabel(new GuiNpcLabel(106, "ability.slownessLvl", labelX, y + 5));
|
||||
addTextField(createIntField(106, fieldX, y, 50, hazard.getSlownessLevel()));
|
||||
|
||||
addLabel(new GuiNpcLabel(107, "ability.debuffDur", col2LabelX, y + 5));
|
||||
addTextField(createIntField(107, col2FieldX, y, 50, hazard.getDebuffDuration()));
|
||||
|
||||
y += 24;
|
||||
|
||||
// Row 5: Poison Level + Affects Caster
|
||||
addLabel(new GuiNpcLabel(108, "ability.poisonLvl", labelX, y + 5));
|
||||
addTextField(createIntField(108, fieldX, y, 50, hazard.getPoisonLevel()));
|
||||
|
||||
addLabel(new GuiNpcLabel(109, "ability.affectsCaster", col2LabelX, y + 5));
|
||||
addButton(new GuiNpcButton(109, col2FieldX, y, 50, 20, new String[]{"gui.no", "gui.yes"}, hazard.isAffectsCaster() ? 1 : 0));
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void handleTypeButton(int id, GuiNpcButton button) {
|
||||
int value = button.getValue();
|
||||
switch (id) {
|
||||
case 100: hazard.setShape(AbilityHazard.HazardShape.values()[value]); break;
|
||||
case 101: hazard.setPlacement(AbilityHazard.PlacementMode.values()[value]); break;
|
||||
case 109: hazard.setAffectsCaster(value == 1); break;
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void handleTypeTextField(int id, GuiNpcTextField field) {
|
||||
switch (id) {
|
||||
case 102: hazard.setRadius(parseFloat(field, hazard.getRadius())); break;
|
||||
case 103: hazard.setInnerRadius(parseFloat(field, hazard.getInnerRadius())); break;
|
||||
case 104: hazard.setDamagePerTick(parseFloat(field, hazard.getDamagePerTick())); break;
|
||||
case 105: hazard.setDamageInterval(field.getInteger()); break;
|
||||
case 106: hazard.setSlownessLevel(field.getInteger()); break;
|
||||
case 107: hazard.setDebuffDuration(field.getInteger()); break;
|
||||
case 108: hazard.setPoisonLevel(field.getInteger()); break;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,74 @@
|
||||
package noppes.npcs.client.gui.advanced.ability;
|
||||
|
||||
import kamkeel.npcs.controllers.data.ability.type.AbilityHeal;
|
||||
import noppes.npcs.client.gui.util.IAbilityConfigCallback;
|
||||
import noppes.npcs.client.gui.advanced.SubGuiAbilityConfig;
|
||||
import noppes.npcs.client.gui.util.GuiNpcButton;
|
||||
import noppes.npcs.client.gui.util.GuiNpcLabel;
|
||||
import noppes.npcs.client.gui.util.GuiNpcTextField;
|
||||
|
||||
/**
|
||||
* GUI for configuring Heal ability type-specific settings.
|
||||
*/
|
||||
public class SubGuiAbilityHeal extends SubGuiAbilityConfig {
|
||||
|
||||
private final AbilityHeal heal;
|
||||
|
||||
public SubGuiAbilityHeal(AbilityHeal ability, IAbilityConfigCallback callback) {
|
||||
super(ability, callback);
|
||||
this.heal = ability;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void initTypeTab(int startY) {
|
||||
int y = startY;
|
||||
int labelX = guiLeft + 8;
|
||||
int fieldX = guiLeft + 85;
|
||||
int col2LabelX = guiLeft + 145;
|
||||
int col2FieldX = guiLeft + 205;
|
||||
|
||||
// Row 1: Heal Amount + Heal Percent
|
||||
addLabel(new GuiNpcLabel(100, "ability.healAmount", labelX, y + 5));
|
||||
addTextField(createFloatField(100, fieldX, y, 50, heal.getHealAmount()));
|
||||
|
||||
addLabel(new GuiNpcLabel(101, "ability.healPercent", col2LabelX, y + 5));
|
||||
addTextField(createFloatField(101, col2FieldX, y, 50, heal.getHealPercent()));
|
||||
|
||||
y += 24;
|
||||
|
||||
// Row 2: Heal Radius + Instant Heal
|
||||
addLabel(new GuiNpcLabel(102, "ability.healRadius", labelX, y + 5));
|
||||
addTextField(createFloatField(102, fieldX, y, 50, heal.getHealRadius()));
|
||||
|
||||
addLabel(new GuiNpcLabel(103, "ability.instant", col2LabelX, y + 5));
|
||||
addButton(new GuiNpcButton(103, col2FieldX, y, 50, 20, new String[]{"gui.no", "gui.yes"}, heal.isInstantHeal() ? 1 : 0));
|
||||
|
||||
y += 24;
|
||||
|
||||
// Row 3: Heal Self + Heal Allies
|
||||
addLabel(new GuiNpcLabel(104, "ability.healSelf", labelX, y + 5));
|
||||
addButton(new GuiNpcButton(104, fieldX, y, 50, 20, new String[]{"gui.no", "gui.yes"}, heal.isHealSelf() ? 1 : 0));
|
||||
|
||||
addLabel(new GuiNpcLabel(105, "ability.healAllies", col2LabelX, y + 5));
|
||||
addButton(new GuiNpcButton(105, col2FieldX, y, 50, 20, new String[]{"gui.no", "gui.yes"}, heal.isHealAllies() ? 1 : 0));
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void handleTypeButton(int id, GuiNpcButton button) {
|
||||
int value = button.getValue();
|
||||
switch (id) {
|
||||
case 103: heal.setInstantHeal(value == 1); break;
|
||||
case 104: heal.setHealSelf(value == 1); break;
|
||||
case 105: heal.setHealAllies(value == 1); break;
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void handleTypeTextField(int id, GuiNpcTextField field) {
|
||||
switch (id) {
|
||||
case 100: heal.setHealAmount(parseFloat(field, heal.getHealAmount())); break;
|
||||
case 101: heal.setHealPercent(parseFloat(field, heal.getHealPercent())); break;
|
||||
case 102: heal.setHealRadius(parseFloat(field, heal.getHealRadius())); break;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,62 @@
|
||||
package noppes.npcs.client.gui.advanced.ability;
|
||||
|
||||
import kamkeel.npcs.controllers.data.ability.type.AbilityHeavyHit;
|
||||
import noppes.npcs.client.gui.util.IAbilityConfigCallback;
|
||||
import noppes.npcs.client.gui.advanced.SubGuiAbilityConfig;
|
||||
import noppes.npcs.client.gui.util.GuiNpcLabel;
|
||||
import noppes.npcs.client.gui.util.GuiNpcTextField;
|
||||
|
||||
/**
|
||||
* GUI for configuring Heavy Hit ability type-specific settings.
|
||||
*/
|
||||
public class SubGuiAbilityHeavyHit extends SubGuiAbilityConfig {
|
||||
|
||||
private final AbilityHeavyHit heavyHit;
|
||||
|
||||
public SubGuiAbilityHeavyHit(AbilityHeavyHit ability, IAbilityConfigCallback callback) {
|
||||
super(ability, callback);
|
||||
this.heavyHit = ability;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void initTypeTab(int startY) {
|
||||
int y = startY;
|
||||
int labelX = guiLeft + 8;
|
||||
int fieldX = guiLeft + 85;
|
||||
int col2LabelX = guiLeft + 145;
|
||||
int col2FieldX = guiLeft + 205;
|
||||
|
||||
// Row 1: Damage + Potion Time
|
||||
addLabel(new GuiNpcLabel(100, "ability.damage", labelX, y + 5));
|
||||
addTextField(createFloatField(100, fieldX, y, 50, heavyHit.getDamage()));
|
||||
|
||||
addLabel(new GuiNpcLabel(101, "ability.potionTime", col2LabelX, y + 5));
|
||||
addTextField(createIntField(101, col2FieldX, y, 50, heavyHit.getPotionDurationSeconds()));
|
||||
|
||||
y += 24;
|
||||
|
||||
// Row 2: Knockback + Slowness Level
|
||||
addLabel(new GuiNpcLabel(102, "ability.knockback", labelX, y + 5));
|
||||
addTextField(createFloatField(102, fieldX, y, 50, heavyHit.getKnockback()));
|
||||
|
||||
addLabel(new GuiNpcLabel(103, "ability.slownessLvl", col2LabelX, y + 5));
|
||||
addTextField(createIntField(103, col2FieldX, y, 50, heavyHit.getSlownessLevel()));
|
||||
|
||||
y += 24;
|
||||
|
||||
// Row 3: Weakness Level
|
||||
addLabel(new GuiNpcLabel(104, "ability.weaknessLvl", labelX, y + 5));
|
||||
addTextField(createIntField(104, fieldX, y, 50, heavyHit.getWeaknessLevel()));
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void handleTypeTextField(int id, GuiNpcTextField field) {
|
||||
switch (id) {
|
||||
case 100: heavyHit.setDamage(parseFloat(field, heavyHit.getDamage())); break;
|
||||
case 101: heavyHit.setPotionDurationSeconds(field.getInteger()); break;
|
||||
case 102: heavyHit.setKnockback(parseFloat(field, heavyHit.getKnockback())); break;
|
||||
case 103: heavyHit.setSlownessLevel(field.getInteger()); break;
|
||||
case 104: heavyHit.setWeaknessLevel(field.getInteger()); break;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,96 @@
|
||||
package noppes.npcs.client.gui.advanced.ability;
|
||||
|
||||
import kamkeel.npcs.controllers.data.ability.type.AbilityOrb;
|
||||
import noppes.npcs.client.gui.util.IAbilityConfigCallback;
|
||||
import noppes.npcs.client.gui.advanced.SubGuiAbilityConfig;
|
||||
import noppes.npcs.client.gui.util.GuiNpcButton;
|
||||
import noppes.npcs.client.gui.util.GuiNpcLabel;
|
||||
import noppes.npcs.client.gui.util.GuiNpcTextField;
|
||||
|
||||
/**
|
||||
* GUI for configuring Orb ability type-specific settings.
|
||||
*/
|
||||
public class SubGuiAbilityOrb extends SubGuiAbilityConfig {
|
||||
|
||||
private final AbilityOrb orb;
|
||||
|
||||
public SubGuiAbilityOrb(AbilityOrb ability, IAbilityConfigCallback callback) {
|
||||
super(ability, callback);
|
||||
this.orb = ability;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void initTypeTab(int startY) {
|
||||
int y = startY;
|
||||
int labelX = guiLeft + 8;
|
||||
int fieldX = guiLeft + 85;
|
||||
int col2LabelX = guiLeft + 145;
|
||||
int col2FieldX = guiLeft + 205;
|
||||
|
||||
// Row 1: Damage + Speed
|
||||
addLabel(new GuiNpcLabel(100, "ability.damage", labelX, y + 5));
|
||||
addTextField(createFloatField(100, fieldX, y, 50, orb.getDamage()));
|
||||
|
||||
addLabel(new GuiNpcLabel(101, "ability.speed", col2LabelX, y + 5));
|
||||
addTextField(createFloatField(101, col2FieldX, y, 50, orb.getOrbSpeed()));
|
||||
|
||||
y += 24;
|
||||
|
||||
// Row 2: Orb Size + Max Distance
|
||||
addLabel(new GuiNpcLabel(102, "ability.orbSize", labelX, y + 5));
|
||||
addTextField(createFloatField(102, fieldX, y, 50, orb.getOrbSize()));
|
||||
|
||||
addLabel(new GuiNpcLabel(103, "ability.maxDist", col2LabelX, y + 5));
|
||||
addTextField(createFloatField(103, col2FieldX, y, 50, orb.getMaxDistance()));
|
||||
|
||||
y += 24;
|
||||
|
||||
// Row 3: Homing + Homing Strength
|
||||
addLabel(new GuiNpcLabel(104, "ability.homing", labelX, y + 5));
|
||||
addButton(new GuiNpcButton(104, fieldX, y, 50, 20, new String[]{"gui.no", "gui.yes"}, orb.isHoming() ? 1 : 0));
|
||||
|
||||
addLabel(new GuiNpcLabel(105, "ability.homingStr", col2LabelX, y + 5));
|
||||
addTextField(createFloatField(105, col2FieldX, y, 50, orb.getHomingStrength()));
|
||||
|
||||
y += 24;
|
||||
|
||||
// Row 4: Explosive + Explosion Radius
|
||||
addLabel(new GuiNpcLabel(106, "ability.explosive", labelX, y + 5));
|
||||
addButton(new GuiNpcButton(106, fieldX, y, 50, 20, new String[]{"gui.no", "gui.yes"}, orb.isExplosive() ? 1 : 0));
|
||||
|
||||
addLabel(new GuiNpcLabel(107, "ability.explosionRad", col2LabelX, y + 5));
|
||||
addTextField(createFloatField(107, col2FieldX, y, 50, orb.getExplosionRadius()));
|
||||
|
||||
y += 24;
|
||||
|
||||
// Row 5: Knockback + Max Lifetime
|
||||
addLabel(new GuiNpcLabel(108, "ability.knockback", labelX, y + 5));
|
||||
addTextField(createFloatField(108, fieldX, y, 50, orb.getKnockback()));
|
||||
|
||||
addLabel(new GuiNpcLabel(109, "ability.lifetime", col2LabelX, y + 5));
|
||||
addTextField(createIntField(109, col2FieldX, y, 50, orb.getMaxLifetime()));
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void handleTypeButton(int id, GuiNpcButton button) {
|
||||
int value = button.getValue();
|
||||
switch (id) {
|
||||
case 104: orb.setHoming(value == 1); break;
|
||||
case 106: orb.setExplosive(value == 1); break;
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void handleTypeTextField(int id, GuiNpcTextField field) {
|
||||
switch (id) {
|
||||
case 100: orb.setDamage(parseFloat(field, orb.getDamage())); break;
|
||||
case 101: orb.setOrbSpeed(parseFloat(field, orb.getOrbSpeed())); break;
|
||||
case 102: orb.setOrbSize(parseFloat(field, orb.getOrbSize())); break;
|
||||
case 103: orb.setMaxDistance(parseFloat(field, orb.getMaxDistance())); break;
|
||||
case 105: orb.setHomingStrength(parseFloat(field, orb.getHomingStrength())); break;
|
||||
case 107: orb.setExplosionRadius(parseFloat(field, orb.getExplosionRadius())); break;
|
||||
case 108: orb.setKnockback(parseFloat(field, orb.getKnockback())); break;
|
||||
case 109: orb.setMaxLifetime(field.getInteger()); break;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,97 @@
|
||||
package noppes.npcs.client.gui.advanced.ability;
|
||||
|
||||
import kamkeel.npcs.controllers.data.ability.type.AbilityProjectile;
|
||||
import noppes.npcs.client.gui.util.IAbilityConfigCallback;
|
||||
import noppes.npcs.client.gui.advanced.SubGuiAbilityConfig;
|
||||
import noppes.npcs.client.gui.util.GuiNpcButton;
|
||||
import noppes.npcs.client.gui.util.GuiNpcLabel;
|
||||
import noppes.npcs.client.gui.util.GuiNpcTextField;
|
||||
|
||||
/**
|
||||
* GUI for configuring Projectile ability type-specific settings.
|
||||
*/
|
||||
public class SubGuiAbilityProjectile extends SubGuiAbilityConfig {
|
||||
|
||||
private final AbilityProjectile projectile;
|
||||
|
||||
public SubGuiAbilityProjectile(AbilityProjectile ability, IAbilityConfigCallback callback) {
|
||||
super(ability, callback);
|
||||
this.projectile = ability;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void initTypeTab(int startY) {
|
||||
int y = startY;
|
||||
int labelX = guiLeft + 8;
|
||||
int fieldX = guiLeft + 85;
|
||||
int col2LabelX = guiLeft + 145;
|
||||
int col2FieldX = guiLeft + 205;
|
||||
|
||||
// Row 1: Damage + Speed
|
||||
addLabel(new GuiNpcLabel(100, "ability.damage", labelX, y + 5));
|
||||
addTextField(createFloatField(100, fieldX, y, 50, projectile.getDamage()));
|
||||
|
||||
addLabel(new GuiNpcLabel(101, "ability.speed", col2LabelX, y + 5));
|
||||
addTextField(createFloatField(101, col2FieldX, y, 50, projectile.getSpeed()));
|
||||
|
||||
y += 24;
|
||||
|
||||
// Row 2: Knockback + Projectile Type
|
||||
addLabel(new GuiNpcLabel(102, "ability.knockback", labelX, y + 5));
|
||||
addTextField(createFloatField(102, fieldX, y, 50, projectile.getKnockback()));
|
||||
|
||||
addLabel(new GuiNpcLabel(103, "ability.projType", col2LabelX, y + 5));
|
||||
String[] projTypes = {"fireball", "arrow", "magic"};
|
||||
int typeIdx = 0;
|
||||
String currType = projectile.getProjectileType();
|
||||
for (int i = 0; i < projTypes.length; i++) {
|
||||
if (projTypes[i].equals(currType)) {
|
||||
typeIdx = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
addButton(new GuiNpcButton(103, col2FieldX, y, 60, 20, projTypes, typeIdx));
|
||||
|
||||
y += 24;
|
||||
|
||||
// Row 3: Explosive + Explosion Radius
|
||||
addLabel(new GuiNpcLabel(104, "ability.explosive", labelX, y + 5));
|
||||
addButton(new GuiNpcButton(104, fieldX, y, 50, 20, new String[]{"gui.no", "gui.yes"}, projectile.isExplosive() ? 1 : 0));
|
||||
|
||||
addLabel(new GuiNpcLabel(105, "ability.explosionRad", col2LabelX, y + 5));
|
||||
addTextField(createFloatField(105, col2FieldX, y, 50, projectile.getExplosionRadius()));
|
||||
|
||||
y += 24;
|
||||
|
||||
// Row 4: Homing + Homing Strength
|
||||
addLabel(new GuiNpcLabel(106, "ability.homing", labelX, y + 5));
|
||||
addButton(new GuiNpcButton(106, fieldX, y, 50, 20, new String[]{"gui.no", "gui.yes"}, projectile.isHoming() ? 1 : 0));
|
||||
|
||||
addLabel(new GuiNpcLabel(107, "ability.homingStr", col2LabelX, y + 5));
|
||||
addTextField(createFloatField(107, col2FieldX, y, 50, projectile.getHomingStrength()));
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void handleTypeButton(int id, GuiNpcButton button) {
|
||||
int value = button.getValue();
|
||||
switch (id) {
|
||||
case 103:
|
||||
String[] projTypes = {"fireball", "arrow", "magic"};
|
||||
projectile.setProjectileType(projTypes[value]);
|
||||
break;
|
||||
case 104: projectile.setExplosive(value == 1); break;
|
||||
case 106: projectile.setHoming(value == 1); break;
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void handleTypeTextField(int id, GuiNpcTextField field) {
|
||||
switch (id) {
|
||||
case 100: projectile.setDamage(parseFloat(field, projectile.getDamage())); break;
|
||||
case 101: projectile.setSpeed(parseFloat(field, projectile.getSpeed())); break;
|
||||
case 102: projectile.setKnockback(parseFloat(field, projectile.getKnockback())); break;
|
||||
case 105: projectile.setExplosionRadius(parseFloat(field, projectile.getExplosionRadius())); break;
|
||||
case 107: projectile.setHomingStrength(parseFloat(field, projectile.getHomingStrength())); break;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,65 @@
|
||||
package noppes.npcs.client.gui.advanced.ability;
|
||||
|
||||
import kamkeel.npcs.controllers.data.ability.type.AbilityShockwave;
|
||||
import noppes.npcs.client.gui.util.IAbilityConfigCallback;
|
||||
import noppes.npcs.client.gui.advanced.SubGuiAbilityConfig;
|
||||
import noppes.npcs.client.gui.util.GuiNpcLabel;
|
||||
import noppes.npcs.client.gui.util.GuiNpcTextField;
|
||||
|
||||
/**
|
||||
* GUI for configuring Shockwave ability type-specific settings.
|
||||
*/
|
||||
public class SubGuiAbilityShockwave extends SubGuiAbilityConfig {
|
||||
|
||||
private final AbilityShockwave shockwave;
|
||||
|
||||
public SubGuiAbilityShockwave(AbilityShockwave ability, IAbilityConfigCallback callback) {
|
||||
super(ability, callback);
|
||||
this.shockwave = ability;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void initTypeTab(int startY) {
|
||||
int y = startY;
|
||||
int labelX = guiLeft + 8;
|
||||
int fieldX = guiLeft + 85;
|
||||
int col2LabelX = guiLeft + 145;
|
||||
int col2FieldX = guiLeft + 205;
|
||||
|
||||
// Row 1: Damage + Push Radius
|
||||
addLabel(new GuiNpcLabel(100, "ability.damage", labelX, y + 5));
|
||||
addTextField(createFloatField(100, fieldX, y, 50, shockwave.getDamage()));
|
||||
|
||||
addLabel(new GuiNpcLabel(101, "ability.pushRadius", col2LabelX, y + 5));
|
||||
addTextField(createFloatField(101, col2FieldX, y, 50, shockwave.getPushRadius()));
|
||||
|
||||
y += 24;
|
||||
|
||||
// Row 2: Push Strength
|
||||
addLabel(new GuiNpcLabel(102, "ability.pushStrength", labelX, y + 5));
|
||||
addTextField(createFloatField(102, fieldX, y, 50, shockwave.getPushStrength()));
|
||||
|
||||
y += 24;
|
||||
|
||||
// Row 3: Stun Duration + Max Targets
|
||||
addLabel(new GuiNpcLabel(103, "ability.stunDuration", labelX, y + 5));
|
||||
addTextField(createIntField(103, fieldX, y, 50, shockwave.getStunDuration()));
|
||||
|
||||
addLabel(new GuiNpcLabel(104, "ability.maxTargets", col2LabelX, y + 5));
|
||||
addTextField(createIntField(104, col2FieldX, y, 50, shockwave.getMaxTargets()));
|
||||
|
||||
y += 24;
|
||||
addLabel(new GuiNpcLabel(105, "ability.shockwaveFalloff", labelX, y + 5));
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void handleTypeTextField(int id, GuiNpcTextField field) {
|
||||
switch (id) {
|
||||
case 100: shockwave.setDamage(parseFloat(field, shockwave.getDamage())); break;
|
||||
case 101: shockwave.setPushRadius(parseFloat(field, shockwave.getPushRadius())); break;
|
||||
case 102: shockwave.setPushStrength(parseFloat(field, shockwave.getPushStrength())); break;
|
||||
case 103: shockwave.setStunDuration(field.getInteger()); break;
|
||||
case 104: shockwave.setMaxTargets(field.getInteger()); break;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,62 @@
|
||||
package noppes.npcs.client.gui.advanced.ability;
|
||||
|
||||
import kamkeel.npcs.controllers.data.ability.type.AbilitySlam;
|
||||
import noppes.npcs.client.gui.util.IAbilityConfigCallback;
|
||||
import noppes.npcs.client.gui.advanced.SubGuiAbilityConfig;
|
||||
import noppes.npcs.client.gui.util.GuiNpcLabel;
|
||||
import noppes.npcs.client.gui.util.GuiNpcTextField;
|
||||
|
||||
/**
|
||||
* GUI for configuring Slam ability type-specific settings.
|
||||
*/
|
||||
public class SubGuiAbilitySlam extends SubGuiAbilityConfig {
|
||||
|
||||
private final AbilitySlam slam;
|
||||
|
||||
public SubGuiAbilitySlam(AbilitySlam ability, IAbilityConfigCallback callback) {
|
||||
super(ability, callback);
|
||||
this.slam = ability;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void initTypeTab(int startY) {
|
||||
int y = startY;
|
||||
int labelX = guiLeft + 8;
|
||||
int fieldX = guiLeft + 85;
|
||||
int col2LabelX = guiLeft + 145;
|
||||
int col2FieldX = guiLeft + 205;
|
||||
|
||||
// Row 1: Damage + Radius
|
||||
addLabel(new GuiNpcLabel(100, "ability.damage", labelX, y + 5));
|
||||
addTextField(createFloatField(100, fieldX, y, 50, slam.getDamage()));
|
||||
|
||||
addLabel(new GuiNpcLabel(101, "ability.radius", col2LabelX, y + 5));
|
||||
addTextField(createFloatField(101, col2FieldX, y, 50, slam.getRadius()));
|
||||
|
||||
y += 24;
|
||||
|
||||
// Row 2: Knockback + Leap Speed
|
||||
addLabel(new GuiNpcLabel(102, "ability.knockback", labelX, y + 5));
|
||||
addTextField(createFloatField(102, fieldX, y, 50, slam.getKnockbackStrength()));
|
||||
|
||||
addLabel(new GuiNpcLabel(103, "ability.leapSpeed", col2LabelX, y + 5));
|
||||
addTextField(createFloatField(103, col2FieldX, y, 50, slam.getLeapSpeed()));
|
||||
|
||||
y += 24;
|
||||
|
||||
// Row 3: Leap Height
|
||||
addLabel(new GuiNpcLabel(104, "ability.leapHeight", labelX, y + 5));
|
||||
addTextField(createFloatField(104, fieldX, y, 50, slam.getLeapHeight()));
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void handleTypeTextField(int id, GuiNpcTextField field) {
|
||||
switch (id) {
|
||||
case 100: slam.setDamage(parseFloat(field, slam.getDamage())); break;
|
||||
case 101: slam.setRadius(parseFloat(field, slam.getRadius())); break;
|
||||
case 102: slam.setKnockbackStrength(parseFloat(field, slam.getKnockbackStrength())); break;
|
||||
case 103: slam.setLeapSpeed(parseFloat(field, slam.getLeapSpeed())); break;
|
||||
case 104: slam.setLeapHeight(parseFloat(field, slam.getLeapHeight())); break;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,115 @@
|
||||
package noppes.npcs.client.gui.advanced.ability;
|
||||
|
||||
import kamkeel.npcs.controllers.data.ability.type.AbilityTeleport;
|
||||
import noppes.npcs.client.gui.util.IAbilityConfigCallback;
|
||||
import noppes.npcs.client.gui.advanced.SubGuiAbilityConfig;
|
||||
import noppes.npcs.client.gui.util.GuiNpcButton;
|
||||
import noppes.npcs.client.gui.util.GuiNpcLabel;
|
||||
import noppes.npcs.client.gui.util.GuiNpcTextField;
|
||||
|
||||
/**
|
||||
* GUI for configuring Teleport ability type-specific settings.
|
||||
*/
|
||||
public class SubGuiAbilityTeleport extends SubGuiAbilityConfig {
|
||||
|
||||
private final AbilityTeleport teleport;
|
||||
|
||||
public SubGuiAbilityTeleport(AbilityTeleport ability, IAbilityConfigCallback callback) {
|
||||
super(ability, callback);
|
||||
this.teleport = ability;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void initTypeTab(int startY) {
|
||||
int y = startY;
|
||||
int labelX = guiLeft + 8;
|
||||
int fieldX = guiLeft + 85;
|
||||
int col2LabelX = guiLeft + 145;
|
||||
int col2FieldX = guiLeft + 205;
|
||||
|
||||
// Row 1: Mode
|
||||
addLabel(new GuiNpcLabel(100, "ability.mode", labelX, y + 5));
|
||||
String[] modes = {"Blink", "Behind", "Single"};
|
||||
addButton(new GuiNpcButton(100, fieldX, y, 80, 20, modes, teleport.getMode().ordinal()));
|
||||
|
||||
y += 24;
|
||||
|
||||
switch (teleport.getMode()) {
|
||||
case BLINK:
|
||||
// Row 2: Blink Radius + Blink Count
|
||||
addLabel(new GuiNpcLabel(101, "ability.blinkRadius", labelX, y + 5));
|
||||
addTextField(createFloatField(101, fieldX, y, 50, teleport.getBlinkRadius()));
|
||||
|
||||
addLabel(new GuiNpcLabel(102, "ability.blinkCount", col2LabelX, y + 5));
|
||||
addTextField(createIntField(102, col2FieldX, y, 50, teleport.getBlinkCount()));
|
||||
|
||||
y += 24;
|
||||
|
||||
// Row 3: Blink Delay + Line of Sight
|
||||
addLabel(new GuiNpcLabel(103, "ability.blinkDelay", labelX, y + 5));
|
||||
addTextField(createIntField(103, fieldX, y, 50, teleport.getBlinkDelayTicks()));
|
||||
|
||||
addLabel(new GuiNpcLabel(105, "ability.lineOfSight", col2LabelX, y + 5));
|
||||
addButton(new GuiNpcButton(105, col2FieldX, y, 50, 20, new String[]{"gui.no", "gui.yes"}, teleport.isRequireLineOfSight() ? 1 : 0));
|
||||
y += 24;
|
||||
break;
|
||||
case SINGLE:
|
||||
// Row 2: Blink Radius + Line of Sight
|
||||
addLabel(new GuiNpcLabel(101, "ability.blinkRadius", labelX, y + 5));
|
||||
addTextField(createFloatField(101, fieldX, y, 50, teleport.getBlinkRadius()));
|
||||
|
||||
addLabel(new GuiNpcLabel(105, "ability.lineOfSight", col2LabelX, y + 5));
|
||||
addButton(new GuiNpcButton(105, col2FieldX, y, 50, 20, new String[]{"gui.no", "gui.yes"}, teleport.isRequireLineOfSight() ? 1 : 0));
|
||||
y += 24;
|
||||
break;
|
||||
case BEHIND:
|
||||
// Row 2: Behind Distance
|
||||
addLabel(new GuiNpcLabel(104, "ability.behindDistance", labelX, y + 5));
|
||||
addTextField(createFloatField(104, fieldX, y, 50, teleport.getBehindDistance()));
|
||||
y += 24;
|
||||
break;
|
||||
}
|
||||
|
||||
// Damage + Damage Radius
|
||||
addLabel(new GuiNpcLabel(106, "ability.damage", labelX, y + 5));
|
||||
addTextField(createFloatField(106, fieldX, y, 50, teleport.getDamage()));
|
||||
|
||||
addLabel(new GuiNpcLabel(107, "ability.dmgRadius", col2LabelX, y + 5));
|
||||
addTextField(createFloatField(107, col2FieldX, y, 50, teleport.getDamageRadius()));
|
||||
|
||||
y += 24;
|
||||
|
||||
// Damage at Start/End
|
||||
addLabel(new GuiNpcLabel(108, "ability.dmgAtStart", labelX, y + 5));
|
||||
addButton(new GuiNpcButton(108, fieldX, y, 50, 20, new String[]{"gui.no", "gui.yes"}, teleport.isDamageAtStart() ? 1 : 0));
|
||||
|
||||
addLabel(new GuiNpcLabel(109, "ability.dmgAtEnd", col2LabelX, y + 5));
|
||||
addButton(new GuiNpcButton(109, col2FieldX, y, 50, 20, new String[]{"gui.no", "gui.yes"}, teleport.isDamageAtEnd() ? 1 : 0));
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void handleTypeButton(int id, GuiNpcButton button) {
|
||||
int value = button.getValue();
|
||||
switch (id) {
|
||||
case 100:
|
||||
teleport.setMode(AbilityTeleport.TeleportMode.values()[value]);
|
||||
initGui();
|
||||
break;
|
||||
case 105: teleport.setRequireLineOfSight(value == 1); break;
|
||||
case 108: teleport.setDamageAtStart(value == 1); break;
|
||||
case 109: teleport.setDamageAtEnd(value == 1); break;
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void handleTypeTextField(int id, GuiNpcTextField field) {
|
||||
switch (id) {
|
||||
case 101: teleport.setBlinkRadius(parseFloat(field, teleport.getBlinkRadius())); break;
|
||||
case 102: teleport.setBlinkCount(field.getInteger()); break;
|
||||
case 103: teleport.setBlinkDelayTicks(field.getInteger()); break;
|
||||
case 104: teleport.setBehindDistance(parseFloat(field, teleport.getBehindDistance())); break;
|
||||
case 106: teleport.setDamage(parseFloat(field, teleport.getDamage())); break;
|
||||
case 107: teleport.setDamageRadius(parseFloat(field, teleport.getDamageRadius())); break;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,92 @@
|
||||
package noppes.npcs.client.gui.advanced.ability;
|
||||
|
||||
import kamkeel.npcs.controllers.data.ability.type.AbilityTrap;
|
||||
import noppes.npcs.client.gui.util.IAbilityConfigCallback;
|
||||
import noppes.npcs.client.gui.advanced.SubGuiAbilityConfig;
|
||||
import noppes.npcs.client.gui.util.GuiNpcButton;
|
||||
import noppes.npcs.client.gui.util.GuiNpcLabel;
|
||||
import noppes.npcs.client.gui.util.GuiNpcTextField;
|
||||
|
||||
/**
|
||||
* GUI for configuring Trap ability type-specific settings.
|
||||
*/
|
||||
public class SubGuiAbilityTrap extends SubGuiAbilityConfig {
|
||||
|
||||
private final AbilityTrap trap;
|
||||
|
||||
public SubGuiAbilityTrap(AbilityTrap ability, IAbilityConfigCallback callback) {
|
||||
super(ability, callback);
|
||||
this.trap = ability;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void initTypeTab(int startY) {
|
||||
int y = startY;
|
||||
int labelX = guiLeft + 8;
|
||||
int fieldX = guiLeft + 85;
|
||||
int col2LabelX = guiLeft + 145;
|
||||
int col2FieldX = guiLeft + 205;
|
||||
|
||||
// Row 1: Placement + Trigger Radius
|
||||
addLabel(new GuiNpcLabel(100, "ability.placement", labelX, y + 5));
|
||||
String[] placements = {"Caster", "Target", "Ahead"};
|
||||
addButton(new GuiNpcButton(100, fieldX, y, 55, 20, placements, trap.getPlacement().ordinal()));
|
||||
|
||||
addLabel(new GuiNpcLabel(101, "ability.triggerRad", col2LabelX, y + 5));
|
||||
addTextField(createFloatField(101, col2FieldX, y, 50, trap.getTriggerRadius()));
|
||||
|
||||
y += 24;
|
||||
|
||||
// Row 2: Damage + Damage Radius
|
||||
addLabel(new GuiNpcLabel(102, "ability.damage", labelX, y + 5));
|
||||
addTextField(createFloatField(102, fieldX, y, 50, trap.getDamage()));
|
||||
|
||||
addLabel(new GuiNpcLabel(103, "ability.dmgRadius", col2LabelX, y + 5));
|
||||
addTextField(createFloatField(103, col2FieldX, y, 50, trap.getDamageRadius()));
|
||||
|
||||
y += 24;
|
||||
|
||||
// Row 3: Arm Time + Max Triggers
|
||||
addLabel(new GuiNpcLabel(104, "ability.armTime", labelX, y + 5));
|
||||
addTextField(createIntField(104, fieldX, y, 50, trap.getArmTime()));
|
||||
|
||||
addLabel(new GuiNpcLabel(105, "ability.maxTriggers", col2LabelX, y + 5));
|
||||
addTextField(createIntField(105, col2FieldX, y, 50, trap.getMaxTriggers()));
|
||||
|
||||
y += 24;
|
||||
|
||||
// Row 4: Root Duration + Stun Duration
|
||||
addLabel(new GuiNpcLabel(106, "ability.rootDuration", labelX, y + 5));
|
||||
addTextField(createIntField(106, fieldX, y, 50, trap.getRootDuration()));
|
||||
|
||||
addLabel(new GuiNpcLabel(107, "ability.stunDuration", col2LabelX, y + 5));
|
||||
addTextField(createIntField(107, col2FieldX, y, 50, trap.getStunDuration()));
|
||||
|
||||
y += 24;
|
||||
|
||||
// Row 5: Knockback
|
||||
addLabel(new GuiNpcLabel(108, "ability.knockback", labelX, y + 5));
|
||||
addTextField(createFloatField(108, fieldX, y, 50, trap.getKnockback()));
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void handleTypeButton(int id, GuiNpcButton button) {
|
||||
if (id == 100) {
|
||||
trap.setPlacement(AbilityTrap.TrapPlacement.values()[button.getValue()]);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void handleTypeTextField(int id, GuiNpcTextField field) {
|
||||
switch (id) {
|
||||
case 101: trap.setTriggerRadius(parseFloat(field, trap.getTriggerRadius())); break;
|
||||
case 102: trap.setDamage(parseFloat(field, trap.getDamage())); break;
|
||||
case 103: trap.setDamageRadius(parseFloat(field, trap.getDamageRadius())); break;
|
||||
case 104: trap.setArmTime(field.getInteger()); break;
|
||||
case 105: trap.setMaxTriggers(field.getInteger()); break;
|
||||
case 106: trap.setRootDuration(field.getInteger()); break;
|
||||
case 107: trap.setStunDuration(field.getInteger()); break;
|
||||
case 108: trap.setKnockback(parseFloat(field, trap.getKnockback())); break;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,96 @@
|
||||
package noppes.npcs.client.gui.advanced.ability;
|
||||
|
||||
import kamkeel.npcs.controllers.data.ability.type.AbilityVortex;
|
||||
import noppes.npcs.client.gui.util.IAbilityConfigCallback;
|
||||
import noppes.npcs.client.gui.advanced.SubGuiAbilityConfig;
|
||||
import noppes.npcs.client.gui.util.GuiNpcButton;
|
||||
import noppes.npcs.client.gui.util.GuiNpcLabel;
|
||||
import noppes.npcs.client.gui.util.GuiNpcTextField;
|
||||
|
||||
/**
|
||||
* GUI for configuring Vortex ability type-specific settings.
|
||||
*/
|
||||
public class SubGuiAbilityVortex extends SubGuiAbilityConfig {
|
||||
|
||||
private final AbilityVortex vortex;
|
||||
|
||||
public SubGuiAbilityVortex(AbilityVortex ability, IAbilityConfigCallback callback) {
|
||||
super(ability, callback);
|
||||
this.vortex = ability;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void initTypeTab(int startY) {
|
||||
int y = startY;
|
||||
int labelX = guiLeft + 8;
|
||||
int fieldX = guiLeft + 85;
|
||||
int col2LabelX = guiLeft + 145;
|
||||
int col2FieldX = guiLeft + 205;
|
||||
|
||||
// Row 1: Pull Radius + Pull Strength
|
||||
addLabel(new GuiNpcLabel(100, "ability.pullRadius", labelX, y + 5));
|
||||
addTextField(createFloatField(100, fieldX, y, 50, vortex.getPullRadius()));
|
||||
|
||||
addLabel(new GuiNpcLabel(101, "ability.pullStrength", col2LabelX, y + 5));
|
||||
addTextField(createFloatField(101, col2FieldX, y, 50, vortex.getPullStrength()));
|
||||
|
||||
y += 24;
|
||||
|
||||
// Row 2: Damage + Knockback
|
||||
addLabel(new GuiNpcLabel(102, "ability.damage", labelX, y + 5));
|
||||
addTextField(createFloatField(102, fieldX, y, 50, vortex.getDamage()));
|
||||
|
||||
addLabel(new GuiNpcLabel(103, "ability.knockback", col2LabelX, y + 5));
|
||||
addTextField(createFloatField(103, col2FieldX, y, 50, vortex.getKnockback()));
|
||||
|
||||
y += 24;
|
||||
|
||||
// Row 3: AOE + Max Targets
|
||||
addLabel(new GuiNpcLabel(104, "ability.aoe", labelX, y + 5));
|
||||
addButton(new GuiNpcButton(104, fieldX, y, 50, 20, new String[]{"gui.no", "gui.yes"}, vortex.isAoe() ? 1 : 0));
|
||||
|
||||
addLabel(new GuiNpcLabel(105, "ability.maxTargets", col2LabelX, y + 5));
|
||||
addTextField(createIntField(105, col2FieldX, y, 50, vortex.getMaxTargets()));
|
||||
|
||||
y += 24;
|
||||
|
||||
// Row 4: Stun Duration + Root Duration
|
||||
addLabel(new GuiNpcLabel(106, "ability.stunDuration", labelX, y + 5));
|
||||
addTextField(createIntField(106, fieldX, y, 50, vortex.getStunDuration()));
|
||||
|
||||
addLabel(new GuiNpcLabel(107, "ability.rootDuration", col2LabelX, y + 5));
|
||||
addTextField(createIntField(107, col2FieldX, y, 50, vortex.getRootDuration()));
|
||||
|
||||
y += 24;
|
||||
|
||||
// Row 5: Damage on Pull + Pull Damage
|
||||
addLabel(new GuiNpcLabel(108, "ability.dmgOnPull", labelX, y + 5));
|
||||
addButton(new GuiNpcButton(108, fieldX, y, 50, 20, new String[]{"gui.no", "gui.yes"}, vortex.isDamageOnPull() ? 1 : 0));
|
||||
|
||||
addLabel(new GuiNpcLabel(109, "ability.pullDamage", col2LabelX, y + 5));
|
||||
addTextField(createFloatField(109, col2FieldX, y, 50, vortex.getPullDamage()));
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void handleTypeButton(int id, GuiNpcButton button) {
|
||||
int value = button.getValue();
|
||||
switch (id) {
|
||||
case 104: vortex.setAoe(value == 1); break;
|
||||
case 108: vortex.setDamageOnPull(value == 1); break;
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void handleTypeTextField(int id, GuiNpcTextField field) {
|
||||
switch (id) {
|
||||
case 100: vortex.setPullRadius(parseFloat(field, vortex.getPullRadius())); break;
|
||||
case 101: vortex.setPullStrength(parseFloat(field, vortex.getPullStrength())); break;
|
||||
case 102: vortex.setDamage(parseFloat(field, vortex.getDamage())); break;
|
||||
case 103: vortex.setKnockback(parseFloat(field, vortex.getKnockback())); break;
|
||||
case 105: vortex.setMaxTargets(field.getInteger()); break;
|
||||
case 106: vortex.setStunDuration(field.getInteger()); break;
|
||||
case 107: vortex.setRootDuration(field.getInteger()); break;
|
||||
case 109: vortex.setPullDamage(parseFloat(field, vortex.getPullDamage())); break;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,163 @@
|
||||
package noppes.npcs.client.gui.global;
|
||||
|
||||
import kamkeel.npcs.controllers.data.ability.Ability;
|
||||
import kamkeel.npcs.controllers.data.ability.AbilityController;
|
||||
import net.minecraft.client.gui.GuiButton;
|
||||
import noppes.npcs.client.gui.advanced.SubGuiAbilityConfig;
|
||||
import noppes.npcs.client.gui.advanced.SubGuiAbilityDeleteConfirm;
|
||||
import noppes.npcs.client.gui.advanced.SubGuiAbilityLoad;
|
||||
import noppes.npcs.client.gui.util.*;
|
||||
import noppes.npcs.entity.EntityNPCInterface;
|
||||
|
||||
import java.util.*;
|
||||
|
||||
/**
|
||||
* Global GUI for managing saved ability presets.
|
||||
* Allows viewing, editing, and deleting saved abilities.
|
||||
*/
|
||||
public class GuiNpcManageAbilities extends GuiNPCInterface2 implements ICustomScrollListener, ISubGuiListener, IAbilityConfigCallback {
|
||||
|
||||
private GuiCustomScroll scroll;
|
||||
private String selectedName = null;
|
||||
private List<String> abilityNames = new ArrayList<>();
|
||||
private String search = "";
|
||||
|
||||
public GuiNpcManageAbilities(EntityNPCInterface npc) {
|
||||
super(npc);
|
||||
loadAbilityNames();
|
||||
}
|
||||
|
||||
private void loadAbilityNames() {
|
||||
Set<String> names = AbilityController.Instance.getSavedAbilityNames();
|
||||
abilityNames = new ArrayList<>(names);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void initGui() {
|
||||
super.initGui();
|
||||
|
||||
int y = guiTop + 10;
|
||||
|
||||
// Title label
|
||||
addLabel(new GuiNpcLabel(0, "ability.manager.title", guiLeft + 10, y));
|
||||
y += 20;
|
||||
|
||||
// Scroll list of saved abilities
|
||||
if (scroll == null) {
|
||||
scroll = new GuiCustomScroll(this, 0);
|
||||
}
|
||||
scroll.setSize(xSize - 90, 160);
|
||||
scroll.guiLeft = guiLeft + 10;
|
||||
scroll.guiTop = y;
|
||||
scroll.setUnsortedList(getFilteredList());
|
||||
if (selectedName != null && abilityNames.contains(selectedName)) {
|
||||
scroll.setSelected(selectedName);
|
||||
}
|
||||
addScroll(scroll);
|
||||
|
||||
// Search bar
|
||||
addTextField(new GuiNpcTextField(1, this, fontRendererObj, guiLeft + 10, y + 163, xSize - 90, 18, search));
|
||||
|
||||
// Right side buttons
|
||||
int btnX = guiLeft + xSize - 70;
|
||||
addButton(new GuiNpcButton(1, btnX, y, 60, 20, "gui.edit"));
|
||||
addButton(new GuiNpcButton(2, btnX, y + 25, 60, 20, "gui.delete"));
|
||||
addButton(new GuiNpcButton(3, btnX, y + 60, 60, 20, "selectServer.refresh"));
|
||||
|
||||
// Enable/disable buttons based on selection
|
||||
getButton(1).setEnabled(selectedName != null && !selectedName.isEmpty());
|
||||
getButton(2).setEnabled(selectedName != null && !selectedName.isEmpty());
|
||||
}
|
||||
|
||||
private List<String> getFilteredList() {
|
||||
if (search.isEmpty()) {
|
||||
return new ArrayList<>(abilityNames);
|
||||
}
|
||||
List<String> filtered = new ArrayList<>();
|
||||
for (String name : abilityNames) {
|
||||
if (name.toLowerCase().contains(search.toLowerCase())) {
|
||||
filtered.add(name);
|
||||
}
|
||||
}
|
||||
return filtered;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void buttonEvent(GuiButton guibutton) {
|
||||
int id = guibutton.id;
|
||||
|
||||
if (id == 1 && selectedName != null) {
|
||||
// Edit
|
||||
Ability ability = AbilityController.Instance.getSavedAbility(selectedName);
|
||||
if (ability != null) {
|
||||
setSubGui(ability.createConfigGui(this));
|
||||
}
|
||||
} else if (id == 2 && selectedName != null) {
|
||||
// Delete
|
||||
setSubGui(new SubGuiAbilityDeleteConfirm(selectedName, null));
|
||||
} else if (id == 3) {
|
||||
// Refresh
|
||||
AbilityController.Instance.load();
|
||||
loadAbilityNames();
|
||||
selectedName = null;
|
||||
initGui();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void customScrollClicked(int i, int j, int k, GuiCustomScroll scroll) {
|
||||
if (scroll.id == 0) {
|
||||
selectedName = scroll.getSelected();
|
||||
initGui();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void customScrollDoubleClicked(String selection, GuiCustomScroll scroll) {
|
||||
if (scroll.id == 0 && selection != null && !selection.isEmpty()) {
|
||||
// Double-click to edit
|
||||
Ability ability = AbilityController.Instance.getSavedAbility(selection);
|
||||
if (ability != null) {
|
||||
setSubGui(ability.createConfigGui(this));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void keyTyped(char c, int i) {
|
||||
super.keyTyped(c, i);
|
||||
if (getTextField(1) != null && getTextField(1).isFocused()) {
|
||||
if (!search.equals(getTextField(1).getText())) {
|
||||
search = getTextField(1).getText();
|
||||
scroll.setUnsortedList(getFilteredList());
|
||||
scroll.resetScroll();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void subGuiClosed(SubGuiInterface subgui) {
|
||||
// Refresh list after any sub gui closes
|
||||
loadAbilityNames();
|
||||
if (subgui instanceof SubGuiAbilityDeleteConfirm) {
|
||||
// After delete, clear selection if it was deleted
|
||||
if (selectedName != null && !abilityNames.contains(selectedName)) {
|
||||
selectedName = null;
|
||||
}
|
||||
}
|
||||
initGui();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onAbilitySaved(Ability ability) {
|
||||
// Save the edited ability
|
||||
AbilityController.Instance.saveAbility(ability);
|
||||
loadAbilityNames();
|
||||
initGui();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void save() {
|
||||
// Nothing to save - abilities are saved individually
|
||||
}
|
||||
}
|
||||
@@ -38,6 +38,7 @@ public class GuiNPCGlobalMainMenu extends GuiNPCInterface2 {
|
||||
private GuiNpcSquareButton tagButton;
|
||||
private GuiNpcSquareButton effectsButton;
|
||||
private GuiNpcSquareButton magicsButton;
|
||||
private GuiNpcSquareButton abilitiesButton;
|
||||
|
||||
public GuiNPCGlobalMainMenu(EntityNPCInterface npc) {
|
||||
super(npc, 5);
|
||||
@@ -94,6 +95,8 @@ public class GuiNPCGlobalMainMenu extends GuiNPCInterface2 {
|
||||
registerButton(magicsButton = new GuiNpcSquareButton(20, 0, 0, 20, "global.magic", 0xFF333333));
|
||||
magicsButton.setIconPos(24, 24, 48, 56).setIconTexture(specialIcons);
|
||||
|
||||
registerButton(abilitiesButton = new GuiNpcSquareButton(21, 0, 0, 20, "global.abilities", 0xFF333333));
|
||||
abilitiesButton.setIconPos(24, 24, 72, 56).setIconTexture(specialIcons); // Placeholder icon position
|
||||
|
||||
// Layout composite buttons optimally.
|
||||
layoutButtons();
|
||||
@@ -236,6 +239,9 @@ public class GuiNPCGlobalMainMenu extends GuiNPCInterface2 {
|
||||
if (id == 19) {
|
||||
NoppesUtil.requestOpenGUI(EnumGuiType.ManageEffects);
|
||||
}
|
||||
if (id == 21) {
|
||||
NoppesUtil.openGUI(player, new noppes.npcs.client.gui.global.GuiNpcManageAbilities(npc));
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
|
||||
@@ -13,6 +13,7 @@ import noppes.npcs.client.gui.advanced.GuiNPCAdvancedLinkedNpc;
|
||||
import noppes.npcs.client.gui.advanced.GuiNPCDialogNpcOptions;
|
||||
import noppes.npcs.client.gui.advanced.GuiNPCFactionSetup;
|
||||
import noppes.npcs.client.gui.advanced.GuiNPCLinesMenu;
|
||||
import noppes.npcs.client.gui.advanced.GuiNPCAbilities;
|
||||
import noppes.npcs.client.gui.advanced.GuiNPCMagic;
|
||||
import noppes.npcs.client.gui.advanced.GuiNPCMarks;
|
||||
import noppes.npcs.client.gui.advanced.GuiNPCNightSetup;
|
||||
@@ -69,6 +70,7 @@ public class GuiNpcAdvanced extends GuiNPCInterface2 implements IGuiData {
|
||||
this.addButton(new GuiNpcButton(15, guiLeft + 208, y, 190, 20, "advanced.marks"));
|
||||
|
||||
this.addButton(new GuiNpcButton(16, guiLeft + 15, y += 22, 190, 20, "menu.magics"));
|
||||
this.addButton(new GuiNpcButton(17, guiLeft + 208, y, 190, 20, "menu.abilities"));
|
||||
}
|
||||
|
||||
@Override
|
||||
@@ -130,6 +132,10 @@ public class GuiNpcAdvanced extends GuiNPCInterface2 implements IGuiData {
|
||||
save();
|
||||
NoppesUtil.openGUI(player, new GuiNPCMagic(npc));
|
||||
}
|
||||
if (button.id == 17) {
|
||||
save();
|
||||
NoppesUtil.openGUI(player, new GuiNPCAbilities(npc));
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
|
||||
@@ -17,7 +17,6 @@ public class GuiNPCEventScripts extends GuiScriptInterface {
|
||||
|
||||
public GuiNPCEventScripts(EntityNPCInterface npc) {
|
||||
this.hookList = new ArrayList<>(ScriptHookController.Instance.getAllHooks(IScriptHookHandler.CONTEXT_NPC));
|
||||
|
||||
this.script = new DataScript(npc);
|
||||
this.handler = this.script;
|
||||
EventScriptPacket.Get();
|
||||
|
||||
@@ -15,8 +15,7 @@ public class GuiScriptAllNPCs extends GuiScriptInterface {
|
||||
private final GlobalNPCDataScript script = new GlobalNPCDataScript(null);
|
||||
|
||||
public GuiScriptAllNPCs() {
|
||||
this.hookList = new ArrayList<>(ScriptHookController.Instance.getAllHooks(IScriptHookHandler.CONTEXT_GLOBAL_NPC));
|
||||
|
||||
this.hookList = new ArrayList<>(ScriptHookController.Instance.getAllHooks(IScriptHookHandler.CONTEXT_NPC));
|
||||
this.handler = this.script;
|
||||
GlobalNPCScriptPacket.Get();
|
||||
}
|
||||
|
||||
@@ -0,0 +1,175 @@
|
||||
package noppes.npcs.client.gui.select;
|
||||
|
||||
import kamkeel.npcs.network.PacketClient;
|
||||
import kamkeel.npcs.network.packets.request.animation.AnimationsGetPacket;
|
||||
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.GuiNpcLabel;
|
||||
import noppes.npcs.client.gui.util.GuiNpcTextField;
|
||||
import noppes.npcs.client.gui.util.ICustomScrollListener;
|
||||
import noppes.npcs.client.gui.util.IScrollData;
|
||||
import noppes.npcs.client.gui.util.SubGuiInterface;
|
||||
import noppes.npcs.constants.EnumScrollData;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Vector;
|
||||
|
||||
/**
|
||||
* Animation selection dialog for choosing global animations.
|
||||
* Requests animation data from the server via packets.
|
||||
*/
|
||||
public class GuiAnimationSelection extends SubGuiInterface implements ICustomScrollListener, IScrollData {
|
||||
|
||||
private GuiCustomScroll scrollAnimations;
|
||||
private HashMap<String, Integer> animationData = new HashMap<String, Integer>();
|
||||
|
||||
private int initialAnimationId;
|
||||
public int selectedAnimationId = -1;
|
||||
private String selectedName = null;
|
||||
|
||||
private String search = "";
|
||||
|
||||
public GuiAnimationSelection(int animationId) {
|
||||
drawDefaultBackground = false;
|
||||
title = "";
|
||||
setBackground("menubg.png");
|
||||
xSize = 220;
|
||||
ySize = 226;
|
||||
|
||||
this.initialAnimationId = animationId;
|
||||
this.selectedAnimationId = animationId;
|
||||
|
||||
// Request animation data from server
|
||||
PacketClient.sendClient(new AnimationsGetPacket());
|
||||
}
|
||||
|
||||
@Override
|
||||
public void initGui() {
|
||||
super.initGui();
|
||||
|
||||
this.addLabel(new GuiNpcLabel(0, "gui.animations", guiLeft + 8, guiTop + 4));
|
||||
|
||||
this.addButton(new GuiNpcButton(1, guiLeft + 4, guiTop + ySize - 35, 50, 20, "gui.clear"));
|
||||
this.addButton(new GuiNpcButton(2, guiLeft + xSize - 56, guiTop + ySize - 35, 50, 20, "gui.done"));
|
||||
this.addButton(new GuiNpcButton(3, guiLeft + xSize - 108, guiTop + ySize - 35, 50, 20, "gui.cancel"));
|
||||
|
||||
if (scrollAnimations == null) {
|
||||
scrollAnimations = new GuiCustomScroll(this, 0, 0);
|
||||
scrollAnimations.setSize(212, 163);
|
||||
}
|
||||
scrollAnimations.setList(getSearchList());
|
||||
if (selectedName != null) {
|
||||
scrollAnimations.setSelected(selectedName);
|
||||
}
|
||||
scrollAnimations.guiLeft = guiLeft + 4;
|
||||
scrollAnimations.guiTop = guiTop + 14;
|
||||
this.addScroll(scrollAnimations);
|
||||
|
||||
addTextField(new GuiNpcTextField(55, this, fontRendererObj, guiLeft + 4, guiTop + 179, 212, 20, search));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setData(Vector<String> list, HashMap<String, Integer> data, EnumScrollData type) {
|
||||
this.animationData = data;
|
||||
|
||||
// Find the name for our initial animation ID
|
||||
if (initialAnimationId >= 0) {
|
||||
for (String name : data.keySet()) {
|
||||
if (data.get(name) == initialAnimationId) {
|
||||
selectedName = name;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (scrollAnimations != null) {
|
||||
scrollAnimations.setList(getSearchList());
|
||||
if (selectedName != null) {
|
||||
scrollAnimations.setSelected(selectedName);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setSelected(String selected) {
|
||||
this.selectedName = selected;
|
||||
if (scrollAnimations != null) {
|
||||
scrollAnimations.setSelected(selected);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void keyTyped(char c, int i) {
|
||||
super.keyTyped(c, i);
|
||||
if (getTextField(55) != null) {
|
||||
if (getTextField(55).isFocused()) {
|
||||
if (search.equals(getTextField(55).getText()))
|
||||
return;
|
||||
search = getTextField(55).getText().toLowerCase();
|
||||
scrollAnimations.resetScroll();
|
||||
scrollAnimations.setList(getSearchList());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private List<String> getSearchList() {
|
||||
if (search.isEmpty()) {
|
||||
return new ArrayList<String>(animationData.keySet());
|
||||
}
|
||||
List<String> list = new ArrayList<String>();
|
||||
for (String name : animationData.keySet()) {
|
||||
if (name.toLowerCase().contains(search))
|
||||
list.add(name);
|
||||
}
|
||||
return list;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void customScrollClicked(int i, int j, int k, GuiCustomScroll guiCustomScroll) {
|
||||
if (guiCustomScroll.id == 0) {
|
||||
String selected = scrollAnimations.getSelected();
|
||||
if (selected != null && animationData.containsKey(selected)) {
|
||||
selectedName = selected;
|
||||
selectedAnimationId = animationData.get(selected);
|
||||
}
|
||||
}
|
||||
initGui();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void customScrollDoubleClicked(String selection, GuiCustomScroll scroll) {
|
||||
if (selectedAnimationId < 0)
|
||||
return;
|
||||
close();
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void actionPerformed(GuiButton guibutton) {
|
||||
int id = guibutton.id;
|
||||
if (id == 1) {
|
||||
// Clear selection
|
||||
selectedName = null;
|
||||
selectedAnimationId = -1;
|
||||
close();
|
||||
}
|
||||
if (id == 2) {
|
||||
// Done - keep selection
|
||||
close();
|
||||
}
|
||||
if (id == 3) {
|
||||
// Cancel - restore initial value
|
||||
selectedAnimationId = initialAnimationId;
|
||||
close();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the name of the selected animation (for display purposes).
|
||||
*/
|
||||
public String getSelectedName() {
|
||||
return selectedName;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,15 @@
|
||||
package noppes.npcs.client.gui.util;
|
||||
|
||||
import kamkeel.npcs.controllers.data.ability.Ability;
|
||||
|
||||
/**
|
||||
* Callback interface for SubGuiAbilityConfig.
|
||||
* Implemented by GUIs that open the ability config dialog.
|
||||
*/
|
||||
public interface IAbilityConfigCallback {
|
||||
/**
|
||||
* Called when an ability has been edited and saved.
|
||||
* @param ability The edited ability
|
||||
*/
|
||||
void onAbilitySaved(Ability ability);
|
||||
}
|
||||
@@ -63,5 +63,6 @@ public enum EnumGuiType {
|
||||
ScriptItem,
|
||||
ScriptBlock,
|
||||
Paintbrush,
|
||||
MagicBook;
|
||||
MagicBook,
|
||||
ManageAbilities;
|
||||
}
|
||||
@@ -114,7 +114,14 @@ public enum EnumScriptType {
|
||||
PROFILE("profile"),
|
||||
PROFILE_CHANGE("profileChange"),
|
||||
PROFILE_REMOVE("profileRemove"),
|
||||
PROFILE_CREATE("profileCreate");
|
||||
PROFILE_CREATE("profileCreate"),
|
||||
|
||||
ABILITY_START("abilityStart"),
|
||||
ABILITY_EXECUTE("abilityExecute"),
|
||||
ABILITY_INTERRUPT("abilityInterrupt"),
|
||||
ABILITY_COMPLETE("abilityComplete"),
|
||||
ABILITY_HIT("abilityHit"),
|
||||
ABILITY_TICK("abilityTick");
|
||||
|
||||
public String function;
|
||||
|
||||
|
||||
@@ -5,5 +5,6 @@ public enum EnumScrollData {
|
||||
MAGIC,
|
||||
MAGIC_CYCLES,
|
||||
DIALOG_GROUP,
|
||||
QUEST_GROUP
|
||||
QUEST_GROUP,
|
||||
ABILITY_TYPES
|
||||
}
|
||||
@@ -73,6 +73,7 @@ import net.minecraftforge.common.util.FakePlayer;
|
||||
import net.minecraftforge.event.ServerChatEvent;
|
||||
import noppes.npcs.CustomItems;
|
||||
import noppes.npcs.CustomNpcs;
|
||||
import noppes.npcs.DataAbilities;
|
||||
import noppes.npcs.DataAI;
|
||||
import noppes.npcs.DataAdvanced;
|
||||
import noppes.npcs.DataDisplay;
|
||||
@@ -183,6 +184,7 @@ public abstract class EntityNPCInterface extends EntityCreature implements IEnti
|
||||
public DataScript script;
|
||||
public DataTransform transform;
|
||||
public DataTimers timers;
|
||||
public DataAbilities abilities;
|
||||
|
||||
public CombatHandler combatHandler = new CombatHandler(this);
|
||||
public ActionManager actionManager = new ActionManager();
|
||||
@@ -271,6 +273,7 @@ public abstract class EntityNPCInterface extends EntityCreature implements IEnti
|
||||
transform = new DataTransform(this);
|
||||
script = new DataScript(this);
|
||||
timers = new DataTimers(this);
|
||||
abilities = new DataAbilities(this);
|
||||
this.getAttributeMap().registerAttribute(SharedMonsterAttributes.attackDamage);
|
||||
|
||||
this.getEntityAttribute(SharedMonsterAttributes.maxHealth).setBaseValue(stats.maxHealth);
|
||||
@@ -460,6 +463,7 @@ public abstract class EntityNPCInterface extends EntityCreature implements IEnti
|
||||
onCollide();
|
||||
|
||||
actionManager.tick();
|
||||
abilities.tick();
|
||||
}
|
||||
|
||||
if (wasKilled != isKilled() && wasKilled) {
|
||||
@@ -1179,6 +1183,7 @@ public abstract class EntityNPCInterface extends EntityCreature implements IEnti
|
||||
script.readEventsFromNBT(compound);
|
||||
timers.readFromNBT(compound);
|
||||
advanced.readToNBT(compound);
|
||||
abilities.readFromNBT(compound);
|
||||
if (advanced.role != EnumRoleType.None && roleInterface != null)
|
||||
roleInterface.readFromNBT(compound);
|
||||
if (advanced.job != EnumJobType.None && jobInterface != null)
|
||||
@@ -1211,6 +1216,7 @@ public abstract class EntityNPCInterface extends EntityCreature implements IEnti
|
||||
script.writeEventsToNBT(compound);
|
||||
timers.writeToNBT(compound);
|
||||
advanced.writeToNBT(compound);
|
||||
abilities.writeToNBT(compound);
|
||||
if (advanced.role != EnumRoleType.None && roleInterface != null)
|
||||
roleInterface.writeToNBT(compound);
|
||||
if (advanced.job != EnumJobType.None && jobInterface != null)
|
||||
|
||||
@@ -60,6 +60,7 @@ import noppes.npcs.api.entity.IEntity;
|
||||
import noppes.npcs.api.entity.IPlayer;
|
||||
import noppes.npcs.api.gui.ICustomGui;
|
||||
import noppes.npcs.api.handler.IActionManager;
|
||||
import noppes.npcs.api.handler.IAbilityHandler;
|
||||
import noppes.npcs.api.handler.IAnimationHandler;
|
||||
import noppes.npcs.api.handler.IAttributeHandler;
|
||||
import noppes.npcs.api.handler.ICloneHandler;
|
||||
@@ -84,6 +85,7 @@ import noppes.npcs.compat.PixelmonHelper;
|
||||
import noppes.npcs.config.ConfigScript;
|
||||
import noppes.npcs.constants.EnumAnimationPart;
|
||||
import noppes.npcs.containers.ContainerNpcInterface;
|
||||
import kamkeel.npcs.controllers.data.ability.AbilityController;
|
||||
import noppes.npcs.controllers.AnimationController;
|
||||
import noppes.npcs.controllers.ChunkController;
|
||||
import noppes.npcs.controllers.CustomEffectController;
|
||||
@@ -362,6 +364,12 @@ public class NpcAPI extends AbstractNpcAPI {
|
||||
return ScriptHookController.Instance;
|
||||
}
|
||||
|
||||
@Override
|
||||
public IAbilityHandler getAbilities() {
|
||||
this.checkWorld();
|
||||
return AbilityController.Instance;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String[] getAllBiomeNames() {
|
||||
List<String> biomes = new ArrayList<>();
|
||||
|
||||
@@ -0,0 +1,206 @@
|
||||
package noppes.npcs.scripted.event;
|
||||
|
||||
import cpw.mods.fml.common.eventhandler.Cancelable;
|
||||
import kamkeel.npcs.controllers.data.ability.Ability;
|
||||
import net.minecraft.entity.EntityLivingBase;
|
||||
import net.minecraft.util.DamageSource;
|
||||
import noppes.npcs.api.IDamageSource;
|
||||
import noppes.npcs.api.ability.IAbility;
|
||||
import noppes.npcs.api.entity.ICustomNpc;
|
||||
import noppes.npcs.api.entity.IEntityLivingBase;
|
||||
import noppes.npcs.api.event.IAbilityEvent;
|
||||
import noppes.npcs.constants.EnumScriptType;
|
||||
import noppes.npcs.scripted.NpcAPI;
|
||||
|
||||
/**
|
||||
* Events fired during NPC ability execution lifecycle.
|
||||
*/
|
||||
public class AbilityEvent extends NpcEvent implements IAbilityEvent {
|
||||
protected final Ability ability;
|
||||
protected final IEntityLivingBase target;
|
||||
|
||||
public AbilityEvent(ICustomNpc npc, Ability ability, EntityLivingBase target) {
|
||||
super(npc);
|
||||
this.ability = ability;
|
||||
this.target = target != null ? (IEntityLivingBase) NpcAPI.Instance().getIEntity(target) : null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public IAbility getAbility() {
|
||||
return ability;
|
||||
}
|
||||
|
||||
@Override
|
||||
public IEntityLivingBase getTarget() {
|
||||
return target;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getHookName() {
|
||||
return "abilityEvent";
|
||||
}
|
||||
|
||||
/**
|
||||
* Fired when an ability starts executing (enters WINDUP phase).
|
||||
*/
|
||||
@Cancelable
|
||||
public static class StartEvent extends AbilityEvent implements IAbilityEvent.StartEvent {
|
||||
public StartEvent(ICustomNpc npc, Ability ability, EntityLivingBase target) {
|
||||
super(npc, ability, target);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getHookName() {
|
||||
return EnumScriptType.ABILITY_START.function;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Fired when an ability enters the ACTIVE phase and performs its effect.
|
||||
*/
|
||||
@Cancelable
|
||||
public static class ExecuteEvent extends AbilityEvent implements IAbilityEvent.ExecuteEvent {
|
||||
public ExecuteEvent(ICustomNpc npc, Ability ability, EntityLivingBase target) {
|
||||
super(npc, ability, target);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getHookName() {
|
||||
return EnumScriptType.ABILITY_EXECUTE.function;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Fired when an ability is interrupted by damage.
|
||||
*/
|
||||
public static class InterruptEvent extends AbilityEvent implements IAbilityEvent.InterruptEvent {
|
||||
private final IDamageSource damageSource;
|
||||
private final float damage;
|
||||
|
||||
public InterruptEvent(ICustomNpc npc, Ability ability, EntityLivingBase target, DamageSource source, float damage) {
|
||||
super(npc, ability, target);
|
||||
this.damageSource = NpcAPI.Instance().getIDamageSource(source);
|
||||
this.damage = damage;
|
||||
}
|
||||
|
||||
@Override
|
||||
public IDamageSource getDamageSource() {
|
||||
return damageSource;
|
||||
}
|
||||
|
||||
@Override
|
||||
public float getDamage() {
|
||||
return damage;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getHookName() {
|
||||
return EnumScriptType.ABILITY_INTERRUPT.function;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Fired when an ability completes its full execution cycle.
|
||||
*/
|
||||
public static class CompleteEvent extends AbilityEvent implements IAbilityEvent.CompleteEvent {
|
||||
public CompleteEvent(ICustomNpc npc, Ability ability, EntityLivingBase target) {
|
||||
super(npc, ability, target);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getHookName() {
|
||||
return EnumScriptType.ABILITY_COMPLETE.function;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Fired when an ability hits an entity with damage.
|
||||
* This is a cancelable event - canceling prevents the damage from being applied.
|
||||
*/
|
||||
@Cancelable
|
||||
public static class HitEvent extends AbilityEvent implements IAbilityEvent.HitEvent {
|
||||
private final IEntityLivingBase hitEntity;
|
||||
private float damage;
|
||||
private float knockback;
|
||||
private float knockbackUp;
|
||||
|
||||
public HitEvent(ICustomNpc npc, Ability ability, EntityLivingBase target,
|
||||
EntityLivingBase hitEntity, float damage, float knockback, float knockbackUp) {
|
||||
super(npc, ability, target);
|
||||
this.hitEntity = hitEntity != null ? (IEntityLivingBase) NpcAPI.Instance().getIEntity(hitEntity) : null;
|
||||
this.damage = damage;
|
||||
this.knockback = knockback;
|
||||
this.knockbackUp = knockbackUp;
|
||||
}
|
||||
|
||||
@Override
|
||||
public IEntityLivingBase getHitEntity() {
|
||||
return hitEntity;
|
||||
}
|
||||
|
||||
@Override
|
||||
public float getDamage() {
|
||||
return damage;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setDamage(float damage) {
|
||||
this.damage = damage;
|
||||
}
|
||||
|
||||
@Override
|
||||
public float getKnockback() {
|
||||
return knockback;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setKnockback(float knockback) {
|
||||
this.knockback = knockback;
|
||||
}
|
||||
|
||||
@Override
|
||||
public float getKnockbackUp() {
|
||||
return knockbackUp;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setKnockbackUp(float knockbackUp) {
|
||||
this.knockbackUp = knockbackUp;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getHookName() {
|
||||
return EnumScriptType.ABILITY_HIT.function;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Fired every tick while an ability is executing.
|
||||
* Provides information about the current phase and tick.
|
||||
*/
|
||||
public static class TickEvent extends AbilityEvent implements IAbilityEvent.TickEvent {
|
||||
private final int abilityPhase;
|
||||
private final int tick;
|
||||
|
||||
public TickEvent(ICustomNpc npc, Ability ability, EntityLivingBase target, int phase, int tick) {
|
||||
super(npc, ability, target);
|
||||
this.abilityPhase = phase;
|
||||
this.tick = tick;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getAbilityPhase() {
|
||||
return abilityPhase;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getTick() {
|
||||
return tick;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getHookName() {
|
||||
return EnumScriptType.ABILITY_TICK.function;
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user