Hammer

gradle.properties

@@ -1,2 +1,2 @@
 version=MODIFIED
-pylon-core.version=0.1.0
+pylon-core.version=0.1.2

src/main/java/io/github/pylonmc/pylon/base/PylonBase.java

@@ -3,8 +3,21 @@
 import org.bukkit.plugin.java.JavaPlugin;
 
 public class PylonBase extends JavaPlugin {
+
+    private static PylonBase INSTANCE;
+
+    public static PylonBase getInstance() {
+        return INSTANCE;
+    }
+
     @Override
     public void onEnable() {
-        getLogger().info("Hello, world!");
+        INSTANCE = this;
+        PylonItems.register();
+    }
+
+    @Override
+    public void onDisable() {
+        INSTANCE = null;
     }
 }

src/main/java/io/github/pylonmc/pylon/base/PylonItems.java

@@ -0,0 +1,189 @@
+package io.github.pylonmc.pylon.base;
+
+import io.github.pylonmc.pylon.base.items.BasicItemSchema;
+import io.github.pylonmc.pylon.base.items.Hammer;
+import io.github.pylonmc.pylon.base.util.Components;
+import io.github.pylonmc.pylon.base.util.MiningLevel;
+import io.github.pylonmc.pylon.core.item.ItemStackBuilder;
+import io.github.pylonmc.pylon.core.item.PylonItemSchema;
+import io.papermc.paper.datacomponent.DataComponentTypes;
+import io.papermc.paper.datacomponent.item.ItemAttributeModifiers;
+import io.papermc.paper.datacomponent.item.ItemLore;
+import net.kyori.adventure.text.Component;
+import org.bukkit.Material;
+import org.bukkit.NamespacedKey;
+import org.bukkit.Tag;
+import org.bukkit.attribute.Attribute;
+import org.bukkit.attribute.AttributeModifier;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.RecipeChoice;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+
+@SuppressWarnings("UnstableApiUsage")
+public class PylonItems {
+
+    private PylonItems() {
+        throw new AssertionError("Utility class");
+    }
+
+    public static final PylonItemSchema COPPER_SHEET = new BasicItemSchema<>(
+            pylonKey("copper_sheet"),
+            new ItemStackBuilder(Material.PAPER)
+                    .set(DataComponentTypes.ITEM_NAME, Component.text("Copper Sheet"))
+                    .build(),
+            Hammer.RECIPE_TYPE,
+            sheet -> new Hammer.Recipe(
+                    pylonKey("copper_sheet"),
+                    List.of(new ItemStack(Material.COPPER_INGOT)),
+                    sheet,
+                    MiningLevel.STONE,
+                    0.25f
+            )
+    );
+
+    public static final PylonItemSchema GOLD_SHEET = new BasicItemSchema<>(
+            pylonKey("gold_sheet"),
+            new ItemStackBuilder(Material.PAPER)
+                    .set(DataComponentTypes.ITEM_NAME, Component.text("Gold Sheet"))
+                    .build(),
+            Hammer.RECIPE_TYPE,
+            sheet -> new Hammer.Recipe(
+                    pylonKey("gold_sheet"),
+                    List.of(new ItemStack(Material.GOLD_INGOT)),
+                    sheet,
+                    MiningLevel.STONE,
+                    0.25f
+            )
+    );
+
+    public static final PylonItemSchema IRON_SHEET = new BasicItemSchema<>(
+            pylonKey("iron_sheet"),
+            new ItemStackBuilder(Material.PAPER)
+                    .set(DataComponentTypes.ITEM_NAME, Component.text("Iron Sheet"))
+                    .build(),
+            Hammer.RECIPE_TYPE,
+            sheet -> new Hammer.Recipe(
+                    pylonKey("iron_sheet"),
+                    List.of(new ItemStack(Material.IRON_INGOT)),
+                    sheet,
+                    MiningLevel.IRON,
+                    0.25f
+            )
+    );
+
+    //<editor-fold desc="Hammers" defaultstate=collapsed>
+    public static final Hammer STONE_HAMMER = new Hammer(
+            pylonKey("stone_hammer"),
+            Hammer.Item.class,
+            new ItemStackBuilder(Material.STONE_PICKAXE)
+                    .set(DataComponentTypes.ITEM_NAME, Component.text("Stone Hammer"))
+                    .set(DataComponentTypes.LORE,
+                            Components.createLore(
+                                    "A hammer made of stone",
+                                    "Useful as a weapon in a pinch"
+                            )
+                    )
+                    .set(DataComponentTypes.ATTRIBUTE_MODIFIERS, ItemAttributeModifiers.itemAttributes()
+                            .addModifier(Attribute.ATTACK_SPEED, new AttributeModifier(
+                                    pylonKey("hammer_attack_speed"),
+                                    (1.0 / 3) - 4,
+                                    AttributeModifier.Operation.ADD_NUMBER
+                            ))
+                            .addModifier(Attribute.ATTACK_KNOCKBACK, new AttributeModifier(
+                                    pylonKey("hammer_attack_knockback"),
+                                    1,
+                                    AttributeModifier.Operation.ADD_NUMBER
+                            ))
+                            .addModifier(Attribute.ATTACK_DAMAGE, new AttributeModifier(
+                                    pylonKey("hammer_attack_damage"),
+                                    1,
+                                    AttributeModifier.Operation.ADD_NUMBER
+                            ))
+                    )
+                    .build(),
+            MiningLevel.STONE,
+            new RecipeChoice.MaterialChoice(Tag.ITEMS_STONE_TOOL_MATERIALS)
+    );
+
+    public static final Hammer IRON_HAMMER = new Hammer(
+            pylonKey("iron_hammer"),
+            Hammer.Item.class,
+            new ItemStackBuilder(Material.IRON_PICKAXE)
+                    .set(DataComponentTypes.ITEM_NAME, Component.text("Iron Hammer"))
+                    .set(DataComponentTypes.LORE,
+                            Components.createLore(
+                                    "A hammer made of iron",
+                                    "Stronger than a stone hammer"
+                            )
+                    )
+                    .set(DataComponentTypes.ATTRIBUTE_MODIFIERS, ItemAttributeModifiers.itemAttributes()
+                            .addModifier(Attribute.ATTACK_SPEED, new AttributeModifier(
+                                    pylonKey("hammer_attack_speed"),
+                                    (1.0 / 2) - 4,
+                                    AttributeModifier.Operation.ADD_NUMBER
+                            ))
+                            .addModifier(Attribute.ATTACK_KNOCKBACK, new AttributeModifier(
+                                    pylonKey("hammer_attack_knockback"),
+                                    1.5,
+                                    AttributeModifier.Operation.ADD_NUMBER
+                            ))
+                            .addModifier(Attribute.ATTACK_DAMAGE, new AttributeModifier(
+                                    pylonKey("hammer_attack_damage"),
+                                    3,
+                                    AttributeModifier.Operation.ADD_NUMBER
+                            ))
+                    )
+                    .build(),
+            MiningLevel.IRON,
+            new RecipeChoice.MaterialChoice(Material.IRON_INGOT)
+    );
+
+    public static final Hammer DIAMOND_HAMMER = new Hammer(
+            pylonKey("diamond_hammer"),
+            Hammer.Item.class,
+            new ItemStackBuilder(Material.DIAMOND_PICKAXE)
+                    .set(DataComponentTypes.ITEM_NAME, Component.text("Diamond Hammer"))
+                    .set(DataComponentTypes.LORE,
+                            Components.createLore(
+                                    "A hammer made of diamond",
+                                    "Only the richest can afford this"
+                            )
+                    )
+                    .set(DataComponentTypes.ATTRIBUTE_MODIFIERS, ItemAttributeModifiers.itemAttributes()
+                            .addModifier(Attribute.ATTACK_SPEED, new AttributeModifier(
+                                    pylonKey("hammer_attack_speed"),
+                                    1 - 4,
+                                    AttributeModifier.Operation.ADD_NUMBER
+                            ))
+                            .addModifier(Attribute.ATTACK_KNOCKBACK, new AttributeModifier(
+                                    pylonKey("hammer_attack_knockback"),
+                                    2,
+                                    AttributeModifier.Operation.ADD_NUMBER
+                            ))
+                            .addModifier(Attribute.ATTACK_DAMAGE, new AttributeModifier(
+                                    pylonKey("hammer_attack_damage"),
+                                    5,
+                                    AttributeModifier.Operation.ADD_NUMBER
+                            ))
+                    )
+                    .build(),
+            MiningLevel.DIAMOND,
+            new RecipeChoice.MaterialChoice(Material.DIAMOND)
+    );
+    //</editor-fold>
+
+    static void register() {
+        COPPER_SHEET.register();
+        GOLD_SHEET.register();
+        IRON_SHEET.register();
+        STONE_HAMMER.register();
+        IRON_HAMMER.register();
+        DIAMOND_HAMMER.register();
+    }
+
+    private static @NotNull NamespacedKey pylonKey(@NotNull String key) {
+        return new NamespacedKey(PylonBase.getInstance(), key);
+    }
+}

src/main/java/io/github/pylonmc/pylon/base/items/BasicItemSchema.java

@@ -0,0 +1,24 @@
+package io.github.pylonmc.pylon.base.items;
+
+import io.github.pylonmc.pylon.core.item.PylonItemSchema;
+import io.github.pylonmc.pylon.core.item.SimplePylonItem;
+import io.github.pylonmc.pylon.core.recipe.RecipeType;
+import org.bukkit.Keyed;
+import org.bukkit.NamespacedKey;
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.function.Function;
+
+// TODO move to pylon-core
+public class BasicItemSchema<R extends Keyed> extends PylonItemSchema {
+    public BasicItemSchema(
+            @NotNull NamespacedKey id,
+            @NotNull ItemStack template,
+            @NotNull RecipeType<R> recipeType,
+            @NotNull Function<ItemStack, R> recipe
+    ) {
+        super(id, SimplePylonItem.class, template);
+        recipeType.addRecipe(recipe.apply(template));
+    }
+}