Rename events

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
 

src/main/java/com/revolvingmadness/sculk/language/EventHolder.java

@@ -19,41 +19,41 @@
 public class EventHolder {
     public static final List<Event> onEntitySleep = new ArrayList<>();
     public static final List<Event> onPlaceBlock = new ArrayList<>();
-    public static final List<Event> onPlayerAttackEntity = new ArrayList<>();
-    public static final List<Event> onPlayerBreakBlock = new ArrayList<>();
-    public static final List<Event> onPlayerCraftItem = new ArrayList<>();
-    public static final List<Event> onPlayerDropItem = new ArrayList<>();
-    public static final List<Event> onPlayerJump = new ArrayList<>();
-    public static final List<Event> onPlayerPickupItem = new ArrayList<>();
-    public static final List<Event> onPlayerRingBell = new ArrayList<>();
-    public static final List<Event> onPlayerSendChatMessage = new ArrayList<>();
-    public static final List<Event> onPlayerSneak = new ArrayList<>();
-    public static final List<Event> onPlayerUseItem = new ArrayList<>();
+    public static final List<Event> onAttackEntity = new ArrayList<>();
+    public static final List<Event> onBreakBlock = new ArrayList<>();
+    public static final List<Event> onCraftItem = new ArrayList<>();
+    public static final List<Event> onDropItem = new ArrayList<>();
+    public static final List<Event> onJump = new ArrayList<>();
+    public static final List<Event> onPickupItem = new ArrayList<>();
+    public static final List<Event> onRingBell = new ArrayList<>();
+    public static final List<Event> onSendChatMessage = new ArrayList<>();
+    public static final List<Event> whileSneaking = new ArrayList<>();
+    public static final List<Event> 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) {

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());
     }

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<Event> events) {

src/main/java/com/revolvingmadness/sculk/language/builtins/functions/PrintFunction.java

@@ -22,7 +22,7 @@ public BuiltinClass call(Interpreter interpreter, List<BuiltinClass> 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()));

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);

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;