PGMDev · Electroid · Oct 2, 2021 · Jan 9, 2021 · Jan 9, 2021 · Jan 12, 2021
@@ -37,8 +37,8 @@
 import tc.oc.pgm.fallingblocks.FallingBlocksModule;
 import tc.oc.pgm.ffa.FreeForAllMatchModule;
 import tc.oc.pgm.ffa.FreeForAllModule;
-import tc.oc.pgm.filters.FilterMatchModule;
 import tc.oc.pgm.filters.FilterModule;
+import tc.oc.pgm.filters.dynamic.FilterMatchModule;
 import tc.oc.pgm.fireworks.FireworkMatchModule;
 import tc.oc.pgm.flag.FlagMatchModule;
 import tc.oc.pgm.flag.FlagModule;

@@ -1,14 +1,53 @@
 package tc.oc.pgm.api.filter;
 
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import org.bukkit.event.Event;
+import tc.oc.pgm.api.feature.Feature;
+import tc.oc.pgm.api.feature.FeatureReference;
 import tc.oc.pgm.api.filter.query.Query;
+import tc.oc.pgm.filters.FilterParser;
 
+/**
+ * Something that can answer "yes", "no" or "i don't care" to the imagined question: "Can X
+ * happen?". To be able to answer the question context is provided initially through a {@link Query}
+ * and then processed by the filter itself before a response is given.
+ *
+ * <p>If a filter is connected to a specific {@link Feature} a {@link FeatureReference} should be
+ * passed at xml parse time (when the filter is created) and {@link FeatureReference#get() fetched}
+ * at match time
+ *
+ * <p>For examples on how to create filters see {@link FilterParser}
+ *
+ * @see Query
+ */
 public interface Filter {
 
+  /**
+   * Filters with children are responsible for returning the events of their children.
+   *
+   * <p>Empty list tells us that the filter is not dynamic
+   */
+  default Collection<Class<? extends Event>> getRelevantEvents() {
+    return ImmutableList.of();
+  }
+
   /** Least-derived query type that this filter might not abstain from */
   Class<? extends Query> getQueryType();
 
   QueryResponse query(Query query);
 
+  default boolean response(Query query) {
+    switch (query(query)) {
+      case ALLOW:
+        return true;
+      case DENY:
+        return false;
+      default:
+        throw new UnsupportedOperationException("Filter did not respond to the query");
+    }
+  }
+
   enum QueryResponse {
     ALLOW,
     DENY,

@@ -6,8 +6,12 @@
 
 /** A query for a player that may or may not be online or participating in the match. */
 public interface PlayerQuery extends PartyQuery, EntityTypeQuery, LocationQuery {
-  UUID getPlayerId();
+  UUID getId();
 
+  /*TODO this is not followed in any implementations or trusted by any other code. If this is fixed change places like
+  CarryingFlagFilter Line 33/34 at the time of this commit
+  ParticipantFilter Line 26/27
+  RegionMatchModule Line 375/376 etc...*/
   /** Return the {@link MatchPlayer} for this player if they are online, otherwise null. */
   @Nullable
   MatchPlayer getPlayer();

@@ -1,9 +1,33 @@
 package tc.oc.pgm.api.filter.query;
 
 import javax.annotation.Nullable;
+import org.bukkit.Location;
 import org.bukkit.event.Event;
+import org.bukkit.event.entity.CreatureSpawnEvent;
+import tc.oc.pgm.api.filter.Filter;
+import tc.oc.pgm.api.match.Match;
+import tc.oc.pgm.api.party.Party;
+import tc.oc.pgm.api.player.MatchPlayer;
+import tc.oc.pgm.goals.Goal;
 
+/**
+ * A query can be thought of as context to a question which can be asked to a {@link Filter}. The
+ * context can include different information like a {@link Match}, a {@link Goal}, a {@link
+ * MatchPlayer} or a {@link CreatureSpawnEvent.SpawnReason}.
+ *
+ * @implSpec a {@link Query} interface should only add <b>one</b> piece of information to the
+ *     context. To increase the amount of information retrievable from the query it can extend other
+ *     queries.
+ *     <p>A {@link PlayerQuery} adds a {@link MatchPlayer} to the context, but can also provide info
+ *     found in other queries like a {@link Party} or a {@link Location}, therefore it extends those
+ *     queries({@link PartyQuery}, {@link LocationQuery}) instead of adding more methods to its own
+ *     interface.
+ * @see Filter
+ */
 public interface Query {
+  /** The event providing the query information, if any */
   @Nullable
-  Event getEvent();
+  default Event getEvent() {
+    return null;
+  }
 }
@@ -37,4 +37,7 @@ public interface MapProtos {
 
   // Option on objectives to determine if they are required to win the match
   Version GOAL_REQUIRED_OPTION = new Version(1, 4, 0);
+
+  // Various changes to support dynamic filters
+  Version DYNAMIC_FILTERS = new Version(1, 4, 2);
 }
@@ -11,6 +11,7 @@
 import org.bukkit.entity.Player;
 import org.bukkit.event.Event;
 import org.bukkit.event.Listener;
+import tc.oc.pgm.api.filter.query.MatchQuery;
 import tc.oc.pgm.api.map.MapInfo;
 import tc.oc.pgm.api.match.event.MatchFinishEvent;
 import tc.oc.pgm.api.match.event.MatchLoadEvent;
@@ -27,7 +28,7 @@
 import tc.oc.pgm.api.time.Tick;
 import tc.oc.pgm.countdowns.CountdownContext;
 import tc.oc.pgm.features.MatchFeatureContext;
-import tc.oc.pgm.filters.query.Query;
+import tc.oc.pgm.filters.dynamic.Filterable;
 import tc.oc.pgm.util.Audience;
 
 /**
@@ -38,7 +39,12 @@
  * {@link Match}. This should allow multiple {@link Match}es to run concurrently on the same {@link
  * org.bukkit.Server}, as long as resources are cleaned up after {@link #unload()}.
  */
-public interface Match extends MatchPlayerResolver, Audience, ModuleContext<MatchModule> {
+public interface Match
+    extends MatchPlayerResolver,
+        Audience,
+        ModuleContext<MatchModule>,
+        Filterable<MatchQuery>,
+        MatchQuery {
 
   /**
    * Get the global {@link Logger} for the {@link Match}.
@@ -365,13 +371,6 @@ default boolean finish() {
    */
   void removeParty(Party party);
 
-  /**
-   * Get the {@link Query} associated with the {@link Match}.
-   *
-   * @return The filter {@link Query}.
-   */
-  Query getQuery();
-
   /**
    * Get the {@link Duration} of the {@link Match}, or {@link Duration#ZERO} if not yet started.
    *
@@ -407,4 +406,9 @@ default boolean finish() {
    * @return If the {@link Match} was just ended.
    */
   boolean calculateVictory();
+
+  @Override
+  default Match getMatch() {
+    return this;
+  }
 }
@@ -7,8 +7,10 @@
 import org.bukkit.ChatColor;
 import org.bukkit.Color;
 import tc.oc.pgm.api.filter.query.PartyQuery;
+import tc.oc.pgm.api.filter.query.PlayerQuery;
 import tc.oc.pgm.api.match.Match;
 import tc.oc.pgm.api.player.MatchPlayer;
+import tc.oc.pgm.filters.dynamic.Filterable;
 import tc.oc.pgm.util.Audience;
 import tc.oc.pgm.util.named.Named;
 
@@ -17,7 +19,8 @@
  *
  * @see Competitor
  */
-public interface Party extends Audience, Named {
+public interface Party extends Audience, Named, Filterable<PartyQuery>, PartyQuery {
+
   /**
    * Gets the match.
    *
@@ -132,4 +135,20 @@ default boolean isParticipating() {
   default boolean isObserving() {
     return !this.isParticipating();
   }
+
+  @Override
+  @Nullable
+  default Match getFilterableParent() {
+    return this.getMatch();
+  }
+
+  @Override
+  default Collection<? extends Filterable<? extends PlayerQuery>> getFilterableChildren() {
+    return this.getPlayers();
+  }
+
+  @Override
+  default Party getParty() {
+    return this;
+  }
 }
@@ -3,6 +3,7 @@
 import java.util.UUID;
 import javax.annotation.Nullable;
 import org.bukkit.GameMode;
+import org.bukkit.entity.Entity;
 import org.bukkit.entity.Player;
 import org.bukkit.inventory.InventoryHolder;
 import org.bukkit.inventory.PlayerInventory;
@@ -12,7 +13,7 @@
 import tc.oc.pgm.api.party.Competitor;
 import tc.oc.pgm.api.party.Party;
 import tc.oc.pgm.api.setting.Settings;
-import tc.oc.pgm.filters.query.Query;
+import tc.oc.pgm.filters.dynamic.Filterable;
 import tc.oc.pgm.kits.Kit;
 import tc.oc.pgm.util.Audience;
 import tc.oc.pgm.util.attribute.Attribute;
@@ -27,7 +28,8 @@
  * this is used is to check if a {@link MatchPlayer} is involved in an event. If you need to access
  * or modify a {@link Player}, there should be a method added to {@link MatchPlayer}.
  */
-public interface MatchPlayer extends Audience, Named, Tickable, InventoryHolder {
+public interface MatchPlayer
+    extends Audience, Named, Tickable, InventoryHolder, Filterable<PlayerQuery>, PlayerQuery {
 
   /**
    * Get the {@link Match} of the {@link MatchPlayer}.
@@ -73,13 +75,6 @@ public interface MatchPlayer extends Audience, Named, Tickable, InventoryHolder
   @Nullable
   ParticipantState getParticipantState();
 
-  /**
-   * Get the filter {@link Query} that exclusively matches the {@link MatchPlayer}.
-   *
-   * @return The {@link Query} to match the {@link MatchPlayer}.
-   */
-  PlayerQuery getQuery();
-
   /**
    * Get the underlying {@link Player} that is associated with the {@link MatchPlayer}.
    *
@@ -257,4 +252,15 @@ default boolean isLegacy() {
 
   @Deprecated
   void internalSetParty(Party party);
+
+  @Override
+  default Class<? extends Entity> getEntityType() {
+    return Player.class;
+  }
+
+  @Nullable
+  @Override
+  default MatchPlayer getPlayer() {
+    return this;
+  }
 }
@@ -1,11 +1,13 @@
 package tc.oc.pgm.api.region;
 
+import java.util.Collection;
 import java.util.Iterator;
 import java.util.Random;
 import org.bukkit.Location;
 import org.bukkit.block.Block;
 import org.bukkit.block.BlockState;
 import org.bukkit.entity.Entity;
+import org.bukkit.event.Event;
 import org.bukkit.util.BlockVector;
 import org.bukkit.util.Vector;
 import tc.oc.pgm.api.filter.Filter;
@@ -75,4 +77,6 @@ public interface Region extends Filter {
   public Iterator<BlockVector> getBlockVectorIterator();
 
   public Iterable<BlockVector> getBlockVectors();
+
+  public Collection<Class<? extends Event>> getRelevantEvents();
 }
@@ -69,7 +69,7 @@ public int getNumOfLives(UUID id) {
   @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
   public void handleDeath(final MatchPlayerDeathEvent event) {
     MatchPlayer victim = event.getVictim();
-    if (config.getFilter().query(victim.getQuery()).isDenied()) return;
+    if (config.getFilter().query(victim).isDenied()) return;
     if (victim.getParty() instanceof Competitor) {
       Competitor competitor = (Competitor) victim.getParty();
 

@@ -35,8 +35,7 @@ protected Component formatText() {
   public void onEnd(Duration total) {
     super.onEnd(total);
     for (MatchPlayer player : this.getMatch().getPlayers()) {
-      if (this.broadcast.filter == null
-          || this.broadcast.filter.query(player.getQuery()).isAllowed()) {
+      if (this.broadcast.filter == null || this.broadcast.filter.query(player).isAllowed()) {
         player.sendMessage(this.broadcast.getFormattedMessage());
         player.playSound(this.broadcast.getSound());
       }

@@ -243,7 +243,7 @@ private boolean canCapture(Competitor team) {
 
   private boolean canDominate(MatchPlayer player) {
     return this.definition.getPlayerFilter() == null
-        || this.definition.getPlayerFilter().query(player.getQuery()).isAllowed();
+        || this.definition.getPlayerFilter().query(player).isAllowed();
   }
 
   public float getEffectivePointsPerSecond() {

@@ -162,13 +162,13 @@ public boolean isAutomatic() {
   }
 
   /**
-   * If the player is online and participating, this delegates to {@link MatchPlayer#getQuery()}.
-   * Otherwise it returns an PlayerQuery, which knows about the player's identity, but has no
-   * properties related to physical presence in the match.
+   * If the player is online and participating, this delegates to that player. Otherwise it returns
+   * a PlayerQuery, which knows about the player's identity, but has no properties related to
+   * physical presence in the match.
    */
   @Override
   public tc.oc.pgm.api.filter.query.PartyQuery getQuery() {
-    return player != null ? player.getQuery() : query;
+    return player != null ? player : query;
   }
 
   @Override

@@ -1,5 +1,8 @@
 package tc.oc.pgm.filters;
 
+import java.util.Collection;
+import java.util.Collections;
+import org.bukkit.event.Event;
 import tc.oc.pgm.api.feature.FeatureReference;
 import tc.oc.pgm.api.filter.query.PartyQuery;
 import tc.oc.pgm.api.filter.query.PlayerQuery;
@@ -9,6 +12,7 @@
 import tc.oc.pgm.api.player.MatchPlayer;
 import tc.oc.pgm.flag.Flag;
 import tc.oc.pgm.flag.FlagDefinition;
+import tc.oc.pgm.flag.event.FlagStateChangeEvent;
 
 public class CarryingFlagFilter extends TypedFilter<PartyQuery> {
 
@@ -18,6 +22,11 @@ public CarryingFlagFilter(FeatureReference<? extends FlagDefinition> flag) {
     this.flag = flag;
   }
 
+  @Override
+  public Collection<Class<? extends Event>> getRelevantEvents() {
+    return Collections.singleton(FlagStateChangeEvent.class);
+  }
+
   @Override
   public Class<? extends PartyQuery> getQueryType() {
     return PartyQuery.class;
@@ -30,7 +39,7 @@ protected QueryResponse queryTyped(PartyQuery query) {
     if (goal == null) return QueryResponse.ABSTAIN;
 
     if (query instanceof PlayerQuery) {
-      MatchPlayer player = match.getPlayer(((PlayerQuery) query).getPlayerId());
+      MatchPlayer player = match.getPlayer(((PlayerQuery) query).getId());
       return QueryResponse.fromBoolean(player != null && goal.isCarrying(player));
     } else {
       final Party party = query.getParty();