Crate.java

package se.walkercrou.crates;

import com.google.common.base.Objects;
import ninja.leaping.configurate.objectmapping.Setting;
import ninja.leaping.configurate.objectmapping.serialize.ConfigSerializable;
import org.spongepowered.api.data.key.Keys;
import org.spongepowered.api.data.meta.ItemEnchantment;
import org.spongepowered.api.item.Enchantments;
import org.spongepowered.api.item.ItemTypes;
import org.spongepowered.api.item.inventory.ItemStack;
import org.spongepowered.api.item.inventory.ItemStackSnapshot;
import org.spongepowered.api.text.Text;
import org.spongepowered.api.text.TextTemplate;
import se.walkercrou.crates.data.CrateIdData;

import static java.util.Collections.singletonList;

@ConfigSerializable
public class Crate {

    private String id;
    @Setting private Text name;
    @Setting private boolean buyable = false;
    @Setting private double cost = 0;
    @Setting private TextTemplate playerMessage;
    @Setting private TextTemplate broadcastMessage;
    @Setting private ItemStackSnapshot key;

    public Crate setId(String id) {
        this.id = id;
        return this;
    }

    public ItemStack createItemStack(int amount) {
        ItemStack item = ItemStack.of(ItemTypes.CHEST, amount);
        item.offer(new CrateIdData(this.id));
        item.offer(Keys.ITEM_ENCHANTMENTS, singletonList(new ItemEnchantment(Enchantments.AQUA_AFFINITY, 1)));
//        item.offer(Keys.ITEM_LORE, singletonList(this.name));
        return item;
    }

    @Override
    public int hashCode() {
        return Objects.hashCode(this.id);
    }

    @Override
    public String toString() {
        return Objects.toStringHelper(this)
            .add("id", this.id)
            .add("name", this.name)
            .add("buyable", this.buyable)
            .add("playerMessage", this.playerMessage)
            .add("broadcastMessage", this.broadcastMessage)
            .add("key", this.key)
            .toString();
    }

}

CrateIdData.java

package se.walkercrou.crates.data;

import com.google.common.reflect.TypeToken;
import org.spongepowered.api.Sponge;
import org.spongepowered.api.data.DataContainer;
import org.spongepowered.api.data.DataHolder;
import org.spongepowered.api.data.DataQuery;
import org.spongepowered.api.data.key.Key;
import org.spongepowered.api.data.manipulator.mutable.common.AbstractSingleData;
import org.spongepowered.api.data.merge.MergeFunction;
import org.spongepowered.api.data.value.mutable.Value;

import java.util.Optional;

import static org.spongepowered.api.data.key.KeyFactory.makeSingleKey;

public class CrateIdData extends AbstractSingleData<String, CrateIdData, ImmutableCrateIdData> {

    public static final Key<Value<String>> KEY = makeSingleKey(
        TypeToken.of(String.class),
        new TypeToken<Value<String>>() {},
        DataQuery.of("CrateId"),
        "emerelliscrates:crateId",
        "Crate ID");

    public static final int CONTENT_VERSION = 1;

    public CrateIdData(String value) {
        super(value, KEY);
    }

    public CrateIdData() {
        this("");
    }

    public Value<String> crateId() {
        return Sponge.getRegistry().getValueFactory().createValue(KEY, getValue());
    }

    @Override
    protected Value<String> getValueGetter() {
        return crateId();
    }

    @Override
    public Optional<CrateIdData> fill(DataHolder dataHolder, MergeFunction overlap) {
        return dataHolder.get(KEY).map(crateId -> overlap.merge(this, new CrateIdData(crateId)));
    }

    @Override
    public Optional<CrateIdData> from(DataContainer container) {
        return container.getString(KEY.getQuery()).map(CrateIdData::new);
    }

    @Override
    public CrateIdData copy() {
        return new CrateIdData(getValue());
    }

    @Override
    public ImmutableCrateIdData asImmutable() {
        return new ImmutableCrateIdData(getValue());
    }

    @Override
    public int getContentVersion() {
        return CONTENT_VERSION;
    }

}

CrateIdDataManipulatorBuilder

package se.walkercrou.crates.data;

import org.spongepowered.api.data.DataHolder;
import org.spongepowered.api.data.DataView;
import org.spongepowered.api.data.manipulator.DataManipulatorBuilder;
import org.spongepowered.api.data.persistence.InvalidDataException;

import java.util.Optional;

public class CrateIdDataManipulatorBuilder implements DataManipulatorBuilder<CrateIdData, ImmutableCrateIdData> {

    @Override
    public CrateIdData create() {
        return new CrateIdData();
    }

    @Override
    public Optional<CrateIdData> createFrom(DataHolder dataHolder) {
        return Optional.of(dataHolder.get(CrateIdData.class).orElse(new CrateIdData()));
    }

    @Override
    public Optional<CrateIdData> build(DataView container) throws InvalidDataException {
        return container.getString(CrateIdData.KEY.getQuery()).map(CrateIdData::new);
    }

}

DebugCommandExecutors.java

package se.walkercrou.crates.cmd;

import org.spongepowered.api.command.CommandException;
import org.spongepowered.api.command.CommandResult;
import org.spongepowered.api.command.CommandSource;
import org.spongepowered.api.command.args.CommandContext;
import org.spongepowered.api.entity.living.player.Player;
import org.spongepowered.api.item.inventory.ItemStack;
import org.spongepowered.api.item.inventory.entity.Hotbar;
import org.spongepowered.api.item.inventory.property.SlotIndex;
import se.walkercrou.crates.data.CrateIdData;

import static org.spongepowered.api.text.Text.of;

public final class DebugCommandExecutors {

    public CommandResult checkCrate(CommandSource src, CommandContext context) throws CommandException {
        if (!(src instanceof Player))
            throw new CommandException(of("Source must be player."));
        Player player = (Player) src;
        Hotbar hotbar = player.getInventory().query(Hotbar.class);
        ItemStack currentItem = hotbar.getSlot(SlotIndex.of(hotbar.getSelectedSlotIndex())).get().peek()
            .orElseThrow(() -> new CommandException(of("Not holding any item.")));
        src.sendMessage(of("ItemStack: " + currentItem));
        src.sendMessage(of("Crate ID: " + currentItem.get(CrateIdData.KEY).orElse("None")));
        return CommandResult.success();
    }

}

EmerellisCrates.java

package se.walkercrou.crates;

import com.google.common.reflect.TypeToken;
import ninja.leaping.configurate.ConfigurationNode;
import ninja.leaping.configurate.objectmapping.ObjectMappingException;
import org.slf4j.Logger;
import org.spongepowered.api.Game;
import org.spongepowered.api.config.DefaultConfig;
import org.spongepowered.api.event.Listener;
import org.spongepowered.api.event.game.GameReloadEvent;
import org.spongepowered.api.event.game.state.GamePreInitializationEvent;
import org.spongepowered.api.event.game.state.GameStartedServerEvent;
import org.spongepowered.api.event.game.state.GameStoppedEvent;
import org.spongepowered.api.plugin.Plugin;
import org.spongepowered.api.plugin.PluginContainer;
import org.spongepowered.api.text.TextTemplate;
import se.walkercrou.crates.cmd.CommandRegistrar;
import se.walkercrou.crates.data.CrateIdData;
import se.walkercrou.crates.data.CrateIdDataManipulatorBuilder;
import se.walkercrou.crates.data.ImmutableCrateIdData;

import javax.inject.Inject;
import java.io.IOException;
import java.nio.file.Path;
import java.util.*;

@Plugin(id = "emerelliscrates", authors = { "windy" })
public class EmerellisCrates {

    @Inject public PluginContainer self;
    @Inject public Logger log;
    @Inject public Game game;
    @Inject @DefaultConfig(sharedRoot = true) private Path configPath;

    private final Config config = new Config();
    private final Map<String, Crate> crates = new HashMap<>();
    private CommandRegistrar commands;
    private boolean debug = false;

    @Listener
    public void onPreInit(GamePreInitializationEvent event) {
        this.log.info("Initializing...");
        this.game.getDataManager().register(CrateIdData.class, ImmutableCrateIdData.class,
            new CrateIdDataManipulatorBuilder());
    }

    @Listener
    public void onStart(GameStartedServerEvent event) {
        if (init())
            this.log.info("Started.");
    }

    @Listener
    public void onReload(GameReloadEvent event) {
        this.log.info("Reloading...");
        this.crates.clear();
        this.commands.deregister();
        if (init())
            this.log.info("Reloaded.");
    }

    private boolean init() {
        try {
            this.config.load(this.configPath, this.self.getAsset("default.conf").get());
            this.debug = this.config.getRoot().getNode("debug").getBoolean();
            if (this.debug)
                this.log.info("Debug mode enabled.");
            loadCrates();
            this.commands = new CommandRegistrar(this).register();
            return true;
        } catch (ObjectMappingException | IOException e) {
            this.log.error("An error occurred while loading the configuration, commands are unavailable.", e);
            return false;
        }
    }

    @Listener
    public void onStop(GameStoppedEvent event) {
        this.log.info("Stopped.");
    }

    private void loadCrates() throws ObjectMappingException {
        TextTemplate tmp = TextTemplate.of(); // make sure static block is initialized
        ConfigurationNode cratesNode = this.config.getRoot().getNode("crates");
        Set<Object> keys = cratesNode.getChildrenMap().keySet();
        this.log.info("Loading " + keys.size() + " crates...");
        for (Object key : keys)
            this.crates.put(key.toString(), cratesNode.getValue(TypeToken.of(Crate.class)).setId(key.toString()));
    }

    public Optional<Crate> getCrate(String id) {
        return Optional.ofNullable(this.crates.get(id));
    }

    public boolean isDebug() {
        return this.debug;
    }

}

ImmutableCrateIdData.java

package se.walkercrou.crates.data;

import org.spongepowered.api.Sponge;
import org.spongepowered.api.data.manipulator.immutable.common.AbstractImmutableSingleData;
import org.spongepowered.api.data.value.immutable.ImmutableValue;

import static se.walkercrou.crates.data.CrateIdData.*;

public class ImmutableCrateIdData extends AbstractImmutableSingleData<String, ImmutableCrateIdData, CrateIdData> {

    public ImmutableCrateIdData(String value) {
        super(value, KEY);
    }

    public ImmutableValue<String> crateId() {
        return Sponge.getRegistry().getValueFactory().createValue(KEY, getValue()).asImmutable();
    }

    @Override
    protected ImmutableValue<?> getValueGetter() {
        return crateId();
    }

    @Override
    public CrateIdData asMutable() {
        return new CrateIdData(getValue());
    }

    @Override
    public int getContentVersion() {
        return CONTENT_VERSION;
    }

}