Java 类net.minecraft.world.storage.loot.LootEntry 实例源码

@SubscribeEvent
public void onLootTableLoad(LootTableLoadEvent event) {
    if (ConfigHandler.general.enableDungeonLoot) {
        String prefix = "minecraft:chests/";
        String name = event.getName().toString();
        if (name.startsWith(prefix)) {
            String file = name.substring(name.indexOf(prefix) + prefix.length());
            switch (file) {
                case "abandoned_mineshaft":
                case "desert_pyramid":
                case "jungle_temple":
                case "simple_dungeon":
                case "spawn_bonus_chest":
                case "stronghold_corridor":
                case "village_blacksmith":
                    LootEntry entry = new LootEntryTable(RL("inject/simple_dungeon_loot"), 1, 0,  new LootCondition[0], "pneumaticcraft_inject_entry");
                    LootPool pool = new LootPool(new LootEntry[]{entry}, new LootCondition[0], new RandomValueRange(1), new RandomValueRange(0, 1), "pneumaticcraft_inject_pool");
                    event.getTable().addPool(pool);
                    break;
                default:
                    break;
            }
        }
    }
}

@SubscribeEvent
public void onLootTableLoad(LootTableLoadEvent event) {
  LootPool main = event.getTable().getPool(LOOTPOOLNAME);
  if (main == null) {
    //create my own.  EX: mobs that have no drops (bats) also have empty loot table, so i have to inject an entry in the table before I fill it
    event.getTable().addPool(new LootPool(new LootEntry[0], new LootCondition[0], new RandomValueRange(1F, 2F), new RandomValueRange(1F, 1F), LOOTPOOLNAME));
    main = event.getTable().getPool(LOOTPOOLNAME);
    if (main == null) {
      ModCyclic.logger.error("could not insert Loot Pool for table :" + event.getName().toString());
      return;
    }
  }
  if (enableChestLoot) {
    onLootChestTableLoad(main, event);
  }
}

private static void addPool(LootTable table)
{
    LootEntry common = new LootEntryTable(new ResourceLocation("lootslashconquer:chests/common_chest"), 60, 1, new LootCondition[0], "common");
    LootEntry uncommon = new LootEntryTable(new ResourceLocation("lootslashconquer:chests/uncommon_chest"), 25, 1, new LootCondition[0], "uncommon");
    LootEntry rare = new LootEntryTable(new ResourceLocation("lootslashconquer:chests/rare_chest"), 10, 1, new LootCondition[0], "rare");
    LootEntry legendary = new LootEntryTable(new ResourceLocation("lootslashconquer:chests/legendary_chest"), 5, 1, new LootCondition[0], "legendary");
    LootEntry exotic = new LootEntryTable(new ResourceLocation("lootslashconquer:chests/exotic_chest"), 2, 1, new LootCondition[0], "exotic");

    LootPool pool = new LootPool(new LootEntry[] { common, uncommon, rare, legendary, exotic }, new LootCondition[0], new RandomValueRange(0, 1), new RandomValueRange(0), "loot");

    table.addPool(pool);
}

@SubscribeEvent
public void addTables(LootTableLoadEvent event){
    String name = event.getName().toString();
    if(Randores.getConfigObj().getModules().isDungeonLoot()) {
        if (is(name, chests)) {
            event.getTable().addPool(new LootPool(new LootEntry[] {new RandoresLootEntry(1, 2, true, 10, 20, new LootCondition[0], "randores_flexible_loot_entry")}, new LootCondition[0], new RandomValueRange(1), new RandomValueRange(0, 1), "randores_flexible_pool"));
        } else if (name.contains("end_city_treasure")) {
            event.getTable().addPool(new LootPool(new LootEntry[] {new RandoresLootEntry(1, 5, true, 20, 50, new LootCondition[0], "randores_flexible_loot_entry")}, new LootCondition[0], new RandomValueRange(1), new RandomValueRange(0, 1), "randores_flexible_pool"));
        } else if (name.contains("spawn_bonus_chest")) {
            event.getTable().addPool(new LootPool(new LootEntry[] {new RandoresLootEntry(1, 1, false, 0, 0, new LootCondition[0], "randores_flexible_loot_entry")}, new LootCondition[0], new RandomValueRange(1), new RandomValueRange(0, 1), "randores_flexible_pool"));
        }
    }
}

@SubscribeEvent
public void lootTableLoad(final LootTableLoadEvent event) {
    if (NemesisConfig.DISCOVERY_ENABLED && isLootTarget(event)) {

        // TODO improve roll settings

        String name = LOOT_TABLE.toString();
        LootEntry entry = new LootEntryTable(LOOT_TABLE, 1, 0, new LootCondition[0], name);

        RandomValueRange rolls = new RandomValueRange(0, 1);
        LootPool pool = new LootPool(new LootEntry[] { entry }, new LootCondition[0], rolls, rolls, name);
        event.getTable().addPool(pool);
    }
}

/**
 * Converts a LootTable to a list of possible drops, only looks for Item and metadata.
 * @param table the loot table to get items from
 * @return a LinkedList of the stacks in the loot table
 */
public static List<ItemStack> tableToItemStacks(LootTable table){
    List<ItemStack> stacks = new LinkedList<>();
    for(LootPool p:getPools(table)){
        for(LootEntry entry:getEntries(p)){
            if(entry instanceof LootEntryItem){
                LootEntryItem ei = (LootEntryItem)entry;
                Item item = getItem(ei);
                LootFunction[] functs = getFunctions(ei);
                boolean metaSet = false;
                for(LootFunction func:functs){
                    if(func instanceof SetMetadata){
                        metaSet=true;
                        RandomValueRange range = (RandomValueRange)ReflectionHelper.getPrivateValue(SetMetadata.class, (SetMetadata)func, "metaRange","field_186573_b");
                        int meta = MathHelper.floor(range.getMin());
                        stacks.add(new ItemStack(item,1,meta));
                    }
                }
                if(!metaSet)stacks.add(new ItemStack(item));
            }
            /* won't bother with this case for now
            else if(entry instanceof LootEntryTable){
                //restart with that table
                ResourceLocation location = (ResourceLocation) ReflectionHelper.getPrivateValue(LootEntryTable.class, (LootEntryTable)entry, "table","field_186371_a");
            }
            */
        }
    }
    return stacks;
}

@SubscribeEvent
public static void onLootLoading(LootTableLoadEvent event) {
    if (event.getName().toString().equals("minecraft:gameplay/fishing")) {
        LootPool pool = event.getTable().getPool("main");
        if (pool != null) {
            for (String name : LOOT_TABLES) {
                LootEntry entry = pool.getEntry("minecraft:" + name);
                pool.addEntry(getEntry(MOD_ID + "_" + name.replace(FISHING, ""), name, getVanillaQuality(entry), getVanillaWeight(entry)));
            }
        }
    }
}

@SubscribeEvent
public void onLootTableLoad(LootTableLoadEvent event) {
    String name = event.getName().toString();
    if (name.startsWith("minecraft:chests/simple_dungeon") || name.startsWith("minecraft:chests/desert_pyramid") || name.startsWith("minecraft:chests/jungle_temple")) {
        event.getTable().addPool(new LootPool(new LootEntry[] { new LootEntryTable(new ResourceLocation(Allomancy.MODID, "inject/lerasium"), 1, 0, new LootCondition[0], "allomancy_inject_entry") }, new LootCondition[0], new RandomValueRange(1),
                new RandomValueRange(0, 1), "allomancy_inject_pool"));
    }
}

private @Nonnull LootEntry createLootEntry(@Nonnull Item item, int meta, int minStackSize, int maxStackSize, float chance) {
  LootCondition[] chanceCond = new LootCondition[] { new RandomChance(chance) };
  final ResourceLocation registryName = NullHelper.notnull(item.getRegistryName(), "found unregistered item");
  if (item.isDamageable()) {
    return new LootEntryItem(item, 1, 1, new LootFunction[] { setCount(minStackSize, maxStackSize), setDamage(item, meta), setEnergy() }, chanceCond,
        registryName.toString() + ":" + meta);
  } else {
    return new LootEntryItem(item, 1, 1, new LootFunction[] { setCount(minStackSize, maxStackSize), setMetadata(meta) }, chanceCond,
        registryName.toString() + ":" + meta);
  }
}

public static LootPool getLootPool(ResourceLocation res){
    return new LootPool(new LootEntry[]{new LootEntryTable(res, 1, 0, new LootCondition[0], "combined")},
            new LootCondition[0], new RandomValueRange(1), new RandomValueRange(0), "combined");
}

public static List<LootEntry> getEntries(LootPool pool)
{
    return ReflectionHelper.getPrivateValue(LootPool.class, pool, "lootEntries", "field_186453_a");
}

public static void createPoolIfNotExists(LootTable lootTable, String poolId) {
    if (poolId.equals(VANILLA_LOOT_POOL_ID) || lootTable.getPool(poolId) != null) return;
    lootTable.addPool(new LootPool(new LootEntry[] {}, new LootCondition[] {}, new RandomValueRange(1), new RandomValueRange(0), poolId));
}

public FyrestonePool()
{
    super(new LootEntry[0], new LootCondition[0], new RandomValueRange(0, 0), new RandomValueRange(0, 0), VersionInfo.ModName);
}

private static int getVanillaQuality(LootEntry entry) {
    return ReflectionHelper.getPrivateValue(LootEntry.class, entry, "quality", "field_186365_d");
}

private static int getVanillaWeight(LootEntry entry) {
    return ReflectionHelper.getPrivateValue(LootEntry.class, entry, "weight", "field_186364_c");
}

private static LootPool createPool(ResourceLocation injectionEntry) {
    return new LootPool(new LootEntry[] { loadEntry(injectionEntry) }, new LootCondition[0], new RandomValueRange(1), new RandomValueRange(0, 1), "openmods_inject_pool");
}

private static LootEntry loadEntry(ResourceLocation injectionEntry) {
    return new LootEntryTable(injectionEntry, 1, 0, new LootCondition[0], "openmods_inject_entry");
}

private @Nonnull LootEntry createLootEntry(@Nonnull Item item, float chance) {
  return createLootEntry(item, 1, 1, chance);
}

private @Nonnull LootEntry createLootEntry(@Nonnull Item item, int minSize, int maxSize, float chance) {
  return createLootEntry(item, 0, minSize, maxSize, chance);
}

private @Nonnull LootEntry createLootEntry(@Nonnull ItemStack stack, int minStackSize, int maxStackSize, float chance) {
  LootCondition[] chanceCond = new LootCondition[] { new RandomChance(chance) };
  final ResourceLocation registryName = NullHelper.notnull(stack.getItem().getRegistryName(), "found unregistered item");
  return new LootEntryItem(stack.getItem(), 1, 1, new LootFunction[] { setCount(minStackSize, maxStackSize), setMetadata(stack.getMetadata()) }, chanceCond,
      registryName.toString() + ":" + stack.getMetadata());
}

private @Nonnull LootEntry createDarkSteelLootEntry(@Nonnull Item item, float chance) {
  return createDarkSteelLootEntry(item, 1, 1, chance);
}

private @Nonnull LootEntry createDarkSteelLootEntry(@Nonnull Item item, int minSize, int maxSize, float chance) {
  return createDarkSteelLootEntry(item, 0, minSize, maxSize, chance);
}

private @Nonnull LootEntry createDarkSteelLootEntry(@Nonnull Item item, int meta, int minStackSize, int maxStackSize, float chance) {
  LootCondition[] chanceCond = new LootCondition[] { new RandomChance(chance) };
  final ResourceLocation registryName = NullHelper.notnull(item.getRegistryName(), "found unregistered item");
  return new LootEntryItem(item, 1, 1, new LootFunction[] { setCount(minStackSize, maxStackSize), setDamage(item, meta), setUpgrades(), setEnergy() },
      chanceCond, registryName.toString() + ":" + meta);
}

private @Nonnull LootEntry createLootCapacitor(float chance) {
  capCount++;
  return new LootEntryItem(itemBasicCapacitor.getItemNN(), 1, 1, new LootFunction[] { ls, setMetadata(3, 4) },
      new LootCondition[] { new RandomChance(chance) }, itemBasicCapacitor.getUnlocalisedName() + capCount);
}

public static LootEntry deserializeJsonLootEntry(String type, JsonObject json, int weight, int quality, LootCondition[] conditions){ return null; }

public static String getLootEntryType(LootEntry entry){ return null; }