Merge remote-tracking branch 'origin/api-13' into api-14

Author: aromaa

src/main/java/org/spongepowered/api/block/transaction/BlockTransaction.java

@@ -29,7 +29,10 @@
 import org.spongepowered.api.data.Transaction;
 import org.spongepowered.api.data.persistence.DataContainer;
 import org.spongepowered.api.data.persistence.Queries;
+import org.spongepowered.api.world.BlockChangeFlag;
+import org.spongepowered.api.world.BlockChangeFlags;
 
+import java.lang.ref.WeakReference;
 import java.util.List;
 import java.util.Objects;
 import java.util.StringJoiner;
@@ -47,6 +50,9 @@ public final class BlockTransaction extends Transaction<BlockSnapshot> {
 
     private final Operation operation;
 
+    private @Nullable WeakReference<BlockSnapshot> custom;
+    private @Nullable BlockChangeFlag customFlag;
+
     public BlockTransaction(final BlockSnapshot original, final BlockSnapshot defaultReplacement,
         final Operation operation
     ) {
@@ -66,6 +72,37 @@ public Operation operation() {
         return this.operation;
     }
 
+    /**
+     * Sets the custom snapshot. If setting <code>null</code>, this will
+     * reset to use the {@link #defaultReplacement()} snapshot.
+     *
+     * @param custom The custom snapshot
+     * @param flag TThe various change flags controlling some interactions
+     */
+    public void setCustom(final @Nullable BlockSnapshot custom, final BlockChangeFlag flag) {
+        this.setCustom(custom);
+        if (custom != null) {
+            this.custom = new WeakReference<>(custom);
+            this.customFlag = flag;
+        } else {
+            this.custom = null;
+            this.customFlag = null;
+        }
+    }
+
+    /**
+     * Gets the {@link BlockChangeFlag flag} that is used to place
+     * the custom {@link BlockSnapshot}.
+     *
+     * @return The flag
+     */
+    public BlockChangeFlag customFlag() {
+        if (this.custom().isEmpty() || this.custom == null || this.custom.get() != this.custom().get()) {
+            return BlockChangeFlags.DEFAULT_PLACEMENT;
+        }
+        return this.customFlag;
+    }
+
     @Override
     public int hashCode() {
         return Objects.hash(super.hashCode(), this.operation);

src/main/java/org/spongepowered/api/event/lifecycle/RegisterTagEvent.java

@@ -0,0 +1,79 @@
+/*
+ * This file is part of SpongeAPI, licensed under the MIT License (MIT).
+ *
+ * Copyright (c) SpongePowered <https://www.spongepowered.org>
+ * Copyright (c) contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package org.spongepowered.api.event.lifecycle;
+
+import org.spongepowered.api.registry.DefaultedRegistryReference;
+import org.spongepowered.api.registry.RegistryKey;
+import org.spongepowered.api.tag.Tag;
+
+import java.util.function.BiPredicate;
+import java.util.function.Consumer;
+import java.util.function.Predicate;
+
+/**
+ * Lifecycle event for applying modifications to {@link Tag tags}.
+ *
+ * <p>This event provides mechanism for plugins to <strong>propose</strong>
+ * changes to the tags that are processed during tag construction.</p>
+ *
+ * <p>The following chain of events take place during tag construction:</p>
+ * <ul>
+ *     <li>Tags are merged from data packs</li>
+ *     <li>Append proposed tags</li>
+ *     <li>Apply filter to ALL present tags</li>
+ *     <li>Remaining items makes up the final tag</li>
+ * </ul>
+ */
+public interface RegisterTagEvent extends LifecycleEvent {
+
+    <T> TagStep<T> tag(Tag<T> tag);
+
+    interface TagStep<T> {
+
+        default TagStep<T> delete() {
+            return this.filter(k -> false);
+        }
+
+        TagStep<T> filter(Predicate<DefaultedRegistryReference<T>> predicate);
+
+        default TagStep<T> filterTags(Predicate<Tag<T>> predicate) {
+            return this.filterTags((t, k) -> predicate.test(t));
+        }
+
+        TagStep<T> filterTags(BiPredicate<Tag<T>, DefaultedRegistryReference<T>> predicate);
+
+        TagStep<T> append(RegistryKey<T> key);
+
+        TagStep<T> append(Tag<T> tag);
+
+        TagStep<T> test(Predicate<DefaultedRegistryReference<T>> predicate, Consumer<TagStep<T>> consumer);
+
+        default TagStep<T> testTags(Predicate<Tag<T>> predicate, Consumer<TagStep<T>> consumer) {
+            return this.testTags((t, k) -> predicate.test(t), consumer);
+        }
+
+        TagStep<T> testTags(BiPredicate<Tag<T>, DefaultedRegistryReference<T>> predicate, Consumer<TagStep<T>> consumer);
+    }
+}

src/main/java/org/spongepowered/api/tag/Tag.java

@@ -30,6 +30,7 @@
 import org.spongepowered.api.Sponge;
 import org.spongepowered.api.block.BlockType;
 import org.spongepowered.api.registry.DefaultedRegistryType;
+import org.spongepowered.api.registry.RegistryType;
 
 /**
  * A {@link ResourceKey resource keyed} collection of {@link Taggable} values
@@ -49,12 +50,26 @@
  */
 public interface Tag<T> extends ResourceKeyed {
 
+    /**
+     * Gets the {@link RegistryType location} defining the parent registry.
+     *
+     * @return The location
+     */
+    RegistryType<T> registry();
+
     interface Factory {
-        <T> Tag<T> of(DefaultedRegistryType<T> registryType, ResourceKey key);
+        default <T> Tag<T> of(DefaultedRegistryType<T> registryType, ResourceKey key) {
+            return this.of((RegistryType<T>) registryType, key);
+        }
+
+        <T> Tag<T> of(RegistryType<T> registryType, ResourceKey key);
     }
 
     static <T> Tag<T> of(DefaultedRegistryType<T> registryType, ResourceKey key) {
         return Sponge.game().factoryProvider().provide(Tag.Factory.class).of(registryType, key);
     }
 
+    static <T> Tag<T> of(RegistryType<T> registryType, ResourceKey key) {
+        return Sponge.game().factoryProvider().provide(Tag.Factory.class).of(registryType, key);
+    }
 }

src/main/java/org/spongepowered/api/world/World.java

@@ -29,7 +29,9 @@
 import org.spongepowered.api.effect.Viewer;
 import org.spongepowered.api.entity.Entity;
 import org.spongepowered.api.entity.living.player.Player;
+import org.spongepowered.api.event.CauseStackManager;
 import org.spongepowered.api.registry.RegistryHolder;
+import org.spongepowered.api.scheduler.Scheduler;
 import org.spongepowered.api.service.context.ContextSource;
 import org.spongepowered.api.util.annotation.DoNotStore;
 import org.spongepowered.api.world.chunk.WorldChunk;
@@ -227,4 +229,38 @@ default Optional<WorldChunk> loadChunk(final Vector3i chunkPosition, final boole
      */
     Iterable<WorldChunk> loadedChunks();
 
+    /**
+     * Gets the {@link Scheduler} used to schedule sync tasks on this {@link World}.
+     *
+     * <p><strong>Note:</strong> Accessing objects outside of this {@link World}
+     * from the scheduled tasks can lead to hard to diagnose problems
+     * or unrecoverable crashes.</p>
+     *
+     * @return The sync scheduler
+     */
+    default Scheduler scheduler() {
+        return this.engine().scheduler();
+    }
+
+    /**
+     * Gets the {@link CauseStackManager} for handling the current event cause
+     * stack and context information.
+     *
+     * <p><strong>Note:</strong> Accessing this outside of {@link World#onWorldThread()}
+     * can lead to hard to diagnose problems or unrecoverable crashes.</p>
+     *
+     * @return The cause stack manager
+     */
+    default CauseStackManager causeStackManager() {
+        return this.engine().causeStackManager();
+    }
+
+    /**
+     * Checks if the {@link Thread#currentThread() current thread} is the main thread of the world.
+     *
+     * @return {@code true} if main thread, {@code false} if not
+     */
+    default boolean onWorldThread() {
+        return this.engine().onMainThread();
+    }
 }