diff --git a/src/main/java/de/blazemcworld/fireflow/code/node/NodeList.java b/src/main/java/de/blazemcworld/fireflow/code/node/NodeList.java index 5556f4b..ab10b9f 100644 --- a/src/main/java/de/blazemcworld/fireflow/code/node/NodeList.java +++ b/src/main/java/de/blazemcworld/fireflow/code/node/NodeList.java @@ -16,6 +16,10 @@ import de.blazemcworld.fireflow.code.node.impl.item.*; import de.blazemcworld.fireflow.code.node.impl.list.*; import de.blazemcworld.fireflow.code.node.impl.number.*; +import de.blazemcworld.fireflow.code.node.impl.number.constants.EulersNode; +import de.blazemcworld.fireflow.code.node.impl.number.constants.GoldenRatioNode; +import de.blazemcworld.fireflow.code.node.impl.number.constants.PiNode; +import de.blazemcworld.fireflow.code.node.impl.number.constants.TauNode; import de.blazemcworld.fireflow.code.node.impl.player.gameplay.*; import de.blazemcworld.fireflow.code.node.impl.player.inventory.*; import de.blazemcworld.fireflow.code.node.impl.player.meta.*; @@ -164,15 +168,28 @@ public static void init() { .add(new TrimListNode<>(null)) ) .add(new Category("Number", Material.CLOCK) + .add(new Category("Math Constants", Material.TARGET) + .add(new EulersNode()) + .add(new GoldenRatioNode()) + .add(new PiNode()) + .add(new TauNode()) + ) .add(new AbsoluteNumberNode()) .add(new AddNumbersNode()) + .add(new ArcTan2Node()) + .add(new AverageNumberNode()) .add(new BasicNoiseNode()) .add(new ClampNumberNode()) + .add(new CosineNode()) .add(new DivideNumbersNode()) + .add(new GaussianDistributionNode()) .add(new GreaterEqualNode()) .add(new GreaterThanNode()) + .add(new LerpNumbersNode()) .add(new LessEqualNode()) .add(new LessThanNode()) + .add(new MaxNumberNode()) + .add(new MinNumberNode()) .add(new ModuloNode()) .add(new MultiplyNumbersNode()) .add(new ParseNumberNode()) @@ -180,13 +197,16 @@ public static void init() { .add(new RemainderNode()) .add(new RoundNumberNode()) .add(new SetToExponentialNode()) + .add(new SineNode()) .add(new SquareRootNode()) .add(new SubtractNumbersNode()) + .add(new TangentNode()) ) .add(new Category("Player", Material.PLAYER_HEAD) .add(new Category("Gameplay", Material.GRASS_BLOCK) .add(new ClearPlayerEffectsNode()) .add(new DamagePlayerNode()) + .add(new GetPlayerInputNode()) .add(new GivePlayerEffectNode()) .add(new IsPlayerInvulnerableNode()) .add(new KillPlayerNode()) @@ -207,6 +227,7 @@ public static void init() { .add(new PlayerHasItemNode()) .add(new PlayerItemHasCooldownNode()) .add(new SetHeldSlotNode()) + .add(new SetPlayerArmorNode()) .add(new SetPlayerInventoryNode()) .add(new SetPlayerInventorySlotNode()) .add(new SetPlayerItemCooldownNode()) @@ -215,6 +236,7 @@ public static void init() { ) .add(new Category("Meta", Material.COMMAND_BLOCK) .add(new GetPlayerNameNode()) + .add(new GetPlayerPingNode()) .add(new GetPlayerUUIDNode()) .add(new IsPlayingNode()) .add(new KickPlayerNode()) @@ -254,6 +276,7 @@ public static void init() { .add(new SendMessageNode()) .add(new SendTitleNode()) .add(new SetPlayerSkinNode()) + .add(new SetTablistNode()) ) ) .add(new Category("Position", Material.COMPASS) @@ -291,7 +314,9 @@ public static void init() { ) .add(new Category("Vector", Material.ARROW) .add(new AddVectorsNode()) + .add(new DotProductNode()) .add(new GetVectorComponentNode()) + .add(new GetVectorLengthNode()) .add(new PackVectorNode()) .add(new ReflectVectorNode()) .add(new RoundVectorAxesNode()) diff --git a/src/main/java/de/blazemcworld/fireflow/code/node/impl/number/ArcTan2Node.java b/src/main/java/de/blazemcworld/fireflow/code/node/impl/number/ArcTan2Node.java new file mode 100644 index 0000000..3934a9b --- /dev/null +++ b/src/main/java/de/blazemcworld/fireflow/code/node/impl/number/ArcTan2Node.java @@ -0,0 +1,31 @@ +package de.blazemcworld.fireflow.code.node.impl.number; + +import de.blazemcworld.fireflow.code.node.Node; +import de.blazemcworld.fireflow.code.type.NumberType; +import de.blazemcworld.fireflow.code.type.StringType; +import org.bukkit.Material; + +public class ArcTan2Node extends Node { + public ArcTan2Node() { + super("arc_tan_2", "Arc Tangent 2", "Generates the arc tangent of 2 numbers.", Material.FIRE_CORAL_FAN); + Input left = new Input<>("left", "Left", NumberType.INSTANCE); + Input right = new Input<>("right", "Right", NumberType.INSTANCE); + Input inputUnit = new Input<>("input_unit", "Input Unit", StringType.INSTANCE).options("Degrees","Radians"); + Output result = new Output<>("result", "Result", NumberType.INSTANCE); + + result.valueFrom((ctx) -> { + double leftInput = left.getValue(ctx); + double rightInput = right.getValue(ctx); + if(inputUnit.getValue(ctx).equals("Degrees")) { + return Math.toDegrees(Math.atan2(leftInput, rightInput)); + } else { + return Math.atan2(leftInput, rightInput); + } + }); + } + + @Override + public Node copy() { + return new ArcTan2Node(); + } +} \ No newline at end of file diff --git a/src/main/java/de/blazemcworld/fireflow/code/node/impl/number/AverageNumberNode.java b/src/main/java/de/blazemcworld/fireflow/code/node/impl/number/AverageNumberNode.java new file mode 100644 index 0000000..ed5412c --- /dev/null +++ b/src/main/java/de/blazemcworld/fireflow/code/node/impl/number/AverageNumberNode.java @@ -0,0 +1,29 @@ +package de.blazemcworld.fireflow.code.node.impl.number; + +import de.blazemcworld.fireflow.code.node.Node; +import de.blazemcworld.fireflow.code.type.NumberType; +import org.bukkit.Material; + +public class AverageNumberNode extends Node { + + public AverageNumberNode() { + super("average_number", "Average Number", "Returns the average number of a set.", Material.RAW_COPPER); + + Varargs numbers = new Varargs<>("numbers", "Numbers", NumberType.INSTANCE); + Output result = new Output<>("result", "Result", NumberType.INSTANCE); + + result.valueFrom((ctx) -> { + return numbers.getVarargs(ctx) + .stream() + .mapToDouble(Double::doubleValue) + .average() + .orElse(0.0); + }); + } + + @Override + public Node copy() { + return new AverageNumberNode(); + } + +} diff --git a/src/main/java/de/blazemcworld/fireflow/code/node/impl/number/CosineNode.java b/src/main/java/de/blazemcworld/fireflow/code/node/impl/number/CosineNode.java new file mode 100644 index 0000000..c2d0d1e --- /dev/null +++ b/src/main/java/de/blazemcworld/fireflow/code/node/impl/number/CosineNode.java @@ -0,0 +1,47 @@ +package de.blazemcworld.fireflow.code.node.impl.number; + +import de.blazemcworld.fireflow.code.node.Node; +import de.blazemcworld.fireflow.code.type.NumberType; +import de.blazemcworld.fireflow.code.type.StringType; +import org.bukkit.Material; + +public class CosineNode extends Node { + public CosineNode() { + super("cosine", "Cosine", "Generates the trigonometric cosine function of a number.", Material.BUBBLE_CORAL_FAN); + Input value = new Input<>("value", "Value", NumberType.INSTANCE); + Input mode = new Input<>("mode", "Mode", StringType.INSTANCE).options("cos","cosh","acos"); + Input inputUnit = new Input<>("input_unit", "Input Unit", StringType.INSTANCE).options("Degrees","Radians"); + Output result = new Output<>("result", "Result", NumberType.INSTANCE); + + result.valueFrom((ctx) -> { + double valueInput = value.getValue(ctx); + switch (mode.getValue(ctx)) { + case "cos" -> { + if (inputUnit.getValue(ctx).equals("Degrees")) { + return Math.cos(Math.toRadians(valueInput)); + } else { + return Math.cos(valueInput); + } + } + case "acos" -> { + if (inputUnit.getValue(ctx).equals("Degrees")) { + return Math.toDegrees(Math.acos(valueInput)); + } else { + return Math.acos(valueInput); + } + } + case "cosh" -> { + return Math.cosh(valueInput); + } + default -> { + return 0.0; + } + } + }); + } + + @Override + public Node copy() { + return new CosineNode(); + } +} \ No newline at end of file diff --git a/src/main/java/de/blazemcworld/fireflow/code/node/impl/number/GaussianDistributionNode.java b/src/main/java/de/blazemcworld/fireflow/code/node/impl/number/GaussianDistributionNode.java new file mode 100644 index 0000000..1a2233c --- /dev/null +++ b/src/main/java/de/blazemcworld/fireflow/code/node/impl/number/GaussianDistributionNode.java @@ -0,0 +1,38 @@ +package de.blazemcworld.fireflow.code.node.impl.number; + +import de.blazemcworld.fireflow.code.node.Node; +import de.blazemcworld.fireflow.code.type.NumberType; +import de.blazemcworld.fireflow.code.type.StringType; +import org.bukkit.Material; + +import java.util.Random; + +public class GaussianDistributionNode extends Node { + + public GaussianDistributionNode() { + super("gaussian_distribution", "Gaussian Distribution", "Generate a normally distributed random number", Material.POLAR_BEAR_SPAWN_EGG); + Input mode = new Input<>("mode", "Mode", StringType.INSTANCE) + .options("Normal", "Folded"); + Input mean = new Input<>("mean", "μ (Mean midpoint)", NumberType.INSTANCE); + Input deviation = new Input<>("max", "σ (Standard deviation)", NumberType.INSTANCE); + Output output = new Output<>("output", "Output", NumberType.INSTANCE); + + output.valueFrom((ctx -> { + Random random = new Random(); + double outputMean = mean.getValue(ctx); + double outputDeviation = deviation.getValue(ctx); + + return switch (mode.getValue(ctx)) { + case "Normal" -> outputMean + outputDeviation * random.nextGaussian(); + case "Folded" -> outputMean + outputDeviation * Math.abs(random.nextGaussian()); + + default -> 0.0; + }; + })); + } + + @Override + public Node copy() { + return new GaussianDistributionNode(); + } +} \ No newline at end of file diff --git a/src/main/java/de/blazemcworld/fireflow/code/node/impl/number/LerpNumbersNode.java b/src/main/java/de/blazemcworld/fireflow/code/node/impl/number/LerpNumbersNode.java new file mode 100644 index 0000000..3ae8382 --- /dev/null +++ b/src/main/java/de/blazemcworld/fireflow/code/node/impl/number/LerpNumbersNode.java @@ -0,0 +1,29 @@ +package de.blazemcworld.fireflow.code.node.impl.number; + +import de.blazemcworld.fireflow.code.node.Node; +import de.blazemcworld.fireflow.code.type.NumberType; +import org.bukkit.Material; + +public class LerpNumbersNode extends Node { + + public LerpNumbersNode() { + super("lerp_numbers", "Lerp", "Calculates a value between two inputs by linearly interpolating based on a factor t, where t = 0 returns the start value, t = 1 returns the end value, and values in between produce a proportional blend.", Material.REPEATER); + + Input left = new Input<>("left", "Left", NumberType.INSTANCE); + Input right = new Input<>("right", "Right", NumberType.INSTANCE); + Input time = new Input<>("time", "Time (0-1)", NumberType.INSTANCE); + Output result = new Output<>("result", "Result", NumberType.INSTANCE); + + result.valueFrom((ctx) -> { + double leftValue = left.getValue(ctx); + double rightValue = right.getValue(ctx); + double timeValue = Math.clamp(time.getValue(ctx),0,1); + return leftValue + (rightValue - leftValue) * timeValue; + }); + } + + @Override + public Node copy() { + return new LerpNumbersNode(); + } +} diff --git a/src/main/java/de/blazemcworld/fireflow/code/node/impl/number/MaxNumberNode.java b/src/main/java/de/blazemcworld/fireflow/code/node/impl/number/MaxNumberNode.java new file mode 100644 index 0000000..7f207c5 --- /dev/null +++ b/src/main/java/de/blazemcworld/fireflow/code/node/impl/number/MaxNumberNode.java @@ -0,0 +1,28 @@ +package de.blazemcworld.fireflow.code.node.impl.number; + +import de.blazemcworld.fireflow.code.node.Node; +import de.blazemcworld.fireflow.code.type.NumberType; +import org.bukkit.Material; + +public class MaxNumberNode extends Node { + + public MaxNumberNode() { + super("max_number", "Maximum Number", "Returns the highest number in a set.", Material.NETHERITE_SCRAP); + + Varargs numbers = new Varargs<>("numbers", "Numbers", NumberType.INSTANCE); + Output result = new Output<>("result", "Result", NumberType.INSTANCE); + + result.valueFrom((ctx) -> { + return numbers.getVarargs(ctx) + .stream() + .max(Double::compareTo) + .orElse(0.0); + }); + } + + @Override + public Node copy() { + return new MaxNumberNode(); + } + +} diff --git a/src/main/java/de/blazemcworld/fireflow/code/node/impl/number/MinNumberNode.java b/src/main/java/de/blazemcworld/fireflow/code/node/impl/number/MinNumberNode.java new file mode 100644 index 0000000..a5b89c0 --- /dev/null +++ b/src/main/java/de/blazemcworld/fireflow/code/node/impl/number/MinNumberNode.java @@ -0,0 +1,28 @@ +package de.blazemcworld.fireflow.code.node.impl.number; + +import de.blazemcworld.fireflow.code.node.Node; +import de.blazemcworld.fireflow.code.type.NumberType; +import org.bukkit.Material; + +public class MinNumberNode extends Node { + + public MinNumberNode() { + super("min_number", "Minimum Number", "Returns the lowest number in a set.", Material.DISC_FRAGMENT_5); + + Varargs numbers = new Varargs<>("numbers", "Numbers", NumberType.INSTANCE); + Output result = new Output<>("result", "Result", NumberType.INSTANCE); + + result.valueFrom((ctx) -> { + return numbers.getVarargs(ctx) + .stream() + .min(Double::compareTo) + .orElse(0.0); + }); + } + + @Override + public Node copy() { + return new MinNumberNode(); + } + +} diff --git a/src/main/java/de/blazemcworld/fireflow/code/node/impl/number/SineNode.java b/src/main/java/de/blazemcworld/fireflow/code/node/impl/number/SineNode.java new file mode 100644 index 0000000..786e972 --- /dev/null +++ b/src/main/java/de/blazemcworld/fireflow/code/node/impl/number/SineNode.java @@ -0,0 +1,47 @@ +package de.blazemcworld.fireflow.code.node.impl.number; + +import de.blazemcworld.fireflow.code.node.Node; +import de.blazemcworld.fireflow.code.type.NumberType; +import de.blazemcworld.fireflow.code.type.StringType; +import org.bukkit.Material; + +public class SineNode extends Node { + public SineNode() { + super("sine", "Sine", "Generates the trigonometric sine function of a number.", Material.TUBE_CORAL_FAN); + Input value = new Input<>("value", "Value", NumberType.INSTANCE); + Input mode = new Input<>("mode", "Mode", StringType.INSTANCE).options("sin","sinh","asin"); + Input inputUnit = new Input<>("input_unit", "Input Unit", StringType.INSTANCE).options("Degrees","Radians"); + Output result = new Output<>("result", "Result", NumberType.INSTANCE); + + result.valueFrom((ctx) -> { + double valueInput = value.getValue(ctx); + switch (mode.getValue(ctx)) { + case "sin" -> { + if (inputUnit.getValue(ctx).equals("Degrees")) { + return Math.sin(Math.toRadians(valueInput)); + } else { + return Math.sin(valueInput); + } + } + case "asin" -> { + if (inputUnit.getValue(ctx).equals("Degrees")) { + return Math.toDegrees(Math.asin(valueInput)); + } else { + return Math.asin(valueInput); + } + } + case "sinh" -> { + return Math.sinh(valueInput); + } + default -> { + return 0.0; + } + } + }); + } + + @Override + public Node copy() { + return new SineNode(); + } +} \ No newline at end of file diff --git a/src/main/java/de/blazemcworld/fireflow/code/node/impl/number/TangentNode.java b/src/main/java/de/blazemcworld/fireflow/code/node/impl/number/TangentNode.java new file mode 100644 index 0000000..1309e8a --- /dev/null +++ b/src/main/java/de/blazemcworld/fireflow/code/node/impl/number/TangentNode.java @@ -0,0 +1,47 @@ +package de.blazemcworld.fireflow.code.node.impl.number; + +import de.blazemcworld.fireflow.code.node.Node; +import de.blazemcworld.fireflow.code.type.NumberType; +import de.blazemcworld.fireflow.code.type.StringType; +import org.bukkit.Material; + +public class TangentNode extends Node { + public TangentNode() { + super("tangent", "Tangent", "Generates the trigonometric tangent function of a number.", Material.HORN_CORAL_FAN); + Input value = new Input<>("value", "Value", NumberType.INSTANCE); + Input mode = new Input<>("mode", "Mode", StringType.INSTANCE).options("tan","tanh","atan"); + Input inputUnit = new Input<>("input_unit", "Input Unit", StringType.INSTANCE).options("Degrees","Radians"); + Output result = new Output<>("result", "Result", NumberType.INSTANCE); + + result.valueFrom((ctx) -> { + double valueInput = value.getValue(ctx); + switch (mode.getValue(ctx)) { + case "tan" -> { + if (inputUnit.getValue(ctx).equals("Degrees")) { + return Math.tan(Math.toRadians(valueInput)); + } else { + return Math.tan(valueInput); + } + } + case "atan" -> { + if (inputUnit.getValue(ctx).equals("Degrees")) { + return Math.toDegrees(Math.atan(valueInput)); + } else { + return Math.atan(valueInput); + } + } + case "tanh" -> { + return Math.tanh(valueInput); + } + default -> { + return 0.0; + } + } + }); + } + + @Override + public Node copy() { + return new TangentNode(); + } +} \ No newline at end of file diff --git a/src/main/java/de/blazemcworld/fireflow/code/node/impl/number/constants/EulersNode.java b/src/main/java/de/blazemcworld/fireflow/code/node/impl/number/constants/EulersNode.java new file mode 100644 index 0000000..7884f4c --- /dev/null +++ b/src/main/java/de/blazemcworld/fireflow/code/node/impl/number/constants/EulersNode.java @@ -0,0 +1,21 @@ +package de.blazemcworld.fireflow.code.node.impl.number.constants; + +import de.blazemcworld.fireflow.code.node.Node; +import de.blazemcworld.fireflow.code.type.NumberType; +import org.bukkit.Material; + +public class EulersNode extends Node { + + public EulersNode() { + super("eulers", "Euler's (e)", "Returns Euler's number.", Material.SPECTRAL_ARROW); + + Output value = new Output<>("value", "Value", NumberType.INSTANCE); + value.valueFrom(ctx -> Math.E); + } + + @Override + public Node copy() { + return new EulersNode(); + } + +} diff --git a/src/main/java/de/blazemcworld/fireflow/code/node/impl/number/constants/GoldenRatioNode.java b/src/main/java/de/blazemcworld/fireflow/code/node/impl/number/constants/GoldenRatioNode.java new file mode 100644 index 0000000..f75f473 --- /dev/null +++ b/src/main/java/de/blazemcworld/fireflow/code/node/impl/number/constants/GoldenRatioNode.java @@ -0,0 +1,21 @@ +package de.blazemcworld.fireflow.code.node.impl.number.constants; + +import de.blazemcworld.fireflow.code.node.Node; +import de.blazemcworld.fireflow.code.type.NumberType; +import org.bukkit.Material; + +public class GoldenRatioNode extends Node { + + public GoldenRatioNode() { + super("golden_ratio", "Golden Ratio (Φ)", "Returns the Golden Ratio.", Material.GOLD_NUGGET); + + Output value = new Output<>("value", "Value", NumberType.INSTANCE); + value.valueFrom(ctx -> (1 + Math.sqrt(5)) / 2); + } + + @Override + public Node copy() { + return new GoldenRatioNode(); + } + +} diff --git a/src/main/java/de/blazemcworld/fireflow/code/node/impl/number/constants/PiNode.java b/src/main/java/de/blazemcworld/fireflow/code/node/impl/number/constants/PiNode.java new file mode 100644 index 0000000..c09172f --- /dev/null +++ b/src/main/java/de/blazemcworld/fireflow/code/node/impl/number/constants/PiNode.java @@ -0,0 +1,21 @@ +package de.blazemcworld.fireflow.code.node.impl.number.constants; + +import de.blazemcworld.fireflow.code.node.Node; +import de.blazemcworld.fireflow.code.type.NumberType; +import org.bukkit.Material; + +public class PiNode extends Node { + + public PiNode() { + super("pi", "Pi (π)", "Returns PI.", Material.SNOWBALL); + + Output value = new Output<>("value", "Value", NumberType.INSTANCE); + value.valueFrom(ctx -> Math.PI); + } + + @Override + public Node copy() { + return new PiNode(); + } + +} diff --git a/src/main/java/de/blazemcworld/fireflow/code/node/impl/number/constants/TauNode.java b/src/main/java/de/blazemcworld/fireflow/code/node/impl/number/constants/TauNode.java new file mode 100644 index 0000000..0a7c6d4 --- /dev/null +++ b/src/main/java/de/blazemcworld/fireflow/code/node/impl/number/constants/TauNode.java @@ -0,0 +1,21 @@ +package de.blazemcworld.fireflow.code.node.impl.number.constants; + +import de.blazemcworld.fireflow.code.node.Node; +import de.blazemcworld.fireflow.code.type.NumberType; +import org.bukkit.Material; + +public class TauNode extends Node { + + public TauNode() { + super("tau", "Tau (τ)", "Returns TAU.", Material.SNOW_BLOCK); + + Output value = new Output<>("value", "Value", NumberType.INSTANCE); + value.valueFrom(ctx -> Math.TAU); + } + + @Override + public Node copy() { + return new TauNode(); + } + +} diff --git a/src/main/java/de/blazemcworld/fireflow/code/node/impl/player/gameplay/GetPlayerInputNode.java b/src/main/java/de/blazemcworld/fireflow/code/node/impl/player/gameplay/GetPlayerInputNode.java new file mode 100644 index 0000000..181f563 --- /dev/null +++ b/src/main/java/de/blazemcworld/fireflow/code/node/impl/player/gameplay/GetPlayerInputNode.java @@ -0,0 +1,41 @@ +package de.blazemcworld.fireflow.code.node.impl.player.gameplay; + +import de.blazemcworld.fireflow.code.node.Node; +import de.blazemcworld.fireflow.code.type.ConditionType; +import de.blazemcworld.fireflow.code.type.PlayerType; +import de.blazemcworld.fireflow.code.type.SignalType; +import de.blazemcworld.fireflow.code.type.StringType; +import de.blazemcworld.fireflow.code.value.PlayerValue; +import org.bukkit.GameMode; +import org.bukkit.Material; + +public class GetPlayerInputNode extends Node { + public GetPlayerInputNode() { + super("get_player_input", "Get Player Input", "Gets if a player is pressing a specific key", Material.OMINOUS_TRIAL_KEY); + + Input player = new Input<>("player", "Player", PlayerType.INSTANCE); + Input key = new Input<>("key", "Key", StringType.INSTANCE) + .options("Forward", "Backward", "Right", "Left", "Jump", "Sneak", "Sprint"); + Output pressed = new Output<>("pressed", "Pressed", ConditionType.INSTANCE); + + pressed.valueFrom(ctx -> player.getValue(ctx).tryGet(ctx, p -> { + return switch(key.getValue(ctx)) { + case "Forward" -> p.getCurrentInput().isForward(); + case "Backward" -> p.getCurrentInput().isBackward(); + case "Right" -> p.getCurrentInput().isRight(); + case "Left" -> p.getCurrentInput().isLeft(); + case "Jump" -> p.getCurrentInput().isJump(); + case "Sneak" -> p.getCurrentInput().isSneak(); + case "Sprint" -> p.getCurrentInput().isSprint(); + default -> false; + }; + }, false)); + + + } + + @Override + public Node copy() { + return new GetPlayerInputNode(); + } +} \ No newline at end of file diff --git a/src/main/java/de/blazemcworld/fireflow/code/node/impl/player/inventory/SetPlayerArmorNode.java b/src/main/java/de/blazemcworld/fireflow/code/node/impl/player/inventory/SetPlayerArmorNode.java new file mode 100644 index 0000000..f45e8ea --- /dev/null +++ b/src/main/java/de/blazemcworld/fireflow/code/node/impl/player/inventory/SetPlayerArmorNode.java @@ -0,0 +1,49 @@ +package de.blazemcworld.fireflow.code.node.impl.player.inventory; + +import de.blazemcworld.fireflow.code.node.Node; +import de.blazemcworld.fireflow.code.type.*; +import de.blazemcworld.fireflow.code.value.PlayerValue; +import org.bukkit.Material; +import org.bukkit.inventory.ItemStack; + + +public class SetPlayerArmorNode extends Node { + + public SetPlayerArmorNode() { + super("set_player_armor", "Set Player Armor", "Changes the armor of a player", Material.DIAMOND_LEGGINGS); + + Input signal = new Input<>("signal", "Signal", SignalType.INSTANCE); + Input player = new Input<>("player", "Player", PlayerType.INSTANCE); + Input head = new Input<>("head", "Head", ItemType.INSTANCE); + Input chest = new Input<>("chest", "Chest", ItemType.INSTANCE); + Input legs = new Input<>("legs", "Legs", ItemType.INSTANCE); + Input feet = new Input<>("feet", "Feet", ItemType.INSTANCE); + Input behaviour = new Input<>("behaviour", "Behaviour", StringType.INSTANCE) + .options("Clear", "Merge"); + Output next = new Output<>("next", "Next", SignalType.INSTANCE); + + signal.onSignal((ctx) -> { + player.getValue(ctx).tryUse(ctx, p -> { + boolean clearInv = behaviour.getValue(ctx).equals("Clear"); + ItemStack headItem = head.getValue(ctx); + ItemStack chestItem = chest.getValue(ctx); + ItemStack legsItem = legs.getValue(ctx); + ItemStack feetItem = feet.getValue(ctx); + if (!headItem.isEmpty() || clearInv) p.getInventory().setItem(39, headItem); + if (!chestItem.isEmpty() || clearInv) p.getInventory().setItem(38, chestItem); + if (!legsItem.isEmpty() || clearInv) p.getInventory().setItem(37, legsItem); + if (!feetItem.isEmpty() || clearInv) p.getInventory().setItem(36, feetItem); + }); + ctx.sendSignal(next); + }); + + } + + @Override + public Node copy() { + return new SetPlayerArmorNode(); + } + +} + + diff --git a/src/main/java/de/blazemcworld/fireflow/code/node/impl/player/meta/GetPlayerPingNode.java b/src/main/java/de/blazemcworld/fireflow/code/node/impl/player/meta/GetPlayerPingNode.java new file mode 100644 index 0000000..239e71f --- /dev/null +++ b/src/main/java/de/blazemcworld/fireflow/code/node/impl/player/meta/GetPlayerPingNode.java @@ -0,0 +1,24 @@ +package de.blazemcworld.fireflow.code.node.impl.player.meta; + +import de.blazemcworld.fireflow.code.node.Node; +import de.blazemcworld.fireflow.code.type.NumberType; +import de.blazemcworld.fireflow.code.type.PlayerType; +import de.blazemcworld.fireflow.code.value.PlayerValue; +import org.bukkit.Material; +import org.bukkit.entity.Player; + +public class GetPlayerPingNode extends Node { + public GetPlayerPingNode() { + super("get_player_ping", "Get Player Ping", "Gets the ping of a player.", Material.SHAPER_ARMOR_TRIM_SMITHING_TEMPLATE); + + Input player = new Input<>("player", "Player", PlayerType.INSTANCE); + Output ping = new Output<>("ping", "Ping", NumberType.INSTANCE); + + ping.valueFrom(ctx -> (double) player.getValue(ctx).tryGet(ctx, Player::getPing, 0)); + } + + @Override + public Node copy() { + return new GetPlayerPingNode(); + } +} \ No newline at end of file diff --git a/src/main/java/de/blazemcworld/fireflow/code/node/impl/player/visual/SendActionbarNode.java b/src/main/java/de/blazemcworld/fireflow/code/node/impl/player/visual/SendActionbarNode.java index 8e9845c..9e4f88d 100644 --- a/src/main/java/de/blazemcworld/fireflow/code/node/impl/player/visual/SendActionbarNode.java +++ b/src/main/java/de/blazemcworld/fireflow/code/node/impl/player/visual/SendActionbarNode.java @@ -20,7 +20,7 @@ public SendActionbarNode() { Output next = new Output<>("next", "Next", SignalType.INSTANCE); signal.onSignal((ctx) -> { - player.getValue(ctx).tryUse(ctx, p -> p.sendMessage(message.getValue(ctx))); + player.getValue(ctx).tryUse(ctx, p -> p.sendActionBar(message.getValue(ctx))); ctx.sendSignal(next); }); } diff --git a/src/main/java/de/blazemcworld/fireflow/code/node/impl/player/visual/SetTablistNode.java b/src/main/java/de/blazemcworld/fireflow/code/node/impl/player/visual/SetTablistNode.java new file mode 100644 index 0000000..c5b51cf --- /dev/null +++ b/src/main/java/de/blazemcworld/fireflow/code/node/impl/player/visual/SetTablistNode.java @@ -0,0 +1,36 @@ +package de.blazemcworld.fireflow.code.node.impl.player.visual; + +import de.blazemcworld.fireflow.code.node.Node; +import de.blazemcworld.fireflow.code.type.PlayerType; +import de.blazemcworld.fireflow.code.type.SignalType; +import de.blazemcworld.fireflow.code.type.TextType; +import de.blazemcworld.fireflow.code.value.PlayerValue; +import net.kyori.adventure.text.Component; +import org.bukkit.Material; + +public class SetTablistNode extends Node { + + public SetTablistNode() { + super("set_tablist", "Set Tablist", "Sets a tablist for a player", Material.OBSERVER); + + Input signal = new Input<>("signal", "Signal", SignalType.INSTANCE); + Input player = new Input<>("player", "Player", PlayerType.INSTANCE); + Input header = new Input<>("header", "Header", TextType.INSTANCE); + Input footer = new Input<>("footer", "Footer", TextType.INSTANCE); + + Output next = new Output<>("next", "Next", SignalType.INSTANCE); + + signal.onSignal((ctx) -> { + player.getValue(ctx).tryUse(ctx, p -> { + p.sendPlayerListHeader(header.getValue(ctx)); + p.sendPlayerListFooter(footer.getValue(ctx)); + }); + ctx.sendSignal(next); + }); + } + + @Override + public Node copy() { + return new SetTablistNode(); + } +} diff --git a/src/main/java/de/blazemcworld/fireflow/code/node/impl/vector/DotProductNode.java b/src/main/java/de/blazemcworld/fireflow/code/node/impl/vector/DotProductNode.java new file mode 100644 index 0000000..9c60a32 --- /dev/null +++ b/src/main/java/de/blazemcworld/fireflow/code/node/impl/vector/DotProductNode.java @@ -0,0 +1,25 @@ +package de.blazemcworld.fireflow.code.node.impl.vector; + +import de.blazemcworld.fireflow.code.node.Node; +import de.blazemcworld.fireflow.code.type.NumberType; +import de.blazemcworld.fireflow.code.type.VectorType; +import org.bukkit.Material; +import org.bukkit.util.Vector; + +public class DotProductNode extends Node { + + public DotProductNode() { + super("dot_product", "Dot Product", "Gets the Dot Product of two vectors", Material.GUNPOWDER); + + Input first = new Input<>("first", "First", VectorType.INSTANCE); + Input second = new Input<>("second", "Second", VectorType.INSTANCE); + Output result = new Output<>("result", "Result", NumberType.INSTANCE); + + result.valueFrom(ctx -> first.getValue(ctx).dot(second.getValue(ctx))); + } + + @Override + public Node copy() { + return new DotProductNode(); + } +} diff --git a/src/main/java/de/blazemcworld/fireflow/code/node/impl/vector/GetVectorLengthNode.java b/src/main/java/de/blazemcworld/fireflow/code/node/impl/vector/GetVectorLengthNode.java new file mode 100644 index 0000000..f5e4785 --- /dev/null +++ b/src/main/java/de/blazemcworld/fireflow/code/node/impl/vector/GetVectorLengthNode.java @@ -0,0 +1,37 @@ +package de.blazemcworld.fireflow.code.node.impl.vector; + +import de.blazemcworld.fireflow.code.node.Node; +import de.blazemcworld.fireflow.code.type.NumberType; +import de.blazemcworld.fireflow.code.type.StringType; +import de.blazemcworld.fireflow.code.type.VectorType; +import org.bukkit.Material; +import org.bukkit.util.Vector; + +public class GetVectorLengthNode extends Node { + public GetVectorLengthNode() { + super("get_vector_length", "Get Vector Length", "Gets the length of a vector", Material.BREEZE_ROD); + Input vector = new Input<>("vector", "Vector", VectorType.INSTANCE); + Input lengthType = new Input<>("length_type", "Length Type", StringType.INSTANCE).options("Normal","Squared"); + Output length = new Output<>("length", "Length", NumberType.INSTANCE); + + length.valueFrom(ctx -> { + Vector v = vector.getValue(ctx); + switch(lengthType.getValue(ctx)) { + case "Normal" -> { + return v.length(); + } + case "Squared" -> { + return v.lengthSquared(); + } + default -> { + return 0.0; + } + } + }); + } + + @Override + public Node copy() { + return new GetVectorLengthNode(); + } +} diff --git a/src/main/java/de/blazemcworld/fireflow/code/node/impl/world/TimestampNode.java b/src/main/java/de/blazemcworld/fireflow/code/node/impl/world/TimestampNode.java new file mode 100644 index 0000000..96db25f --- /dev/null +++ b/src/main/java/de/blazemcworld/fireflow/code/node/impl/world/TimestampNode.java @@ -0,0 +1,21 @@ +package de.blazemcworld.fireflow.code.node.impl.world; + +import de.blazemcworld.fireflow.code.node.Node; +import de.blazemcworld.fireflow.code.type.NumberType; +import org.bukkit.Material; + +public class TimestampNode extends Node { + + public TimestampNode() { + super("timestamp", "Timestamp", "Returns the elapsed seconds since the Unix epoch.", Material.CLOCK); + + Output usage = new Output<>("timestamp", "Timestamp", NumberType.INSTANCE); + usage.valueFrom(ctx -> (double) System.currentTimeMillis() / 1000); + } + + @Override + public Node copy() { + return new TimestampNode(); + } + +} diff --git a/src/main/java/de/blazemcworld/fireflow/code/widget/NodeMenuWidget.java b/src/main/java/de/blazemcworld/fireflow/code/widget/NodeMenuWidget.java index b310df9..ff80f51 100644 --- a/src/main/java/de/blazemcworld/fireflow/code/widget/NodeMenuWidget.java +++ b/src/main/java/de/blazemcworld/fireflow/code/widget/NodeMenuWidget.java @@ -61,7 +61,7 @@ public NodeMenuWidget(WidgetVec pos, NodeList.Category category, List { if (interaction.type() != CodeInteraction.Type.RIGHT_CLICK) return false; diff --git a/src/main/java/de/blazemcworld/fireflow/util/Statistics.java b/src/main/java/de/blazemcworld/fireflow/util/Statistics.java index ace1d52..c035a43 100644 --- a/src/main/java/de/blazemcworld/fireflow/util/Statistics.java +++ b/src/main/java/de/blazemcworld/fireflow/util/Statistics.java @@ -1,9 +1,13 @@ package de.blazemcworld.fireflow.util; +import net.kyori.adventure.text.Component; +import org.bukkit.Bukkit; import org.bukkit.GameMode; import org.bukkit.entity.Player; import org.bukkit.event.inventory.InventoryType; +import java.util.Objects; + public class Statistics { public static void reset(Player player) { @@ -25,6 +29,8 @@ public static void reset(Player player) { player.setLastDeathLocation(null); player.setInvulnerable(false); player.setInvisible(false); + player.sendPlayerListHeader(Component.empty()); + player.sendPlayerListFooter(Component.empty()); } }