mirror/Slimefun4
mirror/Slimefun4
1
Fork 0
mirror of https://github.com/StarWishsama/Slimefun4.git synced 2024-09-20 03:35:51 +00:00
Code Releases Activity

[CI skip] Improved Cargo Performance a lot (breaks Barrels though)

Browse Source
This commit is contained in:
TheBusyBiscuit 2019-12-19 23:22:09 +01:00
parent f7fa6e2972
commit f9b12dfed5
7 changed files with 350 additions and 360 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
src/main/java/me/mrCookieSlime/Slimefun/api/BlockStorage.java
View File

@ -39,8 +39,8 @@ import me.mrCookieSlime.Slimefun.api.inventory.UniversalBlockMenu;
public class BlockStorage {
private static final String path_blocks = "data-storage/Slimefun/stored-blocks/";
private static final String path_chunks = "data-storage/Slimefun/stored-chunks/";
private static final String PATH_BLOCKS = "data-storage/Slimefun/stored-blocks/";
private static final String PATH_CHUNKS = "data-storage/Slimefun/stored-chunks/";
private World world;
private Map<Location, Config> storage = new HashMap<>();
@ -87,7 +87,7 @@ public class BlockStorage {
Slimefun.getLogger().log(Level.INFO, "Loading Blocks for World \"" + w.getName() + "\"");
Slimefun.getLogger().log(Level.INFO, "This may take a long time...");
File f = new File(path_blocks + w.getName());
File f = new File(PATH_BLOCKS + w.getName());
if (f.exists()) {
long total = f.listFiles().length;
long start = System.currentTimeMillis();
@ -157,7 +157,7 @@ public class BlockStorage {
}
else f.mkdirs();
File chunks = new File(path_chunks + "chunks.sfc");
File chunks = new File(PATH_CHUNKS + "chunks.sfc");
if (chunks.exists()) {
FileConfiguration cfg = YamlConfiguration.loadConfiguration(chunks);
@ -277,8 +277,8 @@ public class BlockStorage {
}
if (chunkChanges > 0) {
File chunks = new File(path_chunks + "chunks.sfc");
Config cfg = new Config(path_chunks + "chunks.temp");
File chunks = new File(PATH_CHUNKS + "chunks.sfc");
Config cfg = new Config(PATH_CHUNKS + "chunks.temp");
for (Map.Entry<String, BlockInfoConfig> entry : SlimefunPlugin.getUtilities().mapChunks.entrySet()) {
cfg.setValue(entry.getKey(), entry.getValue().toJSON());
@ -551,7 +551,7 @@ public class BlockStorage {
}
private static void refreshCache(BlockStorage storage, Location l, String key, String value, boolean updateTicker) {
Config cfg = storage.blocksCache.computeIfAbsent(key, k -> new Config(path_blocks + l.getWorld().getName() + '/' + key + ".sfb"));
Config cfg = storage.blocksCache.computeIfAbsent(key, k -> new Config(PATH_BLOCKS + l.getWorld().getName() + '/' + key + ".sfb"));
cfg.setValue(serializeLocation(l), value);
if (updateTicker) {
@ -672,20 +672,20 @@ public class BlockStorage {
return inventories.containsKey(l);
}
public boolean hasUniversalInventory(String id) {
public static boolean hasUniversalInventory(String id) {
return SlimefunPlugin.getUtilities().universalInventories.containsKey(id);
}
public UniversalBlockMenu getUniversalInventory(Block block) {
public static UniversalBlockMenu getUniversalInventory(Block block) {
return getUniversalInventory(block.getLocation());
}
public UniversalBlockMenu getUniversalInventory(Location l) {
public static UniversalBlockMenu getUniversalInventory(Location l) {
String id = checkID(l);
return id == null ? null: getUniversalInventory(id);
}
public UniversalBlockMenu getUniversalInventory(String id) {
public static UniversalBlockMenu getUniversalInventory(String id) {
return SlimefunPlugin.getUtilities().universalInventories.get(id);
}
@ -693,11 +693,19 @@ public class BlockStorage {
return getInventory(b.getLocation());
}
public static boolean hasInventory(Block b) {
BlockStorage storage = getStorage(b.getWorld());
if (storage == null) return false;
else return storage.hasInventory(b.getLocation());
}
public static BlockMenu getInventory(Location l) {
BlockStorage storage = getStorage(l.getWorld());
if (storage == null) return null;
if (!storage.hasInventory(l)) return storage.loadInventory(l, BlockMenuPreset.getPreset(checkID(l)));
else return storage.inventories.get(l);
BlockMenu menu = storage.inventories.get(l);
if (menu != null) return menu;
else return storage.loadInventory(l, BlockMenuPreset.getPreset(checkID(l)));
}
public static Config getChunkInfo(Chunk chunk) {

99
src/main/java/me/mrCookieSlime/Slimefun/api/inventory/BlockMenu.java
View File

@ -1,47 +1,33 @@
package me.mrCookieSlime.Slimefun.api.inventory;
import java.io.File;
import java.util.ArrayList;
import java.util.logging.Level;
import org.bukkit.Location;
import org.bukkit.block.Block;
import org.bukkit.entity.HumanEntity;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import io.github.thebusybiscuit.cscorelib2.inventory.InvUtils;
import io.github.thebusybiscuit.cscorelib2.inventory.ItemUtils;
import me.mrCookieSlime.CSCoreLibPlugin.Configuration.Config;
import me.mrCookieSlime.CSCoreLibPlugin.general.Inventory.Item.CustomItem;
import me.mrCookieSlime.Slimefun.api.Slimefun;
public class BlockMenu extends DirtyChestMenu {
private BlockMenuPreset preset;
private Location l;
private ItemManipulationEvent event;
private Location location;
private static String serializeLocation(Location l) {
return l.getWorld().getName() + ';' + l.getBlockX() + ';' + l.getBlockY() + ';' + l.getBlockZ();
}
public BlockMenu(BlockMenuPreset preset, Location l) {
super(preset.getTitle());
this.preset = preset;
this.l = l;
changes = 1;
super(preset);
this.location = l;
preset.clone(this);
this.getContents();
}
public BlockMenu(BlockMenuPreset preset, Location l, Config cfg) {
super(preset.getTitle());
this.preset = preset;
this.l = l;
super(preset);
this.location = l;
for (int i = 0; i < 54; i++) {
if (cfg.contains(String.valueOf(i))) addItem(i, cfg.getItem(String.valueOf(i)));
@ -49,13 +35,11 @@ public class BlockMenu extends DirtyChestMenu {
preset.clone(this);
if (preset.getSize() > -1 && !preset.getPresetSlots().contains(preset.getSize() - 1) && cfg.contains(String.valueOf(preset.getSize() - 1))) addItem(preset.getSize() - 1, cfg.getItem(String.valueOf(preset.getSize() - 1)));
this.getContents();
if (preset.getSize() > -1 && !preset.getPresetSlots().contains(preset.getSize() - 1) && cfg.contains(String.valueOf(preset.getSize() - 1))) {
addItem(preset.getSize() - 1, cfg.getItem(String.valueOf(preset.getSize() - 1)));
}
public void registerEvent(ItemManipulationEvent event) {
this.event = event;
this.getContents();
}
public void save(Location l) {
@ -69,9 +53,11 @@ public class BlockMenu extends DirtyChestMenu {
File file = new File("data-storage/Slimefun/stored-inventories/" + serializeLocation(l) + ".sfi");
Config cfg = new Config(file);
cfg.setValue("preset", preset.getID());
for (int slot : preset.getInventorySlots()) {
cfg.setValue(String.valueOf(slot), getItemInSlot(slot));
}
cfg.save();
changes = 0;
@ -83,18 +69,18 @@ public class BlockMenu extends DirtyChestMenu {
}
public void move(Location l) {
this.delete(this.l);
this.l = l;
this.delete(this.location);
this.location = l;
this.preset.newInstance(this, l);
this.save(l);
}
public Block getBlock() {
return this.l.getBlock();
return this.location.getBlock();
}
public Location getLocation() {
return l;
return location;
}
public void delete(Location l) {
@ -104,61 +90,4 @@ public class BlockMenu extends DirtyChestMenu {
Slimefun.getLogger().log(Level.WARNING, "Could not delete File: " + file.getName());
}
}
public BlockMenuPreset getPreset() {
return this.preset;
}
public boolean canOpen(Block b, Player p) {
return this.preset.canOpen(b, p);
}
@Override
public void replaceExistingItem(int slot, ItemStack item) {
this.replaceExistingItem(slot, item, true);
}
public void replaceExistingItem(int slot, ItemStack item, boolean event) {
final ItemStack previous = getItemInSlot(slot);
if (event && this.event != null) {
item = this.event.onEvent(slot, previous, item);
}
super.replaceExistingItem(slot, item);
markDirty();
}
public boolean fits(ItemStack item, int... slots) {
return InvUtils.fits(toInventory(), item, slots);
}
public ItemStack pushItem(ItemStack item, int... slots) {
int amount = item.getAmount();
for (int slot: slots) {
if (amount <= 0) break;
ItemStack stack = getItemInSlot(slot);
if (stack == null) {
replaceExistingItem(slot, item);
return null;
}
else if (stack.getAmount() < stack.getMaxStackSize() && ItemUtils.canStack(item, stack)) {
amount -= (stack.getMaxStackSize() - stack.getAmount());
stack.setAmount(Math.min(stack.getAmount() + item.getAmount(), stack.getMaxStackSize()));
}
}
if (amount > 0) {
return new CustomItem(item, amount);
}
else {
return null;
}
}
public void close() {
for (HumanEntity human: new ArrayList<>(toInventory().getViewers())) {
human.closeInventory();
}
}
}

14
src/main/java/me/mrCookieSlime/Slimefun/api/inventory/BlockMenuPreset.java
View File

@ -54,12 +54,17 @@ public abstract class BlockMenuPreset extends ChestMenu {
// This method can optionally be overridden by implementations
}
@Deprecated
public int[] getSlotsAccessedByItemTransport(BlockMenu menu, ItemTransportFlow flow, ItemStack item) {
// This method will default to this method, can be overridden though
return this.getSlotsAccessedByItemTransport(flow);
return getSlotsAccessedByItemTransport((DirtyChestMenu) menu, flow, item);
}
@Deprecated
public int[] getSlotsAccessedByItemTransport(UniversalBlockMenu menu, ItemTransportFlow flow, ItemStack item) {
return getSlotsAccessedByItemTransport((DirtyChestMenu) menu, flow, item);
}
public int[] getSlotsAccessedByItemTransport(DirtyChestMenu menu, ItemTransportFlow flow, ItemStack item) {
// This method will default to this method, can be overridden though
return this.getSlotsAccessedByItemTransport(flow);
}
@ -130,7 +135,9 @@ public abstract class BlockMenuPreset extends ChestMenu {
newInstance(menu, menu.getLocation());
for (int slot = 0; slot < 54; slot++) {
if (getMenuClickHandler(slot) != null) menu.addMenuClickHandler(slot, getMenuClickHandler(slot));
if (getMenuClickHandler(slot) != null) {
menu.addMenuClickHandler(slot, getMenuClickHandler(slot));
}
}
menu.addMenuOpeningHandler(getMenuOpeningHandler());
@ -146,6 +153,7 @@ public abstract class BlockMenuPreset extends ChestMenu {
}
if (size > -1) menu.addItem(size - 1, null);
for (int slot = 0; slot < 54; slot++) {
if (getMenuClickHandler(slot) != null) menu.addMenuClickHandler(slot, getMenuClickHandler(slot));
}

82
src/main/java/me/mrCookieSlime/Slimefun/api/inventory/DirtyChestMenu.java
View File

@ -1,15 +1,27 @@
package me.mrCookieSlime.Slimefun.api.inventory;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import org.bukkit.block.Block;
import org.bukkit.entity.HumanEntity;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import io.github.thebusybiscuit.cscorelib2.inventory.InvUtils;
import io.github.thebusybiscuit.cscorelib2.inventory.ItemUtils;
import me.mrCookieSlime.CSCoreLibPlugin.general.Inventory.ChestMenu;
import me.mrCookieSlime.CSCoreLibPlugin.general.Inventory.Item.CustomItem;
public class DirtyChestMenu extends ChestMenu {
protected int changes = 0;
protected final BlockMenuPreset preset;
protected ItemManipulationEvent event;
protected int changes = 1;
public DirtyChestMenu(String title) {
super(title);
public DirtyChestMenu(BlockMenuPreset preset) {
super(preset.getTitle());
this.preset = preset;
}
public void markDirty() {
@ -24,6 +36,24 @@ public class DirtyChestMenu extends ChestMenu {
return changes;
}
public BlockMenuPreset getPreset() {
return this.preset;
}
public boolean canOpen(Block b, Player p) {
return this.preset.canOpen(b, p);
}
public void close() {
for (HumanEntity human : new ArrayList<>(toInventory().getViewers())) {
human.closeInventory();
}
}
public void registerEvent(ItemManipulationEvent event) {
this.event = event;
}
@Override
public ChestMenu addMenuOpeningHandler(MenuOpeningHandler handler) {
if (handler instanceof SaveHandler) {
@ -34,6 +64,50 @@ public class DirtyChestMenu extends ChestMenu {
}
}
public boolean fits(ItemStack item, int... slots) {
return InvUtils.fits(toInventory(), item, slots);
}
public ItemStack pushItem(ItemStack item, int... slots) {
int amount = item.getAmount();
for (int slot : slots) {
if (amount <= 0) break;
ItemStack stack = getItemInSlot(slot);
if (stack == null) {
replaceExistingItem(slot, item);
return null;
}
else if (stack.getAmount() < stack.getMaxStackSize() && ItemUtils.canStack(item, stack)) {
amount -= (stack.getMaxStackSize() - stack.getAmount());
stack.setAmount(Math.min(stack.getAmount() + item.getAmount(), stack.getMaxStackSize()));
}
}
if (amount > 0) {
return new CustomItem(item, amount);
}
else {
return null;
}
}
@Override
public void replaceExistingItem(int slot, ItemStack item) {
this.replaceExistingItem(slot, item, true);
}
public void replaceExistingItem(int slot, ItemStack item, boolean event) {
ItemStack previous = getItemInSlot(slot);
if (event && this.event != null) {
item = this.event.onEvent(slot, previous, item);
}
super.replaceExistingItem(slot, item);
markDirty();
}
public static class SaveHandler implements MenuOpeningHandler {
private DirtyChestMenu menu;

59
src/main/java/me/mrCookieSlime/Slimefun/api/inventory/UniversalBlockMenu.java
View File

@ -1,24 +1,13 @@
package me.mrCookieSlime.Slimefun.api.inventory;
import java.io.File;
import java.util.ArrayList;
import org.bukkit.block.Block;
import org.bukkit.entity.HumanEntity;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import me.mrCookieSlime.CSCoreLibPlugin.Configuration.Config;
public class UniversalBlockMenu extends DirtyChestMenu {
private BlockMenuPreset preset;
private ItemManipulationEvent event;
public UniversalBlockMenu(BlockMenuPreset preset) {
super(preset.getTitle());
this.preset = preset;
changes = 1;
super(preset);
preset.clone(this);
@ -26,22 +15,21 @@ public class UniversalBlockMenu extends DirtyChestMenu {
}
public UniversalBlockMenu(BlockMenuPreset preset, Config cfg) {
super(preset.getTitle());
this.preset = preset;
super(preset);
for (int i = 0; i < 54; i++) {
if (cfg.contains(String.valueOf(i))) addItem(i, cfg.getItem(String.valueOf(i)));
if (cfg.contains(String.valueOf(i))) {
addItem(i, cfg.getItem(String.valueOf(i)));
}
}
preset.clone(this);
if (preset.getSize() > -1 && !preset.getPresetSlots().contains(preset.getSize() - 1) && cfg.contains(String.valueOf(preset.getSize() - 1))) addItem(preset.getSize() - 1, cfg.getItem(String.valueOf(preset.getSize() - 1)));
this.getContents();
if (preset.getSize() > -1 && !preset.getPresetSlots().contains(preset.getSize() - 1) && cfg.contains(String.valueOf(preset.getSize() - 1))) {
addItem(preset.getSize() - 1, cfg.getItem(String.valueOf(preset.getSize() - 1)));
}
public void registerEvent(ItemManipulationEvent event) {
this.event = event;
this.getContents();
}
public void save() {
@ -52,41 +40,14 @@ public class UniversalBlockMenu extends DirtyChestMenu {
File file = new File("data-storage/Slimefun/universal-inventories/" + preset.getID() + ".sfi");
Config cfg = new Config(file);
cfg.setValue("preset", preset.getID());
for (int slot : preset.getInventorySlots()) {
cfg.setValue(String.valueOf(slot), getItemInSlot(slot));
}
cfg.save();
changes = 0;
}
public BlockMenuPreset getPreset() {
return this.preset;
}
public boolean canOpen(Block b, Player p) {
return this.preset.canOpen(b, p);
}
@Override
public void replaceExistingItem(int slot, ItemStack item) {
this.replaceExistingItem(slot, item, true);
}
public void replaceExistingItem(int slot, ItemStack item, boolean event) {
final ItemStack previous = getItemInSlot(slot);
if (event && this.event != null) {
item = this.event.onEvent(slot, previous, item);
}
super.replaceExistingItem(slot, item);
markDirty();
}
public void close() {
for (HumanEntity human: new ArrayList<>(toInventory().getViewers())) {
human.closeInventory();
}
}
}

129
src/main/java/me/mrCookieSlime/Slimefun/api/item_transport/CargoManager.java
View File

@ -4,26 +4,33 @@ import java.util.ArrayList;
import java.util.List;
import org.bukkit.block.Block;
import org.bukkit.block.BlockState;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.InventoryHolder;
import org.bukkit.inventory.ItemStack;
import io.github.thebusybiscuit.cscorelib2.item.CustomItem;
import me.mrCookieSlime.CSCoreLibPlugin.Configuration.Config;
import me.mrCookieSlime.CSCoreLibPlugin.general.Inventory.Item.CustomItem;
import me.mrCookieSlime.Slimefun.Setup.SlimefunManager;
import me.mrCookieSlime.Slimefun.api.BlockStorage;
import me.mrCookieSlime.Slimefun.api.inventory.BlockMenu;
import me.mrCookieSlime.Slimefun.api.inventory.DirtyChestMenu;
import me.mrCookieSlime.Slimefun.api.inventory.UniversalBlockMenu;
public final class CargoManager {
//Whitelist or blacklist slots
private static final int[] SLOTS = new int[] {19, 20, 21, 28, 29, 30, 37, 38, 39};
private CargoManager() {}
public static ItemStack withdraw(Block node, BlockStorage storage, Block target, ItemStack template) {
if (storage.hasUniversalInventory(target)) {
UniversalBlockMenu menu = storage.getUniversalInventory(target);
public static ItemStack withdraw(Block node, Block target, ItemStack template) {
DirtyChestMenu menu = getChestMenu(target);
if (menu != null) {
for (int slot : menu.getPreset().getSlotsAccessedByItemTransport(menu, ItemTransportFlow.WITHDRAW, null)) {
final ItemStack is = menu.getItemInSlot(slot);
ItemStack is = menu.getItemInSlot(slot);
if (SlimefunManager.isItemSimilar(is, template, true) && matchesFilter(node, is, -1)) {
if (is.getAmount() > template.getAmount()) {
menu.replaceExistingItem(slot, new CustomItem(is, is.getAmount() - template.getAmount()));
@ -36,26 +43,14 @@ public final class CargoManager {
}
}
}
else if (storage.hasInventory(target.getLocation())) {
BlockMenu menu = BlockStorage.getInventory(target.getLocation());
for (int slot: menu.getPreset().getSlotsAccessedByItemTransport(menu, ItemTransportFlow.WITHDRAW, null)) {
final ItemStack is = menu.getItemInSlot(slot);
if (SlimefunManager.isItemSimilar(is, template, true) && matchesFilter(node, is, -1)) {
if (is.getAmount() > template.getAmount()) {
menu.replaceExistingItem(slot, new CustomItem(is, is.getAmount() - template.getAmount()));
return template;
}
else {
menu.replaceExistingItem(slot, null);
return is.clone();
}
}
}
}
else if (target.getState() instanceof InventoryHolder) {
Inventory inv = ((InventoryHolder) target.getState()).getInventory();
BlockState state = target.getState();
if (state instanceof InventoryHolder) {
Inventory inv = ((InventoryHolder) state).getInventory();
for (int slot = 0; slot < inv.getContents().length; slot++) {
final ItemStack is = inv.getContents()[slot];
ItemStack is = inv.getContents()[slot];
if (SlimefunManager.isItemSimilar(is, template, true) && matchesFilter(node, is, -1)) {
if (is.getAmount() > template.getAmount()) {
inv.setItem(slot, ChestManipulator.trigger(target, slot, is, new CustomItem(is, is.getAmount() - template.getAmount())));
@ -68,49 +63,51 @@ public final class CargoManager {
}
}
}
}
return null;
}
public static ItemSlot withdraw(Block node, BlockStorage storage, Block target, int index) {
if (storage.hasUniversalInventory(target)) {
UniversalBlockMenu menu = storage.getUniversalInventory(target);
public static ItemSlot withdraw(Block node, Block target, int index) {
DirtyChestMenu menu = getChestMenu(target);
if (menu != null) {
for (int slot : menu.getPreset().getSlotsAccessedByItemTransport(menu, ItemTransportFlow.WITHDRAW, null)) {
ItemStack is = menu.getItemInSlot(slot);
if (matchesFilter(node, is, index)) {
menu.replaceExistingItem(slot, null);
return new ItemSlot(is.clone(), slot);
}
}
}
else if (storage.hasInventory(target.getLocation())) {
BlockMenu menu = BlockStorage.getInventory(target.getLocation());
for (int slot: menu.getPreset().getSlotsAccessedByItemTransport(menu, ItemTransportFlow.WITHDRAW, null)) {
ItemStack is = menu.getItemInSlot(slot);
if (matchesFilter(node, is, index)) {
menu.replaceExistingItem(slot, null);
return new ItemSlot(is.clone(), slot);
}
}
}
else if (target.getState() instanceof InventoryHolder) {
Inventory inv = ((InventoryHolder) target.getState()).getInventory();
else {
BlockState state = target.getState();
if (state instanceof InventoryHolder) {
Inventory inv = ((InventoryHolder) state).getInventory();
for (int slot = 0; slot < inv.getContents().length; slot++) {
ItemStack is = inv.getContents()[slot];
if (matchesFilter(node, is, index)) {
inv.setItem(slot, ChestManipulator.trigger(target, slot, is, null));
return new ItemSlot(is.clone(), slot);
}
}
}
}
return null;
}
public static ItemStack insert(Block node, BlockStorage storage, Block target, ItemStack stack, int index) {
public static ItemStack insert(Block node, Block target, ItemStack stack, int index) {
if (!matchesFilter(node, stack, index)) return stack;
if (storage.hasUniversalInventory(target)) {
UniversalBlockMenu menu = storage.getUniversalInventory(target);
DirtyChestMenu menu = getChestMenu(target);
if (menu != null) {
for (int slot : menu.getPreset().getSlotsAccessedByItemTransport(menu, ItemTransportFlow.INSERT, stack)) {
ItemStack is = menu.getItemInSlot(slot) == null ? null: menu.getItemInSlot(slot).clone();
if (is == null) {
menu.replaceExistingItem(slot, stack.clone());
return null;
@ -132,43 +129,21 @@ public final class CargoManager {
}
}
}
else if (storage.hasInventory(target.getLocation())) {
BlockMenu menu = BlockStorage.getInventory(target.getLocation());
for (int slot: menu.getPreset().getSlotsAccessedByItemTransport(menu, ItemTransportFlow.INSERT, stack)) {
ItemStack is = menu.getItemInSlot(slot) == null ? null: menu.getItemInSlot(slot).clone();
if (is == null) {
menu.replaceExistingItem(slot, stack.clone());
return null;
}
else if (SlimefunManager.isItemSimilar(new CustomItem(is, 1), new CustomItem(stack, 1), true) && is.getAmount() < is.getType().getMaxStackSize()) {
int amount = is.getAmount() + stack.getAmount();
if (amount > is.getType().getMaxStackSize()) {
is.setAmount(is.getType().getMaxStackSize());
stack.setAmount(amount - is.getType().getMaxStackSize());
}
else {
is.setAmount(amount);
stack = null;
}
menu.replaceExistingItem(slot, is);
return stack;
}
}
}
else if (target.getState() instanceof InventoryHolder) {
Inventory inv = ((InventoryHolder) target.getState()).getInventory();
BlockState state = target.getState();
if (state instanceof InventoryHolder) {
Inventory inv = ((InventoryHolder) state).getInventory();
for (int slot = 0; slot < inv.getContents().length; slot++) {
ItemStack is = inv.getContents()[slot];
if (is == null) {
inv.setItem(slot, ChestManipulator.trigger(target, slot, null, stack.clone()));
return null;
}
else if (SlimefunManager.isItemSimilar(new CustomItem(is, 1), new CustomItem(stack, 1), true) && is.getAmount() < is.getType().getMaxStackSize()) {
ItemStack prev = is.clone();
int amount = is.getAmount() + stack.getAmount();
ItemStack prev = is.clone();
if (amount > is.getType().getMaxStackSize()) {
is.setAmount(is.getType().getMaxStackSize());
@ -184,11 +159,21 @@ public final class CargoManager {
}
}
}
}
return stack;
}
//Whitelist or blacklist slots
private static int[] slots = new int[] {19, 20, 21, 28, 29, 30, 37, 38, 39};
public static DirtyChestMenu getChestMenu(Block block) {
if (BlockStorage.hasInventory(block)) {
return BlockStorage.getInventory(block);
}
UniversalBlockMenu universalMenu = BlockStorage.getUniversalInventory(block);
if (universalMenu != null) return universalMenu;
return null;
}
public static boolean matchesFilter(Block block, ItemStack item, int index) {
if (item == null) return false;
@ -205,7 +190,7 @@ public final class CargoManager {
if ("whitelist".equals(blockInfo.getString("filter-type"))) {
List<ItemStack> items = new ArrayList<>();
for (int slot: slots) {
for (int slot : SLOTS) {
ItemStack template = menu.getItemInSlot(slot);
if (template != null) items.add(new CustomItem(template, 1));
}
@ -230,7 +215,7 @@ public final class CargoManager {
}
}
else {
for (int slot: slots) {
for (int slot : SLOTS) {
if (menu.getItemInSlot(slot) != null && SlimefunManager.isItemSimilar(item, new CustomItem(menu.getItemInSlot(slot), 1), lore)) {
return false;
}

121
src/main/java/me/mrCookieSlime/Slimefun/api/item_transport/CargoNet.java
View File

@ -11,11 +11,11 @@ import java.util.Map;
import java.util.Set;
import java.util.logging.Level;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.block.BlockState;
import org.bukkit.block.data.Directional;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.InventoryHolder;
@ -23,6 +23,7 @@ import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.ItemMeta;
import io.github.thebusybiscuit.cscorelib2.math.DoubleHandler;
import me.mrCookieSlime.CSCoreLibPlugin.Configuration.Config;
import me.mrCookieSlime.CSCoreLibPlugin.general.Inventory.ChestMenu.MenuClickHandler;
import me.mrCookieSlime.CSCoreLibPlugin.general.Inventory.Item.CustomItem;
import me.mrCookieSlime.Slimefun.SlimefunPlugin;
@ -30,6 +31,7 @@ import me.mrCookieSlime.Slimefun.Setup.SlimefunManager;
import me.mrCookieSlime.Slimefun.api.BlockStorage;
import me.mrCookieSlime.Slimefun.api.Slimefun;
import me.mrCookieSlime.Slimefun.api.inventory.BlockMenu;
import me.mrCookieSlime.Slimefun.api.inventory.DirtyChestMenu;
import me.mrCookieSlime.Slimefun.api.inventory.UniversalBlockMenu;
import me.mrCookieSlime.Slimefun.api.network.Network;
import me.mrCookieSlime.Slimefun.api.network.NetworkComponent;
@ -51,16 +53,26 @@ public class CargoNet extends Network {
private static final ItemStack terminal_noitem_item = new CustomItem(new ItemStack(Material.BARRIER), "&4No Item cached");
private static final MenuClickHandler terminal_noitem_handler = (p, slot, item, action) -> false;
private Set<Location> inputNodes = new HashSet<>();
private Set<Location> outputNodes = new HashSet<>();
//Chest Terminal Stuff
private final Set<Location> terminals = new HashSet<>();
private final Set<Location> imports = new HashSet<>();
private final Set<Location> exports = new HashSet<>();
public static CargoNet getNetworkFromLocation(Location l) {
return getNetworkFromLocation(l, CargoNet.class);
}
public static CargoNet getNetworkFromLocationOrCreate(Location l) {
CargoNet cargoNetwork = getNetworkFromLocation(l);
if (cargoNetwork == null) {
cargoNetwork = new CargoNet(l);
registerNetwork(cargoNetwork);
}
return cargoNetwork;
}
@ -69,15 +81,6 @@ public class CargoNet extends Network {
return getNetworkFromLocation(b.getLocation()) != null;
}
private Set<Location> inputNodes = new HashSet<>();
private Set<Location> outputNodes = new HashSet<>();
//Chest Terminal Stuff
private final Set<Location> terminals = new HashSet<>();
private final Set<Location> imports = new HashSet<>();
private final Set<Location> exports = new HashSet<>();
protected CargoNet(Location l) {
super(l);
}
@ -89,6 +92,7 @@ public class CargoNet extends Network {
public NetworkComponent classifyLocation(Location l) {
String id = BlockStorage.checkID(l);
if (id == null) return null;
switch(id) {
case "CARGO_MANAGER":
return NetworkComponent.REGULATOR;
@ -143,13 +147,15 @@ public class CargoNet extends Network {
SimpleHologram.update(b, "&4Multiple Cargo Regulators connected");
return;
}
super.tick();
if (connectorNodes.isEmpty() && terminusNodes.isEmpty()) {
SimpleHologram.update(b, "&7Status: &4&lOFFLINE");
SimpleHologram.update(b, "&cNo Cargo Nodes found");
}
else {
SimpleHologram.update(b, "&7Status: &a&lONLINE");
final Map<Integer, List<Location>> output = new HashMap<>();
Map<Integer, List<Location>> output = new HashMap<>();
List<Location> list = new LinkedList<>();
int lastFrequency = -1;
@ -178,26 +184,24 @@ public class CargoNet extends Network {
}
//Chest Terminal Stuff
final Set<Location> providers = new HashSet<>();
final Set<Location> destinations = new HashSet<>();
Set<Location> providers = new HashSet<>();
Set<Location> destinations = new HashSet<>();
List<Location> output16 = output.get(16);
if (output16 != null) destinations.addAll(output16);
for (Location inputNode : inputNodes) {
int frequency = getFrequency(inputNode);
if (frequency == 16) {
providers.add(inputNode);
}
}
CargoNet self = this;
final BlockStorage storage = BlockStorage.getStorage(b.getWorld());
Bukkit.getScheduler().scheduleSyncDelayedTask(SlimefunPlugin.instance, () -> {
Slimefun.runSync(() -> {
if (BlockStorage.getLocationInfo(b.getLocation(), "visualizer") == null) {
self.display();
display();
}
//Chest Terminal Code
@ -207,7 +211,7 @@ public class CargoNet extends Network {
if (menu.getItemInSlot(17) == null) {
Block target = getAttachedBlock(bus.getBlock());
ItemSlot stack = CargoManager.withdraw(bus.getBlock(), storage, target, -1);
ItemSlot stack = CargoManager.withdraw(bus.getBlock(), target, -1);
if (stack != null) {
menu.replaceExistingItem(17, stack.getItem());
@ -225,7 +229,7 @@ public class CargoNet extends Network {
if (menu.getItemInSlot(17) != null) {
Block target = getAttachedBlock(bus.getBlock());
menu.replaceExistingItem(17, CargoManager.insert(bus.getBlock(), storage, target, menu.getItemInSlot(17), -1));
menu.replaceExistingItem(17, CargoManager.insert(bus.getBlock(), target, menu.getItemInSlot(17), -1));
}
if (menu.getItemInSlot(17) == null) {
@ -247,7 +251,7 @@ public class CargoNet extends Network {
}
}
for (final Location terminal : terminals) {
for (Location terminal : terminals) {
BlockMenu menu = BlockStorage.getInventory(terminal);
ItemStack sendingItem = menu.getItemInSlot(TERMINAL_OUT_SLOT);
@ -269,7 +273,8 @@ public class CargoNet extends Network {
for (Location l : destinations) {
Block target = getAttachedBlock(l.getBlock());
requestedItem = CargoManager.insert(l.getBlock(), storage, target, requestedItem, -1);
requestedItem = CargoManager.insert(l.getBlock(), target, requestedItem, -1);
if (requestedItem == null) {
menu.replaceExistingItem(request.getSlot(), null);
break;
@ -296,7 +301,8 @@ public class CargoNet extends Network {
for (Location l : providers) {
Block target = getAttachedBlock(l.getBlock());
ItemStack is = CargoManager.withdraw(l.getBlock(), storage, target, requested);
ItemStack is = CargoManager.withdraw(l.getBlock(), target, requested);
if (is != null) {
if (stack == null) {
stack = is;
@ -342,10 +348,12 @@ public class CargoNet extends Network {
ItemStack stack = null;
int previousSlot = -1;
boolean roundrobin = "true".equals(BlockStorage.getLocationInfo(input, "round-robin"));
Config cfg = BlockStorage.getLocationInfo(input);
boolean roundrobin = "true".equals(cfg.getString("round-robin"));
if (inputTarget != null) {
ItemSlot slot = CargoManager.withdraw(input.getBlock(), storage, inputTarget, Integer.parseInt(BlockStorage.getLocationInfo(input, "index")));
ItemSlot slot = CargoManager.withdraw(input.getBlock(), inputTarget, Integer.parseInt(cfg.getString("index")));
if (slot != null) {
stack = slot.getItem();
previousSlot = slot.getSlot();
@ -354,6 +362,7 @@ public class CargoNet extends Network {
if (stack != null) {
List<Location> outputs = output.get(frequency);
if (outputs != null) {
List<Location> outputlist = new ArrayList<>(outputs);
@ -362,7 +371,7 @@ public class CargoNet extends Network {
if (cIndex < outputlist.size()) {
for (int i = 0; i < cIndex; i++) {
final Location temp = outputlist.get(0);
Location temp = outputlist.get(0);
outputlist.remove(temp);
outputlist.add(temp);
}
@ -375,8 +384,9 @@ public class CargoNet extends Network {
for (Location out : outputlist) {
Block target = getAttachedBlock(out.getBlock());
if (target != null) {
stack = CargoManager.insert(out.getBlock(), storage, target, stack, -1);
stack = CargoManager.insert(out.getBlock(), target, stack, -1);
if (stack == null) break;
}
}
@ -384,40 +394,48 @@ public class CargoNet extends Network {
}
if (stack != null && previousSlot > -1) {
if (storage.hasUniversalInventory(inputTarget)) {
UniversalBlockMenu menu = storage.getUniversalInventory(inputTarget);
DirtyChestMenu menu = CargoManager.getChestMenu(inputTarget);
if (menu != null) {
menu.replaceExistingItem(previousSlot, stack);
}
else if (storage.hasInventory(inputTarget.getLocation())) {
BlockMenu menu = BlockStorage.getInventory(inputTarget.getLocation());
menu.replaceExistingItem(previousSlot, stack);
}
else if (inputTarget.getState() instanceof InventoryHolder) {
Inventory inv = ((InventoryHolder) inputTarget.getState()).getInventory();
else {
BlockState state = inputTarget.getState();
if (state instanceof InventoryHolder) {
Inventory inv = ((InventoryHolder) state).getInventory();
inv.setItem(previousSlot, stack);
}
}
}
}
//Chest Terminal Code
if (extraChannels) {
List<StoredItem> items = new ArrayList<>();
for (Location l : providers) {
Block target = getAttachedBlock(l.getBlock());
if (storage.hasUniversalInventory(target)) {
UniversalBlockMenu menu = storage.getUniversalInventory(target);
UniversalBlockMenu menu = BlockStorage.getUniversalInventory(target);
if (menu != null) {
for (int slot : menu.getPreset().getSlotsAccessedByItemTransport(menu, ItemTransportFlow.WITHDRAW, null)) {
ItemStack is = menu.getItemInSlot(slot);
filter(is, items, l);
}
}
else if (storage.hasInventory(target.getLocation())) {
BlockMenu menu = BlockStorage.getInventory(target.getLocation());
if (BlockStorage.checkID(target.getLocation()).startsWith("BARREL_") && BlockStorage.getLocationInfo(target.getLocation(), "storedItems") != null) {
int stored = Integer.parseInt(BlockStorage.getLocationInfo(target.getLocation(), "storedItems"));
for (int slot: menu.getPreset().getSlotsAccessedByItemTransport(menu, ItemTransportFlow.WITHDRAW, null)) {
ItemStack is = menu.getItemInSlot(slot);
else if (BlockStorage.hasInventory(target)) {
BlockMenu blockMenu = BlockStorage.getInventory(target);
Config cfg = BlockStorage.getLocationInfo(target.getLocation());
if (cfg.getString("id").startsWith("BARREL_") && cfg.getString("storedItems") != null) {
int stored = Integer.parseInt(cfg.getString("storedItems"));
for (int slot : blockMenu.getPreset().getSlotsAccessedByItemTransport(blockMenu, ItemTransportFlow.WITHDRAW, null)) {
ItemStack is = blockMenu.getItemInSlot(slot);
if (is != null && CargoManager.matchesFilter(l.getBlock(), is, -1)) {
boolean add = true;
for (StoredItem item : items) {
if (SlimefunManager.isItemSimilar(is, item.getItem(), true)) {
add = false;
@ -432,20 +450,25 @@ public class CargoNet extends Network {
}
}
else {
handleWithdraw(menu, items, l);
handleWithdraw(blockMenu, items, l);
}
}
else if (target.getState() instanceof InventoryHolder) {
Inventory inv = ((InventoryHolder) target.getState()).getInventory();
else {
BlockState state = target.getState();
if (state instanceof InventoryHolder) {
Inventory inv = ((InventoryHolder) state).getInventory();
for (ItemStack is : inv.getContents()) {
filter(is, items, l);
}
}
}
}
Collections.sort(items, sorter);
for (final Location l: terminals) {
for (Location l : terminals) {
BlockMenu menu = BlockStorage.getInventory(l);
int page = Integer.parseInt(BlockStorage.getLocationInfo(l, "page"));
@ -456,6 +479,7 @@ public class CargoNet extends Network {
for (int i = 0; i < terminal_slots.length; i++) {
int slot = terminal_slots[i];
if (items.size() > i + (terminal_slots.length * (page - 1))) {
final StoredItem item = items.get(i + (terminal_slots.length * (page - 1)));
@ -520,6 +544,7 @@ public class CargoNet extends Network {
private void filter(ItemStack is, List<StoredItem> items, Location l) {
if (is != null && CargoManager.matchesFilter(l.getBlock(), is, -1)) {
boolean add = true;
for (StoredItem item : items) {
if (SlimefunManager.isItemSimilar(is, item.getItem(), true)) {
add = false;