Simple GUI management solution.
Just use my public repository and set the scope to compile.
There's no any jar file to install on the server. You just compile it with your plugin.
<repositories>
<repository>
<id>opengui</id>
<url>https://repo.socketbyte.pl/repository/nexus-releases/</url>
</repository>
</repositories> <dependencies>
<dependency>
<groupId>pl.socketbyte</groupId>
<artifactId>OpenGUI</artifactId>
<version>1.2</version>
<scope>compile</scope>
</dependency>
</dependencies>Download and copy the source-code into your src folder.
Keep in mind that you need following dependencies to get it to work.
- Bukkit or Spigot engine installed on your server. https://yivesmirror.com/downloads/spigot
- JDK/JRE 8 or higher. http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html
This API should be compatible with all Bukkit or Spigot
versions since 1.0.
I would recommend running it on a version higher than 1.7.2 though.
It was tested on Minecraft version 1.12.2.
It is fairly simple. OpenGUI has two possible usages. Object-based or standard.
Standard, and the simplest usage example:
public class YourPluginClass extends JavaPlugin {
public static void showGUI(Player player) {
// Register the listeners.
OpenGUI.INSTANCE.register(instance);
// Create the GUI inventory using our special wrapper.
GUI gui = new GUI("&cSimple Title", Rows.FIVE);
// Create GUIExtender class and provide the GUI information.
SimpleGUI simpleGUI = new SimpleGUI(gui);
// Some additional GUI settings like entering/dragging items.
simpleGUI.getGuiSettings().setCanEnterItems(true);
simpleGUI.getGuiSettings().setCanDrag(true);
// Set specific enterable/draggable items
simpleGUI.getGuiSettings().addEnterableItem(Material.STONE);
simpleGUI.getGuiSettings().addEnterableItem(Material.GOLDEN_APPLE, 1);
// Set event to occur when user tries to enter non-enterable item
simpleGUI.getGuiSettings().setNotEnterableItemResponse(
inventoryClickEvent ->
inventoryClickEvent.getWhoClicked().sendMessage(
"You can not enter that item!"));
// Set event to occur when user enters an item successfully
simpleGUI.getGuiSettings().setEnteredItemResponse(
inventoryClickEvent ->
inventoryClickEvent.getWhoClicked().sendMessage(
"Entered an item!"));
// #1 Set an item to a specified slot and assign an ItemBuilder
simpleGUI.setItem(0, new ItemBuilder(Material.DIRT, 1).setName("&aTest!"));
// #2 Add an item with assigned ItemBuilder
simpleGUI.addItem(new ItemBuilder(Material.DIAMOND));
// #3 Add an item with assigned ItemBuilder and ElementResponse event. (onClick)
simpleGUI.addItem(new ItemBuilder(Material.GOLD_AXE), event ->
System.out.println("On click event!"));
// #4 Set items all together using ItemPack class.
simpleGUI.setItem(
new ItemPack(1, new ItemBuilder(Material.WOOD)),
new ItemPack(2, new ItemBuilder(Material.STONE)),
new ItemPack(3, new ItemBuilder(Material.DIAMOND_ORE)),
new ItemPack(4, new ItemBuilder(Material.EMERALD)));
// Add an element response to slot 0.
simpleGUI.addElementResponse(0, event ->
System.out.println("On click event at slot 0!"));
// Add an element response to slot 1 and assign "pullable" value.
// It means that you can pull out that item from the GUI and take it with you.
simpleGUI.addElementResponse(1, true, event ->
System.out.println("On click event at slot 1!"));
// Add WindowResponse event.
simpleGUI.addWindowResponse(new WindowResponse() {
@Override
public void onOpen(InventoryOpenEvent event) {
System.out.println("Opened!");
}
@Override
public void onClose(InventoryCloseEvent event) {
System.out.println("Closed!");
}
});
// Remove an item from slot 0.
simpleGUI.removeItem(0);
// Open inventory.
// WARNING: This is important that you use our method.
// You can use player.openInventory(inventory)
// only when not using overrided items. (More on that in object-based usage)
simpleGUI.openInventory(player);
}
}Object-based usage. (A little more complicated, this is for advanced users who are familiar with basics of object-oriented programming!)
public class TestGUI extends GUIExtender {
// Simple custom GUI, here you can add your items and prepare it for show.
// Functionality of this object will be extended in the future.
public TestGUI() {
super(new GUI("&cSuper Title", Rows.THREE));
getGuiSettings().setCanDrag(true);
getGuiSettings().setCanEnterItems(true);
// Add possible to enter material
getGuiSettings().addEnterableItem(Material.STONE);
// Here we can set our GUIExtenderItem class extension as a normal item.
setItem(0, new TestItem());
// Every functionality from standard usage is of course here.
// You can add/set items, add element response or other listeners.
// You can even override all the methods, but I don't see any useful outcomes of this.
}
@Override
public void onOpen(InventoryOpenEvent e) {
System.out.println("Opened!");
}
@Override
public void onClose(InventoryCloseEvent e) {
System.out.println("Closed!");
}
}
public class TestItem extends GUIExtenderItem {
public TestItem() {
// We can set here the default ItemBuilder,
// but there's no need for it as we're overriding the getItemBuilder method
super();
setPullable(false);
}
// You can change resulting item just before the player opens the inventory.
// The assignment of the item is made in GUIExtender.openInventory(player) method.
@Override
public ItemBuilder getItemBuilder(Player player) {
if (player.getName().equals("pl.socketbyte.opengui.Test"))
return new ItemBuilder(Material.DIAMOND)
.setName("&bDiamond")
.setLore("Very nice", "Diamond");
return new ItemBuilder(Material.GRASS)
.setName("&2Grass")
.setLore("Gross", "Grass");
}
// ElementResponse implementation.
@Override
public void onClick(InventoryClickEvent event) {
System.out.println("Click!");
}
}Now you can show your amazing objects to the player using
TestGUI testGUI = new TestGUI();
testGUI.openInventory(player);
OpenGUI in 1.2 offers Serializable classes that allow to easily configure your GUI from config.yml file.
If you want to use it from config, you need to use different objects.
SerializableSimpleGUI instead of SimpleGUI
SerializableGUI instead of GUI
SerializableItemBuilder instead of ItemBuilder
Congratulations! You can save now your SerializableSimpleGUI
using
configuration.set("gui", yourSimpleGUI)Of course you can read GUI from config like this:
SerializableSimpleGUI gui = (SerializableSimpleGUI) configuration.get("gui")Result:
gui:
canDrag: true
canEnterItems: true
enterableItems:
- GOLD_PICKAXE
gui:
title: '&2&lDrop'
actions:
# action ID on slot 0 etc.
0: on_click_action_0
1: on_click_action_1
2: on_click_action_2
3: on_click_action_3
4: on_click_action_4
5: on_click_action_5
inventory:
- slot: 0
item:
material: DIAMOND
amount: 1
durability: 0
name: null
lore: null
- slot: 1
item:
material: GOLDEN_APPLE
amount: 1
durability: 1
name: null
lore: null
- slot: 2
item:
material: COAL
amount: 48
durability: 0
name: null
lore: null
- slot: 3
item:
material: CHORUS_FLOWER
amount: 1
durability: 0
name: null
lore:
- Hi!
- Boi!
- slot: 4
item:
material: JACK_O_LANTERN
amount: 1
durability: 0
name: '&6Hello!'
lore: null
- slot: 5
item:
material: LAPIS_BLOCK
amount: 1
durability: 0
name: null
lore: nullLike you can see, OpenGUI offers additional action id parameters.
You can find them in SerializableSimpleGUI and use them like this:
simpleGUI.hasAction(int slot)
simpleGUI.getActionFor(int slot) // returns StringYou can use them to append different ElementResponse actions for each item.
It allows to create dynamic GUIs right from your configuration file.
Enchantments are currently not supported. To be added in 1.2b
Project supports JUnit 4. Test code is generated automatically using EvoSuite 1.0.5.
This project is not well written, or amazing in any case. It's usage is heavily inspired by AmpMenus but it's a bit more rich in functionalities and still supported.
If you have any questions or issues feel free to use github issues forum. If you want to contribute on the project you of course can.
No license basically. You can do everything with the code, but you can't distribute or sell it.