Introduces toggle effect & expression

src/main/java/ch/njol/skript/effects/EffToggle.java

@@ -18,19 +18,18 @@
  */
 package ch.njol.skript.effects;
 
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.MethodHandles;
-import java.lang.invoke.MethodType;
+import java.util.ArrayList;
 
 import org.bukkit.block.Block;
-import org.bukkit.block.BlockFace;
 import org.bukkit.block.data.BlockData;
 import org.bukkit.block.data.Openable;
 import org.bukkit.block.data.Powerable;
 import org.bukkit.event.Event;
 import org.eclipse.jdt.annotation.Nullable;
 
 import ch.njol.skript.Skript;
+import ch.njol.skript.classes.Changer.ChangeMode;
+import ch.njol.skript.classes.Changer.ChangerUtils;
 import ch.njol.skript.doc.Description;
 import ch.njol.skript.doc.Examples;
 import ch.njol.skript.doc.Name;
@@ -40,63 +39,88 @@
 import ch.njol.skript.lang.SkriptParser.ParseResult;
 import ch.njol.util.Kleenean;
 
-/**
- * @author Peter Güttinger
- */
-@SuppressWarnings("deprecation")
 @Name("Toggle")
-@Description("Toggle the state of a block.")
+@Description("Toggle a boolean or the state of a block.")
 @Examples({"# use arrows to toggle switches, doors, etc.",
 		"on projectile hit:",
 		"\tprojectile is arrow",
-		"\ttoggle the block at the arrow"})
-@Since("1.4")
+		"\ttoggle the block at the arrow",
+		"",
+		"# With booleans",
+		"toggle gravity of player"
+})
+@Since("1.4, INSERT VERSION (booleans)")
 public class EffToggle extends Effect {
 
 	static {
-		Skript.registerEffect(EffToggle.class, "(close|turn off|de[-]activate) %blocks%", "(toggle|switch) [[the] state of] %blocks%", "(open|turn on|activate) %blocks%");
+		Skript.registerEffect(EffToggle.class,
+			"(open|turn on|activate) %blocks%",
+			"(close|turn off|de[-]activate) %blocks%",
+			"(toggle|switch) [[the] state of] %booleans/blocks%");
+	}
+
+	private enum State {
+		ACTIVATE, DEACTIVATE, TOGGLE
 	}
 
 	@SuppressWarnings("null")
-	private Expression<Block> blocks;
-	private int toggle;
+	private Expression<?> togglables;
+	private State state;
 
-	@SuppressWarnings({"unchecked", "null"})
 	@Override
-	public boolean init(final Expression<?>[] vars, final int matchedPattern, final Kleenean isDelayed, final ParseResult parseResult) {
-		blocks = (Expression<Block>) vars[0];
-		toggle = matchedPattern - 1;
+	public boolean init(Expression<?>[] vars, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) {
+		togglables = (Expression<?>) vars[0];
+		state = State.values()[matchedPattern];
+		if (togglables.getReturnType() == Boolean.class && !ChangerUtils.acceptsChange(togglables, ChangeMode.SET, Boolean.class)) {
+			Skript.error(togglables.toString(null, false) + " cannot be toggled");
+			return false;
+		}
 		return true;
 	}
 
 	@Override
-	protected void execute(final Event e) {
-		for (Block b : blocks.getArray(e)) {
-			BlockData data = b.getBlockData();
-			if (toggle == -1) {
-				if (data instanceof Openable)
-					((Openable) data).setOpen(false);
-				else if (data instanceof Powerable)
-					((Powerable) data).setPowered(false);
-			} else if (toggle == 1) {
-				if (data instanceof Openable)
-					((Openable) data).setOpen(true);
-				else if (data instanceof Powerable)
-					((Powerable) data).setPowered(true);
-			} else {
-				if (data instanceof Openable) // open = NOT was open
-					((Openable) data).setOpen(!((Openable) data).isOpen());
-				else if (data instanceof Powerable) // power = NOT power
-					((Powerable) data).setPowered(!((Powerable) data).isPowered());
+	protected void execute(Event event) {
+		ArrayList<Object> toggledValues = new ArrayList<>();
+		for (Object obj : togglables.getArray(event)) {
+			if (obj instanceof Block) {
+				Block block = (Block) obj;
+				BlockData data = block.getBlockData();
+				if (state == State.TOGGLE) {
+					if (data instanceof Openable) { // open = NOT was open
+						((Openable) data).setOpen(!((Openable) data).isOpen());
+					} else if (data instanceof Powerable) { // power = NOT power
+						((Powerable) data).setPowered(!((Powerable) data).isPowered());
+					}
+				} else {
+					boolean value = state == State.ACTIVATE; 
+					if (data instanceof Openable) {
+						((Openable) data).setOpen(value);
+					} else if (data instanceof Powerable) {
+						((Powerable) data).setPowered(value);
+					}
+				}
+
+				block.setBlockData(data);
+				toggledValues.add(block);
+
+			} else if (obj instanceof Boolean) {
+				toggledValues.add(!(Boolean) obj);
 			}
-
-			b.setBlockData(data);
 		}
-	}
 
+		Object[] filteredValues = toggledValues.stream().filter(
+			obj -> ChangerUtils.acceptsChange(togglables, ChangeMode.SET, obj.getClass())
+		).toArray(Object[]::new);
+
+		if (filteredValues.length != 0) {
+			togglables.change(event, filteredValues, ChangeMode.SET);
+		}
+
+	}
+
 	@Override
-	public String toString(final @Nullable Event e, final boolean debug) {
-		return "toggle " + blocks.toString(e, debug);
+	public String toString(@Nullable Event event, final boolean debug) {
+		return "toggle " + togglables.toString(event, debug);
 	}
 
 }

src/main/java/ch/njol/skript/expressions/ExprInverse.java

@@ -0,0 +1,82 @@
+/**
+ *   This file is part of Skript.
+ *
+ *  Skript is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Skript is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Skript.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Copyright Peter Güttinger, SkriptLang team and contributors
+ */
+package ch.njol.skript.expressions;
+
+import org.bukkit.event.Event;
+import org.eclipse.jdt.annotation.Nullable;
+
+import ch.njol.skript.Skript;
+import ch.njol.skript.doc.Description;
+import ch.njol.skript.doc.Examples;
+import ch.njol.skript.doc.Name;
+import ch.njol.skript.doc.Since;
+import ch.njol.skript.lang.Expression;
+import ch.njol.skript.lang.ExpressionType;
+import ch.njol.skript.lang.SkriptParser.ParseResult;
+import ch.njol.skript.lang.util.SimpleExpression;
+import ch.njol.util.Kleenean;
+
+@Name("Inverse Boolean")
+@Description("An expression to obtain the inverse value of a boolean")
+@Examples("set {_gravity} to inverse of player's flight mode")
+@Since("INSERT VERSION")
+public class ExprInverse extends SimpleExpression<Boolean> {
+
+	static {
+		Skript.registerExpression(ExprInverse.class, Boolean.class, ExpressionType.COMBINED, 
+			"[the] (inverse|opposite) of %booleans%"
+		);
+	}
+
+	private Expression<Boolean> booleanExpr;
+
+	@Override
+	@SuppressWarnings("unchecked")
+	public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) {
+		booleanExpr = (Expression<Boolean>) exprs[0];
+		return true;
+	}
+
+	@Override
+	@Nullable
+	protected Boolean[] get(Event event) {
+		Boolean[] original = booleanExpr.getArray(event);
+		Boolean[] toggled = new Boolean[original.length];
+		for (int i = 0; i < original.length; i++) {
+			toggled[i] = !original[i];
+		}
+		return toggled;
+	}
+
+	@Override
+	public boolean isSingle() {
+		return booleanExpr.isSingle();
+	}
+
+	@Override
+	public Class<? extends Boolean> getReturnType() {
+		return Boolean.class;
+	}
+
+	@Override
+	public String toString(@Nullable Event event, boolean debug) {
+		return "inverse of " + booleanExpr.toString(event, debug);
+	}
+
+}

src/test/skript/tests/syntaxes/effects/EffToggle.sk

@@ -0,0 +1,35 @@
+test "toggle effect":
+  set {_isToggled} to false
+  assert {_isToggled} is false with "{_isToggled} should be set to false"
+  toggle {_isToggled}
+  assert {_isToggled} is true with "{_isToggled} should be toggled to true"
+  set {_toggle::*} to false, false and false
+  assert {_toggle::1} is false with "{_toggle::1} should be set to false"
+  assert {_toggle::2} is false with "{_toggle::2} should be set to false"
+  assert {_toggle::3} is false with "{_toggle::3} should be set to false"
+  toggle {_toggle::*}
+  assert {_toggle::1} is true with "{_toggle::1} should be toggled to true"
+  assert {_toggle::2} is true with "{_toggle::2} should be toggled to true"
+  assert {_toggle::3} is true with "{_toggle::3} should be toggled to true"
+  assert inverse of {_isToggled} is false with "{_isToggled} should be toggled to false"
+
+  set {_block} to block at location(10, 10, 10, world "world")
+  set {_list::*} to true and {_block}
+  toggle {_list::*}
+  assert {_list::1} is false with "{_list::1} should be set to false"
+  assert amount of {_list::*} is 2 with "{_list::*} should be set to false and {_block}"
+
+  set block at location(10, 11, 10, world "world") to birch door
+  set {_door} to block at location(10, 11, 10, world "world")
+  assert {_door} is birch door with "{_door} should be birch door"
+  assert "%block data of {_door}%" contains "open=false"  with "{_door} should be closed"
+  toggle {_door}
+  assert "%block data of {_door}%" contains "open=true" with "{_door} should be open"
+
+  set {_list::myFirstIndex::myFirstValue} to "hello"
+  set {_list::mySecondIndex::mySecondValue} to "world"
+  set {_list::myThirdIndex::myThirdValue} to false
+  toggle {_list::*}
+  assert {_list::myFirstIndex::myFirstValue} is "hello" with "{_list::myFirstIndex::myFirstValue} should be toggled to 'hello'"
+  assert {_list::mySecondIndex::mySecondValue} is "world" with "{_list::mySecondIndex::mySecondValue} should be toggled to 'world'"
+  assert {_list::myThirdIndex::myThirdValue} is true with "{_list::myThirdIndex::myThirdValue} should be toggled to true"