import org.spongepowered.api.item.Enchantment; //导入依赖的package包/类
@Override
public ItemStack makeSpongeStack(BaseItemStack baseItemStack) {
    final ItemType itemType = ItemRegistryModule.get().getTypeByInternalId(baseItemStack.getType())
            .orElseThrow(() -> new IllegalStateException("Invalid item type: " + baseItemStack.getType()));
    final LanternItemStack itemStack = new LanternItemStack(itemType, baseItemStack.getAmount());
    final ObjectStore<LanternItemStack> store = ObjectStoreRegistry.get().get(LanternItemStack.class)
            .orElseThrow(() -> new IllegalStateException("Unable to access the LanternItemStack store."));
    final DataView view = DataContainer.createNew(DataView.SafetyMode.NO_DATA_CLONED);
    view.set(DATA_VALUE, baseItemStack.getData());
    store.deserialize(itemStack, view);
    final Map<Integer, Integer> enchantments = baseItemStack.getEnchantments();
    if (!enchantments.isEmpty()) {
        itemStack.offer(Keys.ITEM_ENCHANTMENTS, enchantments.entrySet().stream()
                .map(entry -> {
                    final Enchantment enchantment = EnchantmentRegistryModule.get().getByInternalId(entry.getKey())
                            .orElseThrow(() -> new IllegalStateException("Invalid enchantment type: " + entry.getKey()));
                    return new ItemEnchantment(enchantment, entry.getValue());
                })
                .collect(Collectors.toList()));
    }
    return itemStack;
}
 

import org.spongepowered.api.item.Enchantment; //导入依赖的package包/类
public static Optional<Enchantment> getID(final String name) {
	Enchantment enchant = null;
	List<Enchantment> enchantments = getAll();
	int cpt = 0;
	while(cpt < enchantments.size() && enchant == null){
		if (enchantments.get(cpt).getId().equalsIgnoreCase(name)) {
			enchant = enchantments.get(cpt);
		}
		cpt++;
	}
	return Optional.ofNullable(enchant);
}
 

import org.spongepowered.api.item.Enchantment; //导入依赖的package包/类
public static boolean canBeAppliedToItemStack(ItemStack item, Enchantment enchantment) {
	if (enchantment.canBeAppliedToStack(item)) {
		EnchantmentData enchantment_data = item.getOrCreate(EnchantmentData.class).get();
		
		for (ItemEnchantment enchantment_item : enchantment_data.enchantments()) {
			if (!enchantment.isCompatibleWith(enchantment_item.getEnchantment())) {
				return false;
			}
		}
	} else {
		return false;
	}
	return true;
}
 

import org.spongepowered.api.item.Enchantment; //导入依赖的package包/类
public static List<ItemEnchantment> getEnchantment(CompositeValueStore<?, ?> valueStore, Enchantment enchantment) {
  Optional<List<ItemEnchantment>> results = valueStore.get(Keys.ITEM_ENCHANTMENTS);
  if (results.isPresent()) {
    List<ItemEnchantment> enchantments = results.get();
    return enchantments.stream().filter(e -> e.getEnchantment().equals(enchantment)).collect(Collectors.toList());
  }
  return Lists.newArrayList();
}
 

import org.spongepowered.api.item.Enchantment; //导入依赖的package包/类
public static Optional<ItemEnchantment> getHighestEnchantment(CompositeValueStore<?, ?> valueStore, Enchantment enchantment) {
  List<ItemEnchantment> enchantments = getEnchantment(valueStore, enchantment);
  if (!enchantments.isEmpty()) {
    return Optional.of(enchantments.stream().sorted(Comparator.comparingInt(ItemEnchantment::getLevel)).findFirst().get());
  }
  return Optional.empty();
}
 

import org.spongepowered.api.item.Enchantment; //导入依赖的package包/类
public ItemData(ItemType material, short dura, String displayName, List<String> lore,
                Map<Enchantment, Integer> enchantments)
{
    this.material = material;
    this.dura = dura;
    this.displayName = displayName;
    this.lore = lore;
    this.enchantments = enchantments;
}
 

import org.spongepowered.api.item.Enchantment; //导入依赖的package包/类
@Override
public CommandResult execute(CommandSource sender, CommandContext args) throws CommandException {
    checkIfPlayer(sender);
    checkPermission(sender, ItemPermissions.UC_ITEM_ITEMENCHANT_BASE);
    Player p = (Player) sender;

    if (!p.getItemInHand(HandTypes.MAIN_HAND).isPresent() || p.getItemInHand(HandTypes.MAIN_HAND).get().getItem().equals(ItemTypes.NONE)) {
        throw new ErrorMessageException(Messages.getFormatted(p, "item.noiteminhand"));
    }
    ItemStack stack = p.getItemInHand(HandTypes.MAIN_HAND).get();

    Enchantment ench = args.<Enchantment>getOne("enchantment").get();
    int level = args.hasAny("level") ? args.<Integer>getOne("level").get() : 1;

    if (level > ItemPermissions.UC_ITEM_ITEMENCHANT_MAXLEVEL.getIntFor(p)) {
        throw Messages.error(p, "item.command.itemenchant.maxlevel", "%max%", ItemPermissions.UC_ITEM_ITEMENCHANT_MAXLEVEL.getIntFor(p));
    }

    List<ItemEnchantment> enchs = stack.get(Keys.ITEM_ENCHANTMENTS).orElse(new ArrayList<>());
    if (level > 0) {
        enchs.add(new ItemEnchantment(ench, level));
        stack.offer(Keys.ITEM_ENCHANTMENTS, enchs);
        p.setItemInHand(HandTypes.MAIN_HAND, stack);
        Messages.send(sender, "item.command.itemenchant.success", "%enchant%", ench.getTranslation().get(), "%level%", level);
        return CommandResult.success();
    } else {
        enchs = enchs.stream().filter(e -> !e.getEnchantment().equals(ench)).collect(Collectors.toList());
        stack.offer(Keys.ITEM_ENCHANTMENTS, enchs);
        p.setItemInHand(HandTypes.MAIN_HAND, stack);
        Messages.send(sender, "item.command.itemenchant.success2", "%enchant%", ench.getTranslation().get(), "%level%", level);
        return CommandResult.success();
    }
}
 

import org.spongepowered.api.item.Enchantment; //导入依赖的package包/类
@Nullable
@Override
public Enchantment parseValue(CommandSource sender, CommandArgs args) throws ArgumentParseException {
    String value = args.next();
    Optional<Enchantment> type = Sponge.getRegistry().getType(CatalogTypes.ENCHANTMENT, value);
    if (!type.isPresent()) {
        throw args.createError(Messages.getFormatted(sender, "item.command.itemenchant.notfound", "%enchantment%", value));
    }
    return type.get();
}
 

import org.spongepowered.api.item.Enchantment; //导入依赖的package包/类
public static  List<Enchantment> getAll(){
	return Sponge.getRegistry().getAllOf(Enchantment.class).stream().collect(Collectors.toList());
}
 

import org.spongepowered.api.item.Enchantment; //导入依赖的package包/类
private CompletableFuture<Boolean> commandEnchant(final EPlayer player, Enchantment enchantment, int level) {
	// Le joueur n'a pas d'item dans la main
	if (!player.getItemInMainHand().isPresent()) {
		EAMessages.EMPTY_ITEM_IN_HAND.sender()
			.prefix(EEMessages.PREFIX)
			.sendTo(player);
		return CompletableFuture.completedFuture(false);
	}
	
	ItemStack item = player.getItemInMainHand().get();
		
	// Le level est trop faible
	if (level < enchantment.getMinimumLevel()) {
		EEMessages.ENCHANT_LEVEL_TOO_LOW.sender()
			.replace("{number}", String.valueOf(level))
			.sendTo(player);
		return CompletableFuture.completedFuture(false);
	}
	
	if (level > enchantment.getMaximumLevel()) {
		EEMessages.ENCHANT_LEVEL_TOO_HIGHT.sender()
			.replace("{number}", String.valueOf(level))
			.sendTo(player);
		return CompletableFuture.completedFuture(false);
	}

	EnchantmentData enchantment_data = item.getOrCreate(EnchantmentData.class).get();
				
	// L'enchantement n'est pas applicable sur cet item
	if (!UtilsEnchantment.canBeAppliedToItemStack(item, enchantment)) {
		EEMessages.ENCHANT_INCOMPATIBLE.sender()
			.replace("{enchantment}", () -> enchantment.getId().toLowerCase().replace("minecraft:", "").replaceAll(" ", ""))
			.replace("{level}", String.valueOf(level))
			.replace("{item}", () -> EChat.getButtomItem(item, EEMessages.ENCHANT_ITEM_COLOR.getColor()))
			.sendTo(player);
		return CompletableFuture.completedFuture(false);
	}
	
	enchantment_data.set(enchantment_data.enchantments().add(new ItemEnchantment(enchantment, level)));
	item.offer(enchantment_data);
	player.setItemInMainHand(item);
	
	EEMessages.ENCHANT_SUCCESSFULL.sender()
		.replace("{enchantment}", enchantment.getTranslation().get())
		.replace("{level}", String.valueOf(level))
		.replace("{item}", () -> EChat.getButtomItem(item, EEMessages.ENCHANT_ITEM_COLOR.getColor()))
		.sendTo(player);
	return CompletableFuture.completedFuture(true);
}
 

import org.spongepowered.api.item.Enchantment; //导入依赖的package包/类
private Optional<Enchantment> getEnchantment(String enchant) {
	return UtilsEnchantment.getID("minecraft:" + enchant.toLowerCase().replace("minecraft:", ""));
}
 

import org.spongepowered.api.item.Enchantment; //导入依赖的package包/类
@Override
public List<String> getAllEnchants() {
	return Sponge.getRegistry().getAllOf(Enchantment.class).stream().map(Enchantment::getId).collect(Collectors.toList());
}
 

import org.spongepowered.api.item.Enchantment; //导入依赖的package包/类
public void setEnchants(Map<Enchantment, Integer> enchantsToAdd)
{
    // TODO
}
 

import org.spongepowered.api.item.Enchantment; //导入依赖的package包/类
/**
 * Utility method to calculate the modified damage from an Enchantment damage caused by an Armor
 * piece or Weapon. The {@link com.afterkraft.kraftrpg.api.entity.Insentient} is used to check
 * for any possible {@link com.afterkraft.kraftrpg.api.role.Role} damage modifications
 * necessary.  If varying damage is enabled, the damage will already take this into account.
 *
 * @param being       wearing/using the enchanted ItemStack
 * @param enchantment to calculate for
 * @param item        that is enchanted
 *
 * @return calculated damage that may be varied if enabled
 */
double getItemEnchantmentDamage(Insentient being, Enchantment enchantment,
                                ItemStack item);
 

import org.spongepowered.api.item.Enchantment; //导入依赖的package包/类
double getEnchantmentDamage(Enchantment enchantment, int enchantmentLevel);