From b52c66150486f06ab3d90911b8c5bcc877c9fa66 Mon Sep 17 00:00:00 2001 From: Xenmai Date: Fri, 27 Oct 2017 14:22:05 +0200 Subject: [PATCH] Projectile Impacts Entity Also improved projectile impacts block. --- .../denizen2sponge/Denizen2Sponge.java | 3 +- ...=> ProjectileImpactsBlockScriptEvent.java} | 39 +++--- .../ProjectileImpactsEntityScriptEvent.java | 113 ++++++++++++++++++ 3 files changed, 139 insertions(+), 16 deletions(-) rename src/main/java/com/denizenscript/denizen2sponge/events/entity/{ProjectileHitsBlockScriptEvent.java => ProjectileImpactsBlockScriptEvent.java} (67%) create mode 100644 src/main/java/com/denizenscript/denizen2sponge/events/entity/ProjectileImpactsEntityScriptEvent.java diff --git a/src/main/java/com/denizenscript/denizen2sponge/Denizen2Sponge.java b/src/main/java/com/denizenscript/denizen2sponge/Denizen2Sponge.java index 3ec7a44..a8a6068 100644 --- a/src/main/java/com/denizenscript/denizen2sponge/Denizen2Sponge.java +++ b/src/main/java/com/denizenscript/denizen2sponge/Denizen2Sponge.java @@ -178,7 +178,8 @@ public void onServerStart(GamePreInitializationEvent event) { Denizen2Core.register(new EntityLeavesAreaScriptEvent()); Denizen2Core.register(new EntityMovesScriptEvent()); Denizen2Core.register(new EntitySpawnsScriptEvent()); - Denizen2Core.register(new ProjectileHitsBlockScriptEvent()); + Denizen2Core.register(new ProjectileImpactsBlockScriptEvent()); + Denizen2Core.register(new ProjectileImpactsEntityScriptEvent()); // Events: Player Denizen2Core.register(new ExperienceChangesScriptEvent()); Denizen2Core.register(new LevelChangesScriptEvent()); diff --git a/src/main/java/com/denizenscript/denizen2sponge/events/entity/ProjectileHitsBlockScriptEvent.java b/src/main/java/com/denizenscript/denizen2sponge/events/entity/ProjectileImpactsBlockScriptEvent.java similarity index 67% rename from src/main/java/com/denizenscript/denizen2sponge/events/entity/ProjectileHitsBlockScriptEvent.java rename to src/main/java/com/denizenscript/denizen2sponge/events/entity/ProjectileImpactsBlockScriptEvent.java index 9194473..6a2600b 100644 --- a/src/main/java/com/denizenscript/denizen2sponge/events/entity/ProjectileHitsBlockScriptEvent.java +++ b/src/main/java/com/denizenscript/denizen2sponge/events/entity/ProjectileImpactsBlockScriptEvent.java @@ -15,20 +15,20 @@ import java.util.HashMap; -public class ProjectileHitsBlockScriptEvent extends ScriptEvent { +public class ProjectileImpactsBlockScriptEvent extends ScriptEvent { // <--[event] // @Since 0.3.0 // @Events - // projectile hits block + // projectile impacts block // - // @Updated 2017/03/24 + // @Updated 2017/10/27 // // @Group Entity // // @Cancellable true // - // @Triggers when a projectile hits a block. + // @Triggers when a projectile impacts a block. // // @Switch entity_type (EntityTypeTag) checks the entity type. // @Switch block_type (BlockTypeTag) checks the block type. @@ -37,8 +37,10 @@ public class ProjectileHitsBlockScriptEvent extends ScriptEvent { // @Switch weather (TextTag) checks the weather. // // @Context - // entity (EntityTag) returns the entity that hit the block. - // location (LocationTag) returns the location of the block hit. + // entity (EntityTag) returns the projectile entity that impacted the block. + // location (LocationTag) returns the location of the block impacted. + // impact_point (LocationTag) returns the precise impact location. + // impact_normal (LocationTag) returns the impact normal of the collision. // // @Determinations // None. @@ -46,23 +48,22 @@ public class ProjectileHitsBlockScriptEvent extends ScriptEvent { @Override public String getName() { - return "ProjectileHitsBlock"; + return "ProjectileImpactsBlock"; } @Override public boolean couldMatch(ScriptEventData data) { - return data.eventPath.startsWith("projectile hits block"); + return data.eventPath.startsWith("projectile impacts block"); } @Override public boolean matches(ScriptEventData data) { return D2SpongeEventHelper.checkEntityType(entity.getInternal().getType(), data, this::error, "entity_type") && D2SpongeEventHelper.checkBlockType(material.getInternal(), data, this::error, "block_type") - && D2SpongeEventHelper.checkWorld(entity.getInternal().getLocation().getExtent(), data, this::error) - && D2SpongeEventHelper.checkCuboid((new LocationTag(entity.getInternal() - .getLocation())).getInternal(), data, this::error) + && D2SpongeEventHelper.checkWorld(location.getInternal().world, data, this::error) + && D2SpongeEventHelper.checkCuboid(location.getInternal(), data, this::error) && D2SpongeEventHelper.checkWeather(Utilities.getIdWithoutDefaultPrefix( - entity.getInternal().getLocation().getExtent().getWeather().getId()), data, this::error); + location.getInternal().world.getWeather().getId()), data, this::error); } public EntityTag entity; @@ -71,6 +72,10 @@ public boolean matches(ScriptEventData data) { public LocationTag location; + public LocationTag impact_point; + + public LocationTag impact_normal; + public CollideBlockEvent.Impact internal; @Override @@ -88,16 +93,20 @@ public HashMap getDefinitions(ScriptEventData data) { HashMap defs = super.getDefinitions(data); defs.put("entity", entity); defs.put("location", location); + defs.put("impact_point", impact_point); + defs.put("impact_normal", impact_normal); return defs; } @Listener - public void onEntityCollidesWithBlock(CollideBlockEvent.Impact evt) { - ProjectileHitsBlockScriptEvent event = (ProjectileHitsBlockScriptEvent) clone(); + public void onEntityImpactsBlock(CollideBlockEvent.Impact evt) { + ProjectileImpactsBlockScriptEvent event = (ProjectileImpactsBlockScriptEvent) clone(); event.internal = evt; - event.entity = new EntityTag(evt.getCause().first(Entity.class).get()); + event.entity = new EntityTag((Entity) evt.getSource()); event.material = new BlockTypeTag(evt.getTargetBlock().getType()); event.location = new LocationTag(evt.getTargetLocation()); + event.impact_point = new LocationTag(evt.getImpactPoint()); + event.impact_normal = new LocationTag(evt.getTargetSide().asOffset()); event.cancelled = evt.isCancelled(); event.run(); evt.setCancelled(event.cancelled); diff --git a/src/main/java/com/denizenscript/denizen2sponge/events/entity/ProjectileImpactsEntityScriptEvent.java b/src/main/java/com/denizenscript/denizen2sponge/events/entity/ProjectileImpactsEntityScriptEvent.java new file mode 100644 index 0000000..09aa760 --- /dev/null +++ b/src/main/java/com/denizenscript/denizen2sponge/events/entity/ProjectileImpactsEntityScriptEvent.java @@ -0,0 +1,113 @@ +package com.denizenscript.denizen2sponge.events.entity; + +import com.denizenscript.denizen2core.events.ScriptEvent; +import com.denizenscript.denizen2core.tags.AbstractTagObject; +import com.denizenscript.denizen2sponge.Denizen2Sponge; +import com.denizenscript.denizen2sponge.events.D2SpongeEventHelper; +import com.denizenscript.denizen2sponge.tags.objects.BlockTypeTag; +import com.denizenscript.denizen2sponge.tags.objects.EntityTag; +import com.denizenscript.denizen2sponge.tags.objects.LocationTag; +import com.denizenscript.denizen2sponge.utilities.Utilities; +import org.spongepowered.api.Sponge; +import org.spongepowered.api.entity.Entity; +import org.spongepowered.api.event.Listener; +import org.spongepowered.api.event.entity.CollideEntityEvent; + +import java.util.HashMap; + +public class ProjectileImpactsEntityScriptEvent extends ScriptEvent { + + // <--[event] + // @Since 0.3.0 + // @Events + // projectile impacts entity + // + // @Updated 2017/10/27 + // + // @Group Entity + // + // @Cancellable true + // + // @Triggers when a projectile impacts an entity. + // + // @Switch type (EntityTypeTag) checks the projectile type. + // @Switch other_type (EntityTypeTag) checks the other entity type. + // @Switch world (WorldTag) checks the world. + // @Switch cuboid (CuboidTag) checks the cuboid area. + // @Switch weather (TextTag) checks the weather. + // + // @Context + // entity (EntityTag) returns the projectile entity that impacted the other entity. + // other_entity (EntityTag) returns the entity that was impacted. + // impact_point (LocationTag) returns the precise impact location. + // + // @Determinations + // None. + // --> + + @Override + public String getName() { + return "ProjectileImpactsEntity"; + } + + @Override + public boolean couldMatch(ScriptEventData data) { + return data.eventPath.startsWith("projectile impacts entity"); + } + + @Override + public boolean matches(ScriptEventData data) { + return D2SpongeEventHelper.checkEntityType(entity.getInternal().getType(), data, this::error, "type") + && D2SpongeEventHelper.checkEntityType(other_entity.getInternal().getType(), data, this::error, "other_type") + && D2SpongeEventHelper.checkWorld(impact_point.getInternal().world, data, this::error) + && D2SpongeEventHelper.checkCuboid(impact_point.getInternal(), data, this::error) + && D2SpongeEventHelper.checkWeather(Utilities.getIdWithoutDefaultPrefix( + impact_point.getInternal().world.getWeather().getId()), data, this::error); + } + + public EntityTag entity; + + public EntityTag other_entity; + + public LocationTag impact_point; + + public CollideEntityEvent.Impact internal; + + @Override + public void enable() { + Sponge.getEventManager().registerListeners(Denizen2Sponge.instance, this); + } + + @Override + public void disable() { + Sponge.getEventManager().unregisterListeners(this); + } + + @Override + public HashMap getDefinitions(ScriptEventData data) { + HashMap defs = super.getDefinitions(data); + defs.put("entity", entity); + defs.put("other_entity", other_entity); + defs.put("impact_point", impact_point); + return defs; + } + + @Listener + public void onEntityImpactsEntity(CollideEntityEvent.Impact evt) { + ProjectileImpactsEntityScriptEvent event = (ProjectileImpactsEntityScriptEvent) clone(); + event.internal = evt; + Entity projectile = (Entity) evt.getSource(); + event.entity = new EntityTag(projectile); + evt.getEntities().remove(projectile); + event.other_entity = new EntityTag(evt.getEntities().iterator().next()); + event.impact_point = new LocationTag(evt.getImpactPoint()); + event.cancelled = evt.isCancelled(); + event.run(); + evt.setCancelled(event.cancelled); + } + + @Override + public void applyDetermination(boolean errors, String determination, AbstractTagObject value) { + super.applyDetermination(errors, determination, value); + } +}