Merge branch 'master' into 1.17

src/main/java/carpet/script/annotation/Locator.java

@@ -8,6 +8,7 @@ import java.util.Iterator;
 
 import org.apache.commons.lang3.NotImplementedException;
 
+import carpet.script.CarpetContext;
 import carpet.script.Context;
 import carpet.script.argument.Argument;
 import carpet.script.argument.BlockArgument;
@@ -17,6 +18,8 @@ import carpet.script.bundled.Module;
 import carpet.script.value.BlockValue;
 import carpet.script.value.FunctionValue;
 import carpet.script.value.Value;
+import net.minecraft.block.BlockState;
+import net.minecraft.util.math.BlockPos;
 
 import static java.lang.annotation.ElementType.PARAMETER;
 import static java.lang.annotation.ElementType.TYPE_USE;
@@ -25,20 +28,18 @@ import static java.lang.annotation.RetentionPolicy.RUNTIME;
 /**
  * <p>Class that holds annotation for {@link Argument} locators to be used in Scarpet functions.</p>
  * 
- * <p>Note: Nothing in this class has been implemented at this point in time, since it requires Carpet changes. There is an implementation for
- * Locator.Block working, but not implemented.</p>
+ * <p>Note: Only {@link Block} locator is currently implemented.</p>
  */
 public interface Locator
 {
     /**
      * <p>Represents that the annotated argument must be gotten by passing the arguments in there into a {@link BlockArgument} locator.</p>
      * 
-     * <p>Must be used in either {@link BlockValue} or {@link BlockArgument} parameters</p>
+     * <p>Must be used in either {@link BlockArgument}, {@link BlockValue}, {@link BlockPos} or {@link BlockState} parameters</p>
      */
     @Documented
     @Retention(RUNTIME)
     @Target({ PARAMETER, TYPE_USE })
-    @Deprecated // Not implemented, although implementation available
     public @interface Block
     {
         /**
@@ -140,7 +141,7 @@ public interface Locator
 
         private static class BlockLocator<R> extends AbstractLocator<R>
         {
-            private final boolean returnBlockValue;
+            private final java.util.function.Function<BlockArgument, R> returnFunction;
             private final boolean acceptString;
             private final boolean anyString;
             private final boolean optional;
@@ -150,11 +151,24 @@ public interface Locator
                 this.acceptString = annotation.acceptString();
                 this.anyString = annotation.anyString();
                 this.optional = annotation.optional();
-                this.returnBlockValue = type == BlockValue.class;
-                if (returnBlockValue && (anyString || optional))
+                if (type != BlockArgument.class && (anyString || optional))
                     throw new IllegalArgumentException("Can only use anyString or optional parameters of Locator.Block if targeting a BlockArgument");
-                if (!returnBlockValue && type != BlockArgument.class)
-                    throw new IllegalArgumentException("Locator.Block can only be used against BlockArgument or BlockValue types!");
+                this.returnFunction = getReturnFunction(type);
+                if (returnFunction == null)
+                    throw new IllegalArgumentException("Locator.Block can only be used against BlockArgument, BlockValue, BlockPos or BlockState types!");
+            }
+
+            @SuppressWarnings("unchecked")
+            private static <R> java.util.function.Function<BlockArgument, R> getReturnFunction(Class<R> type) {
+                if (type == BlockArgument.class)
+                    return r -> (R) r;
+                if (type == BlockValue.class)
+                    return r -> (R) r.block;
+                if (type == BlockPos.class)
+                    return r -> (R) r.block.getPos();
+                if (type == BlockState.class)
+                    return r -> (R) r.block.getBlockState();
+                return null;
             }
 
             @Override
@@ -166,10 +180,8 @@ public interface Locator
             @Override
             public R checkAndConvert(Iterator<Value> valueIterator, Context context, Context.Type theLazyT)
             {
-                BlockArgument locator = null; // BlockArgument.findIn((CarpetContext)context, valueIterator (requires changing to Value), 0,
-                                              // acceptString, optional, anyString);
-                // return (R) (returnBlockValue ? locator.block : locator);
-                throw new NotImplementedException("Locator.Block still requires adapting BlockArgument to accept iterators (which is actually simple)");
+                BlockArgument locator = BlockArgument.findIn((CarpetContext) context, valueIterator, 0, acceptString, optional, anyString);
+                return returnFunction.apply(locator);
             }
         }