From bd02dea022b4be3723be8f4c5ed388dd70b05afc Mon Sep 17 00:00:00 2001 From: RevolvingMadness Date: Wed, 14 Feb 2024 18:53:30 -0600 Subject: [PATCH] Rename events --- CHANGELOG.md | 11 +++ .../sculk/language/EventHolder.java | 70 +++++++++---------- .../builtins/classes/BuiltinClass.java | 20 ------ .../builtins/classes/types/EventsType.java | 20 +++--- .../builtins/functions/PrintFunction.java | 2 +- .../language/interpreter/Interpreter.java | 13 ++-- .../language/interpreter/VariableTable.java | 6 +- 7 files changed, 69 insertions(+), 73 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 3667082..62f87a0 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -85,6 +85,7 @@ - function arguments have required types - methods have required return types - method arguments have required types +- `ItemStack.item` ### Changed @@ -96,6 +97,16 @@ - `Entity.removeAllPassengers` -> `Entity.removePassengers` - `ServerPlayerEntity.changeGameMode` -> `ServerPlayerEntity.setGameMode` - Integer now extends Float instead of Float extending Integer +- `Events.onPlayerAttackEntity` -> `Events.onAttackEntity` +- `Events.onPlayerBreakBlock` -> `Events.onBreakBlock` +- `Events.onPlayerCraftItem` -> `Events.onCraftItem` +- `Events.onPlayerDropItem` -> `Events.onDropItem` +- `Events.onPlayerJump` -> `Events.onJump` +- `Events.onPlayerPickupItem` -> `Events.onPickupItem` +- `Events.onPlayerRingBell` -> `Events.onRingBell` +- `Events.onPlayerSneak` -> `Events.whileSneaking` +- `Events.onPlayerUseItem` -> `Events.onRightClickItem` +- `Events.onPlayerSendChatMessage` -> `Events.onSendChatMessage` ### Fixed diff --git a/src/main/java/com/revolvingmadness/sculk/language/EventHolder.java b/src/main/java/com/revolvingmadness/sculk/language/EventHolder.java index 257a6fd..f735978 100644 --- a/src/main/java/com/revolvingmadness/sculk/language/EventHolder.java +++ b/src/main/java/com/revolvingmadness/sculk/language/EventHolder.java @@ -19,41 +19,41 @@ public class EventHolder { public static final List onEntitySleep = new ArrayList<>(); public static final List onPlaceBlock = new ArrayList<>(); - public static final List onPlayerAttackEntity = new ArrayList<>(); - public static final List onPlayerBreakBlock = new ArrayList<>(); - public static final List onPlayerCraftItem = new ArrayList<>(); - public static final List onPlayerDropItem = new ArrayList<>(); - public static final List onPlayerJump = new ArrayList<>(); - public static final List onPlayerPickupItem = new ArrayList<>(); - public static final List onPlayerRingBell = new ArrayList<>(); - public static final List onPlayerSendChatMessage = new ArrayList<>(); - public static final List onPlayerSneak = new ArrayList<>(); - public static final List onPlayerUseItem = new ArrayList<>(); + public static final List onAttackEntity = new ArrayList<>(); + public static final List onBreakBlock = new ArrayList<>(); + public static final List onCraftItem = new ArrayList<>(); + public static final List onDropItem = new ArrayList<>(); + public static final List onJump = new ArrayList<>(); + public static final List onPickupItem = new ArrayList<>(); + public static final List onRingBell = new ArrayList<>(); + public static final List onSendChatMessage = new ArrayList<>(); + public static final List whileSneaking = new ArrayList<>(); + public static final List onRightClickItem = new ArrayList<>(); public static void clearEvents() { EventHolder.onEntitySleep.clear(); EventHolder.onPlaceBlock.clear(); - EventHolder.onPlayerAttackEntity.clear(); - EventHolder.onPlayerBreakBlock.clear(); - EventHolder.onPlayerCraftItem.clear(); - EventHolder.onPlayerDropItem.clear(); - EventHolder.onPlayerJump.clear(); - EventHolder.onPlayerPickupItem.clear(); - EventHolder.onPlayerRingBell.clear(); - EventHolder.onPlayerSendChatMessage.clear(); - EventHolder.onPlayerSneak.clear(); - EventHolder.onPlayerUseItem.clear(); + EventHolder.onAttackEntity.clear(); + EventHolder.onBreakBlock.clear(); + EventHolder.onCraftItem.clear(); + EventHolder.onDropItem.clear(); + EventHolder.onJump.clear(); + EventHolder.onPickupItem.clear(); + EventHolder.onRingBell.clear(); + EventHolder.onSendChatMessage.clear(); + EventHolder.whileSneaking.clear(); + EventHolder.onRightClickItem.clear(); } public static void registerEvents() { AttackEntityCallback.EVENT.register((player, world, hand, entity, hitResult) -> { if (!world.isClient) { try { - for (Event event : EventHolder.onPlayerAttackEntity) { + for (Event event : EventHolder.onAttackEntity) { BuiltinClass eventResultClass = event.execute(List.of(new PlayerEntityInstance(player), new EntityInstance(entity), new ItemStackInstance(player.getStackInHand(hand)))); if (!eventResultClass.instanceOf(BooleanType.TYPE)) { - throw ErrorHolder.functionRequiresReturnType("onPlayerAttackEntity", BooleanType.TYPE, eventResultClass.getType()); + throw ErrorHolder.functionRequiresReturnType("onPlayerAttackEntity", eventResultClass.getType(), BooleanType.TYPE); } boolean eventResult = eventResultClass.toBoolean(); @@ -73,11 +73,11 @@ public static void registerEvents() { PlayerBlockBreakEvents.BEFORE.register((world, player, pos, blockState, blockEntity) -> { if (!player.getWorld().isClient) { try { - for (Event event : EventHolder.onPlayerBreakBlock) { + for (Event event : EventHolder.onBreakBlock) { BuiltinClass eventResultClass = event.execute(List.of(new PlayerEntityInstance(player), new BlockPosInstance(pos), new BlockInstance(world.getBlockState(pos).getBlock()))); if (!eventResultClass.instanceOf(BooleanType.TYPE)) { - throw ErrorHolder.functionRequiresReturnType("onPlayerBreakBlock", BooleanType.TYPE, eventResultClass.getType()); + throw ErrorHolder.functionRequiresReturnType("onPlayerBreakBlock", eventResultClass.getType(), BooleanType.TYPE); } boolean eventResult = eventResultClass.toBoolean(); @@ -97,7 +97,7 @@ public static void registerEvents() { CraftItemCallback.EVENT.register((player, itemStack) -> { if (!player.getWorld().isClient) { try { - for (Event event : EventHolder.onPlayerCraftItem) { + for (Event event : EventHolder.onCraftItem) { event.execute(List.of(new PlayerEntityInstance(player), new ItemStackInstance(itemStack))); } } catch (Error error) { @@ -111,7 +111,7 @@ public static void registerEvents() { DropItemCallback.EVENT.register((player, itemStack) -> { if (!player.getWorld().isClient) { try { - for (Event event : EventHolder.onPlayerDropItem) { + for (Event event : EventHolder.onDropItem) { event.execute(List.of(new PlayerEntityInstance(player), new ItemStackInstance(itemStack))); } } catch (Error error) { @@ -124,7 +124,7 @@ public static void registerEvents() { PlayerJumpCallback.EVENT.register((player) -> { try { - for (Event event : EventHolder.onPlayerJump) { + for (Event event : EventHolder.onJump) { event.execute(List.of(new PlayerEntityInstance(player))); } } catch (Error error) { @@ -136,11 +136,11 @@ public static void registerEvents() { PickupItemCallback.EVENT.register((player, itemStack) -> { try { - for (Event event : EventHolder.onPlayerPickupItem) { + for (Event event : EventHolder.onPickupItem) { BuiltinClass eventResultClass = event.execute(List.of(new PlayerEntityInstance(player), new ItemStackInstance(itemStack))); if (!eventResultClass.instanceOf(BooleanType.TYPE)) { - throw ErrorHolder.functionRequiresReturnType("onPlayerPickupItem", BooleanType.TYPE, eventResultClass.getType()); + throw ErrorHolder.functionRequiresReturnType("onPlayerPickupItem", eventResultClass.getType(), BooleanType.TYPE); } boolean eventResult = eventResultClass.toBoolean(); @@ -182,7 +182,7 @@ public static void registerEvents() { PlayerRingBellCallback.EVENT.register((player) -> { try { - for (Event event : EventHolder.onPlayerRingBell) { + for (Event event : EventHolder.onRingBell) { event.execute(List.of(new PlayerEntityInstance(player))); } } catch (Error error) { @@ -194,11 +194,11 @@ public static void registerEvents() { SendChatMessageCallback.EVENT.register((player, message) -> { try { - for (Event event : EventHolder.onPlayerSendChatMessage) { + for (Event event : EventHolder.onSendChatMessage) { BuiltinClass eventResultClass = event.execute(List.of(new ServerPlayerEntityInstance(player), new StringInstance(message.content().getString()))); if (!eventResultClass.instanceOf(BooleanType.TYPE)) { - throw ErrorHolder.functionRequiresReturnType("onPlayerSendChatMessage", BooleanType.TYPE, eventResultClass.getType()); + throw ErrorHolder.functionRequiresReturnType("onPlayerSendChatMessage", eventResultClass.getType(), BooleanType.TYPE); } boolean eventResult = eventResultClass.toBoolean(); @@ -217,11 +217,11 @@ public static void registerEvents() { UseItemCallback.EVENT.register((player, world, hand) -> { if (!world.isClient) { try { - for (Event event : EventHolder.onPlayerUseItem) { + for (Event event : EventHolder.onRightClickItem) { BuiltinClass eventResultClass = event.execute(List.of(new PlayerEntityInstance(player), new ItemStackInstance(player.getStackInHand(hand)))); if (!eventResultClass.instanceOf(BooleanType.TYPE)) { - throw ErrorHolder.functionRequiresReturnType("onPlayerUseItem", BooleanType.TYPE, eventResultClass.getType()); + throw ErrorHolder.functionRequiresReturnType("onPlayerUseItem", eventResultClass.getType(), BooleanType.TYPE); } boolean eventResult = eventResultClass.toBoolean(); @@ -240,7 +240,7 @@ public static void registerEvents() { PlayerSneakCallback.EVENT.register((player) -> { try { - for (Event event : EventHolder.onPlayerSneak) { + for (Event event : EventHolder.whileSneaking) { event.execute(List.of(new ServerPlayerEntityInstance(player))); } } catch (Error error) { diff --git a/src/main/java/com/revolvingmadness/sculk/language/builtins/classes/BuiltinClass.java b/src/main/java/com/revolvingmadness/sculk/language/builtins/classes/BuiltinClass.java index 1b3c9bf..ae2cd73 100644 --- a/src/main/java/com/revolvingmadness/sculk/language/builtins/classes/BuiltinClass.java +++ b/src/main/java/com/revolvingmadness/sculk/language/builtins/classes/BuiltinClass.java @@ -108,10 +108,6 @@ public BuiltinClass divide(BuiltinClass other) { throw ErrorHolder.cannotApplyBinaryOperatorToTypes("/", this.getType(), other.getType()); } - public BooleanInstance equalToMethod(BuiltinClass other) { - return new BooleanInstance(this.equals(other)); - } - @Override public boolean equals(Object o) { if (this == o) @@ -158,10 +154,6 @@ public BooleanInstance greaterThan(BuiltinClass other) { throw ErrorHolder.cannotApplyBinaryOperatorToTypes(">", this.getType(), other.getType()); } - public BooleanInstance greaterThanOrEqualTo(BuiltinClass other) { - return new BooleanInstance(this.greaterThan(other).value || this.equalToMethod(other).value); - } - public boolean hasAbstractMethods() { for (Variable variable : this.variableScope.variables.values()) { if (variable.isAbstract()) { @@ -177,10 +169,6 @@ public BuiltinClass increment() { } public boolean instanceOf(BuiltinType type) { - if (this.getType().equals(NullType.TYPE)) { - return true; - } - BuiltinType valueType = this.getType(); while (valueType != null) { @@ -207,10 +195,6 @@ public BooleanInstance lessThan(BuiltinClass other) { throw ErrorHolder.cannotApplyBinaryOperatorToTypes("<", this.getType(), other.getType()); } - public BooleanInstance lessThanOrEqualTo(BuiltinClass other) { - return new BooleanInstance(this.lessThan(other).value || this.equalToMethod(other).value); - } - public BuiltinClass logicalNot() { throw ErrorHolder.cannotApplyUnaryOperatorToType("!", this.getType()); } @@ -227,10 +211,6 @@ public BuiltinClass negate() { throw ErrorHolder.cannotApplyUnaryOperatorToType("-", this.getType()); } - public BooleanInstance notEqualToMethod(BuiltinClass other) { - return new BooleanInstance(!this.equalToMethod(other).value); - } - public void setIndex(BuiltinClass index, BuiltinClass value) { throw ErrorHolder.typeIsNotIndexable(this.getType()); } diff --git a/src/main/java/com/revolvingmadness/sculk/language/builtins/classes/types/EventsType.java b/src/main/java/com/revolvingmadness/sculk/language/builtins/classes/types/EventsType.java index 615df4b..41626e0 100644 --- a/src/main/java/com/revolvingmadness/sculk/language/builtins/classes/types/EventsType.java +++ b/src/main/java/com/revolvingmadness/sculk/language/builtins/classes/types/EventsType.java @@ -22,17 +22,17 @@ private EventsType() { super("Events"); this.registerEvent("onPlaceBlock", EventHolder.onPlaceBlock); - this.registerEvent("onPlayerAttackEntity", EventHolder.onPlayerAttackEntity); - this.registerEvent("onPlayerBreakBlock", EventHolder.onPlayerBreakBlock); - this.registerEvent("onPlayerCraftItem", EventHolder.onPlayerCraftItem); - this.registerEvent("onPlayerDropItem", EventHolder.onPlayerDropItem); - this.registerEvent("onPlayerJump", EventHolder.onPlayerJump); - this.registerEvent("onPlayerPickupItem", EventHolder.onPlayerPickupItem); + this.registerEvent("onAttackEntity", EventHolder.onAttackEntity); + this.registerEvent("onBreakBlock", EventHolder.onBreakBlock); + this.registerEvent("onCraftItem", EventHolder.onCraftItem); + this.registerEvent("onDropItem", EventHolder.onDropItem); + this.registerEvent("onJump", EventHolder.onJump); + this.registerEvent("onPickupItem", EventHolder.onPickupItem); this.registerEvent("onEntitySleep", EventHolder.onEntitySleep); - this.registerEvent("onPlayerUseItem", EventHolder.onPlayerUseItem); - this.registerEvent("onPlayerRingBell", EventHolder.onPlayerRingBell); - this.registerEvent("onPlayerSendChatMessage", EventHolder.onPlayerSendChatMessage); - this.registerEvent("onPlayerSneak", EventHolder.onPlayerSneak); + this.registerEvent("onRightClickItem", EventHolder.onRightClickItem); + this.registerEvent("onRingBell", EventHolder.onRingBell); + this.registerEvent("onSendChatMessage", EventHolder.onSendChatMessage); + this.registerEvent("whileSneaking", EventHolder.whileSneaking); } public void registerEvent(String name, List events) { diff --git a/src/main/java/com/revolvingmadness/sculk/language/builtins/functions/PrintFunction.java b/src/main/java/com/revolvingmadness/sculk/language/builtins/functions/PrintFunction.java index 8798091..a276a1c 100644 --- a/src/main/java/com/revolvingmadness/sculk/language/builtins/functions/PrintFunction.java +++ b/src/main/java/com/revolvingmadness/sculk/language/builtins/functions/PrintFunction.java @@ -22,7 +22,7 @@ public BuiltinClass call(Interpreter interpreter, List arguments) BuiltinClass stringClass = value.call(interpreter, "toString", List.of()); if (!stringClass.instanceOf(StringType.TYPE)) { - throw ErrorHolder.functionRequiresReturnType("toString", StringType.TYPE, stringClass.getType()); + throw ErrorHolder.functionRequiresReturnType("toString", stringClass.getType(), StringType.TYPE); } Logger.broadcast(Text.literal(stringClass.toString())); diff --git a/src/main/java/com/revolvingmadness/sculk/language/interpreter/Interpreter.java b/src/main/java/com/revolvingmadness/sculk/language/interpreter/Interpreter.java index a2a0257..e106026 100644 --- a/src/main/java/com/revolvingmadness/sculk/language/interpreter/Interpreter.java +++ b/src/main/java/com/revolvingmadness/sculk/language/interpreter/Interpreter.java @@ -46,12 +46,15 @@ public BuiltinClass visitBinaryExpression(BinaryExpressionNode binaryExpression) case FSLASH -> left.divide(right); case CARET -> left.exponentiate(right); case PERCENT -> left.mod(right); - case EQUAL_TO -> left.equalToMethod(right); - case NOT_EQUAL_TO -> left.notEqualToMethod(right); + case EQUAL_TO -> new BooleanInstance(left.call(this, "equals", List.of(right)).toBoolean()); + case NOT_EQUAL_TO -> + new BooleanInstance(left.call(this, "equals", List.of(right)).toBoolean()).logicalNot(); case GREATER_THAN -> left.greaterThan(right); - case GREATER_THAN_OR_EQUAL_TO -> left.greaterThanOrEqualTo(right); + case GREATER_THAN_OR_EQUAL_TO -> + new BooleanInstance(left.greaterThan(right).value || left.call(this, "equals", List.of(right)).toBoolean()); case LESS_THAN -> left.lessThan(right); - case LESS_THAN_OR_EQUAL_TO -> left.lessThanOrEqualTo(right); + case LESS_THAN_OR_EQUAL_TO -> + new BooleanInstance(left.lessThan(right).value || left.call(this, "equals", List.of(right)).toBoolean()); case DOUBLE_AMPERSAND -> left.booleanAnd(right); case DOUBLE_PIPE -> left.booleanOr(right); case INSTANCEOF -> { @@ -68,7 +71,7 @@ public BuiltinClass visitBinaryExpression(BinaryExpressionNode binaryExpression) yield new IntegerInstance(-1); } - BuiltinClass equalTo = left.equalToMethod(right); + BuiltinClass equalTo = left.call(this, "equals", List.of(right)); if (equalTo.toBoolean()) { yield new IntegerInstance(0); diff --git a/src/main/java/com/revolvingmadness/sculk/language/interpreter/VariableTable.java b/src/main/java/com/revolvingmadness/sculk/language/interpreter/VariableTable.java index a3c133d..f688972 100644 --- a/src/main/java/com/revolvingmadness/sculk/language/interpreter/VariableTable.java +++ b/src/main/java/com/revolvingmadness/sculk/language/interpreter/VariableTable.java @@ -41,8 +41,10 @@ public void assign(String name, BuiltinClass value) { throw ErrorHolder.cannotAssignValueToVariableBecauseItIsAConstant(variable.name); } - if (!value.instanceOf(variable.type)) { - throw new SyntaxError("Cannot assign a value with type '" + value.getType().name + "' to a variable that requires type '" + variable.type.name + "'"); + if (!value.instanceOf(NullType.TYPE)) { + if (!value.instanceOf(variable.type)) { + throw new SyntaxError("Cannot assign a value with type '" + value.getType().name + "' to a variable that requires type '" + variable.type.name + "'"); + } } variable.value = value;