From 1638f3e322ec05b26929de3d84c7c5114b5ca8b4 Mon Sep 17 00:00:00 2001 From: Talamar1 Date: Tue, 16 Jun 2015 00:24:50 -0400 Subject: [PATCH] Rewrote "on entity targets" event in new ScriptEvent format. Removed from BukkitWorldScriptHelper. --- .../java/net/aufdemrand/denizen/Denizen.java | 1 + .../EntityTargetsScriptEvent.java | 173 ++++++++++++++++++ .../core/BukkitWorldScriptHelper.java | 122 ------------ 3 files changed, 174 insertions(+), 122 deletions(-) create mode 100644 src/main/java/net/aufdemrand/denizen/events/scriptevents/EntityTargetsScriptEvent.java diff --git a/src/main/java/net/aufdemrand/denizen/Denizen.java b/src/main/java/net/aufdemrand/denizen/Denizen.java index 373eac7dfa..cdc2717308 100644 --- a/src/main/java/net/aufdemrand/denizen/Denizen.java +++ b/src/main/java/net/aufdemrand/denizen/Denizen.java @@ -603,6 +603,7 @@ public void onEnable() { ScriptEvent.registerScriptEvent(new EntityInteractScriptEvent()); ScriptEvent.registerScriptEvent(new EntityKilledScriptEvent()); ScriptEvent.registerScriptEvent(new EntitySpawnScriptEvent()); + ScriptEvent.registerScriptEvent(new EntityTargetsScriptEvent()); ScriptEvent.registerScriptEvent(new EntityTeleportScriptEvent()); ScriptEvent.registerScriptEvent(new FurnaceBurnsItemScriptEvent()); ScriptEvent.registerScriptEvent(new FurnaceSmeltsItemScriptEvent()); diff --git a/src/main/java/net/aufdemrand/denizen/events/scriptevents/EntityTargetsScriptEvent.java b/src/main/java/net/aufdemrand/denizen/events/scriptevents/EntityTargetsScriptEvent.java new file mode 100644 index 0000000000..083a6e3f86 --- /dev/null +++ b/src/main/java/net/aufdemrand/denizen/events/scriptevents/EntityTargetsScriptEvent.java @@ -0,0 +1,173 @@ +package net.aufdemrand.denizen.events.scriptevents; + +import net.aufdemrand.denizen.BukkitScriptEntryData; +import net.aufdemrand.denizen.objects.*; +import net.aufdemrand.denizen.utilities.DenizenAPI; +import net.aufdemrand.denizen.utilities.debugging.dB; +import net.aufdemrand.denizencore.events.ScriptEvent; +import net.aufdemrand.denizencore.objects.Element; +import net.aufdemrand.denizencore.objects.dList; +import net.aufdemrand.denizencore.objects.dObject; +import net.aufdemrand.denizencore.scripts.ScriptEntryData; +import net.aufdemrand.denizencore.scripts.containers.ScriptContainer; +import net.aufdemrand.denizencore.utilities.CoreUtilities; + +import org.bukkit.Bukkit; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.entity.EntityTargetEvent; + +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; + +public class EntityTargetsScriptEvent extends ScriptEvent implements Listener { + + // <--[event] + // @Events + // entity targets () (in ) + // entity targets () because (in ) + // targets () (in ) + // targets () because (in ) + // + // @Cancellable true + // + // @Triggers when an entity interacts with a block (EG an arrow hits a button) + // + // @Triggers when an entity targets a new entity. + // + // @Context + // returns the targeting entity. + // returns the reason the entity changed targets. + // returns the targeted entity. + // returns dList of cuboids event happened in. + // + // @Determine + // dEntity to make the entity target a different entity instead. + // + // --> + + public EntityTargetsScriptEvent() { + instance = this; + } + public static EntityTargetsScriptEvent instance; + public dEntity entity; + public Element reason; + public dEntity target; + public dList cuboids; + private dLocation location; + public EntityTargetEvent event; + + @Override + public boolean couldMatch(ScriptContainer scriptContainer, String s) { + String lower = CoreUtilities.toLowerCase(s); + String attacker = CoreUtilities.getXthArg(0, lower); + String cmd = CoreUtilities.getXthArg(1, lower); + List types = Arrays.asList("entity", "player", "npc"); + return cmd.equals("targets") + && (types.contains(attacker) || dEntity.matches(attacker)); + } + + @Override + public boolean matches(ScriptContainer scriptContainer, String s) { + String lower = CoreUtilities.toLowerCase(s); + + if (!entity.matchesEntity(CoreUtilities.getXthArg(0, lower))) { + return false; + } + String victim = CoreUtilities.getXthArg(2, lower); + if (!victim.equals("in") && !victim.equals("because") && target != null && victim.length() > 0) { + if (!target.matchesEntity(victim)) { + return false; + } + } + Integer pos = lower.indexOf(" in ") + 4; + if (pos > 4) { + Integer end = lower.indexOf(" ", pos) < 0 ? lower.length(): lower.indexOf(" ", pos); + String it = lower.substring(pos, end); + if (dCuboid.matches(it)) { + dCuboid cuboid = dCuboid.valueOf(it); + if (!cuboid.isInsideCuboid(location)) { + return false; + } + } + else if (dEllipsoid.matches(it)) { + dEllipsoid ellipsoid = dEllipsoid.valueOf(it); + if (!ellipsoid.contains(location)) { + return false; + } + } + else { + dB.echoError("Invalid event 'IN ...' check [" + getName() + "]: '" + s + "' for " + scriptContainer.getName()); + return false; + } + } + pos = lower.indexOf(" because ") + 9; + if (pos > 9) { + Integer end = lower.indexOf(" ", pos) < 0 ? lower.length(): lower.indexOf(" ", pos); + String it = lower.substring(pos, end); + if (!it.equals(reason.toString().toLowerCase())) { + return false; + } + } + return true; + } + + @Override + public String getName() { + return "EntityTargets"; + } + + @Override + public void init() { + Bukkit.getServer().getPluginManager().registerEvents(this, DenizenAPI.getCurrentInstance()); + } + + @Override + public void destroy() { + EntityTargetEvent.getHandlerList().unregister(this); + } + + @Override + public boolean applyDetermination(ScriptContainer container, String determination) { + if (dEntity.matches(determination)) { + target = dEntity.valueOf(determination); + } + return super.applyDetermination(container, determination); + } + + @Override + public ScriptEntryData getScriptEntryData() { + return new BukkitScriptEntryData(entity.isPlayer() ? dEntity.getPlayerFrom(event.getEntity()): null, + entity.isCitizensNPC() ? dEntity.getNPCFrom(event.getEntity()): null); + } + + @Override + public HashMap getContext() { + HashMap context = super.getContext(); + context.put("entity", entity); + context.put("reason", reason); + if (target != null) { + context.put("target", target); + } + context.put("cuboids", cuboids); + return context; + } + + @EventHandler + public void onEntityTargets(EntityTargetEvent event) { + entity = new dEntity(event.getEntity()); + reason = new Element(event.getReason().toString()); + target = event.getTarget() != null ? new dEntity(event.getTarget()): null; + location = new dLocation(event.getEntity().getLocation()); + cuboids = new dList(); + for (dCuboid cuboid: dCuboid.getNotableCuboidsContaining(location)) { + cuboids.add(cuboid.identifySimple()); + } + cancelled = event.isCancelled(); + this.event = event; + fire(); + event.setCancelled(cancelled); + } + +} diff --git a/src/main/java/net/aufdemrand/denizen/scripts/containers/core/BukkitWorldScriptHelper.java b/src/main/java/net/aufdemrand/denizen/scripts/containers/core/BukkitWorldScriptHelper.java index f9e7c5a7ff..d3e6e52cc3 100644 --- a/src/main/java/net/aufdemrand/denizen/scripts/containers/core/BukkitWorldScriptHelper.java +++ b/src/main/java/net/aufdemrand/denizen/scripts/containers/core/BukkitWorldScriptHelper.java @@ -140,48 +140,6 @@ public void timeEvent() { // ENTITY EVENTS ///////////////// - // <--[event] - // @Events - // entity combusts - // combusts - // - // @Triggers when an entity catches fire. - // @Context - // returns the entity that caught fire. - // returns the length of the burn. - // - // @Determine - // "CANCELLED" to stop the creeper from being powered. - // - // --> - // TODO: Smarten event - @EventHandler - public void onCombust(EntityCombustEvent event) { - Map context = new HashMap(); - dEntity entity = new dEntity(event.getEntity()); - Duration dura = new Duration((long)event.getDuration()); - - context.put("entity", entity); - context.put("duration", dura); - - dPlayer player = null; - dNPC npc = null; - - if (entity.isCitizensNPC()) npc = entity.getDenizenNPC(); - else if (entity.isPlayer()) player = entity.getDenizenPlayer(); - - String determination = doEvents(Arrays.asList - ("entity combusts", - entity.identifySimple() + " combusts", - entity.identifyType() + " combusts"), - npc, player, context); - - if (determination.toUpperCase().startsWith("CANCELLED")) - event.setCancelled(true); - else if (Duration.matches(determination)) - event.setDuration(Duration.valueOf(determination).getTicksAsInt()); - } - // <--[event] // @Events // entity explodes @@ -528,86 +486,6 @@ public void entityTame(EntityTameEvent event) { event.setCancelled(true); } - // <--[event] - // @Events - // entity targets () - // entity targets () because - // targets () - // targets () because - // - // @Triggers when an entity targets a new entity. - // @Context - // returns the targeting entity. - // returns the reason the entity changed targets. - // returns the targeted entity. - // - // @Determine - // "CANCELLED" to stop the entity from being targeted. - // dEntity to make the entity target a different entity instead. - // - // --> - @EventHandler - public void entityTarget(EntityTargetEvent event) { - - dPlayer player = null; - dNPC npc = null; - - Map context = new HashMap(); - final dEntity entity = new dEntity(event.getEntity()); - - String reason = event.getReason().name(); - - context.put("entity", entity); - context.put("reason", new Element(reason)); - - List events = new ArrayList(); - events.add("entity targets"); - events.add("entity targets because " + reason); - events.add(entity.identifyType() + " targets"); - events.add(entity.identifyType() + " targets because " + reason); - - if (event.getTarget() != null) { - - dEntity target = new dEntity(event.getTarget()); - context.put("target", target.getDenizenObject()); - - if (target.isCitizensNPC()) { npc = target.getDenizenNPC(); } - else if (target.isPlayer()) player = target.getDenizenPlayer(); - - events.add("entity targets entity"); - events.add("entity targets entity because " + reason); - events.add("entity targets " + target.identifyType()); - events.add("entity targets " + target.identifyType() + " because " + reason); - events.add(entity.identifyType() + " targets entity"); - events.add(entity.identifyType() + " targets entity because " + reason); - events.add(entity.identifyType() + " targets " + target.identifyType()); - events.add(entity.identifyType() + " targets " + target.identifyType() + " because " + reason); - } - - String determination = doEvents(events, npc, player, context, true); - - if (determination.toUpperCase().startsWith("CANCELLED")) - event.setCancelled(true); - - // If the determination matches a dEntity, change the event's target - // using a scheduled task (otherwise, the target will not be changed) - // - // Note: this does not work with all monster types - else if (dEntity.matches(determination)) { - - final dEntity newTarget = dEntity.valueOf(determination); - - Bukkit.getScheduler().scheduleSyncDelayedTask(DenizenAPI.getCurrentInstance(), new Runnable() { - @Override - public void run() { - if (newTarget.isValid() && newTarget.isLivingEntity()) { - entity.target(newTarget.getLivingEntity()); - } - } - }, 1); - } - } - // <--[event] // @Events // entity unleashed (because )