sigonasr2/TwosideKeeper
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Implemented Graphs to prevent Item Cube nesting loss and optimized

Browse Source 
Vacuum and Filter Cubes.
This commit is contained in:
sigonasr2 2017-04-03 23:45:45 -05:00
parent 942654e0d1
commit 1fa2a080c8
15 changed files with 712 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.classpath
View File

@ -1,6 +1,7 @@
<?xml version="1.0" encoding="UTF-8"?>
<classpath>
<classpathentry kind="src" path="src"/>
<classpathentry kind="src" path="jgrapht"/>
<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
<classpathentry kind="lib" path="D:/Documents/Test Server/plugins/AutoPluginUpdate.jar"/>
<classpathentry kind="lib" path="D:/Documents/Test Server/plugins/GlowAPI_v1.4.4.jar"/>

7
.project
View File

@ -24,4 +24,11 @@
<natures>
<nature>org.eclipse.jdt.core.javanature</nature>
</natures>
<linkedResources>
<link>
<name>jgrapht</name>
<type>2</type>
<location>D:/Data/jgrapht-1.0.1/jgrapht-1.0.1/source/jgrapht-core/src/main/java</location>
</link>
</linkedResources>
</projectDescription>

BIN
TwosideKeeper.jar
View File

Binary file not shown.

55
src/sig/plugin/TwosideKeeper/Events/InventoryUpdateEvent.java Normal file
View File

@ -0,0 +1,55 @@
package sig.plugin.TwosideKeeper.Events;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
import org.bukkit.inventory.ItemStack;
import sig.plugin.TwosideKeeper.TwosideKeeper;
public class InventoryUpdateEvent extends Event{
private Player p;
private ItemStack item;
private static final HandlerList handlers = new HandlerList();
private UpdateReason reason;
@Override
public HandlerList getHandlers() {
return handlers;
}
public static HandlerList getHandlerList() {
return handlers;
}
public InventoryUpdateEvent(Player p, ItemStack item, UpdateReason reason) {
this.p=p;
this.item=item;
this.reason=reason;
}
public Player getPlayer() {
return p;
}
public ItemStack getItemStack() {
return item;
}
public UpdateReason getReason() {
return reason;
}
public static void TriggerUpdateInventoryEvent(Player p, ItemStack item, UpdateReason reason) {
InventoryUpdateEvent ev = new InventoryUpdateEvent(p, item, reason);
Bukkit.getPluginManager().callEvent(ev);
//TwosideKeeper.log("Triggered because of "+reason, 0);
}
public enum UpdateReason {
INVENTORYUPDATE,
PICKEDUPITEM,
DROPPEDITEM
}
}

5
src/sig/plugin/TwosideKeeper/HelperStructures/Common/GenericFunctions.java
View File

@ -5122,10 +5122,11 @@ public class GenericFunctions {
return PlayerStructure.GetPlayerStructure(p).blockscanlist;
}
public static boolean itemCanBeSuckedUp(Item ent) {
public static boolean itemCanBeSuckedUp(Item ent, Player p) {
ItemStack item = ent.getItemStack();
//TwosideKeeper.log(item.toString()+": "+ent.getTicksLived()+".."+ent.getPickupDelay()+".."+((Item)ent).getName()+".."+((Item)ent).isCustomNameVisible()+".."+((Item)ent).getCustomName(), 0);
if (ent.getPickupDelay()>=0) {
PlayerStructure pd = PlayerStructure.GetPlayerStructure(p);
if (ent.getPickupDelay()>=0 || pd.ignoreItemsList.contains(ent.getUniqueId())) {
return false;
}
return true;

2
src/sig/plugin/TwosideKeeper/HelperStructures/CustomRecipe.java
View File

@ -91,7 +91,7 @@ public enum CustomRecipe {
ev.getInventory().getItem(i).getType()!=Material.AIR &&
(ev.getInventory().getItem(i).getType()==Material.ENDER_CHEST)) && !CustomItem.isVacuumCube(ev.getInventory().getItem(i))) {
ItemMeta inventory_itemMeta1=ev.getInventory().getItem(i).getItemMeta();
if (inventory_itemMeta1.hasLore() && inventory_itemMeta1.getLore().size()==4) {
if (inventory_itemMeta1.hasLore() && inventory_itemMeta1.getLore().size()>=4) {
String loreitem = inventory_itemMeta1.getLore().get(3);
if (loreitem!=null && loreitem.contains(ChatColor.DARK_PURPLE+"ID#")) {
//log("This is an Item Cube. Invalidate recipe.",4);

63
src/sig/plugin/TwosideKeeper/HelperStructures/FilterCubeItem.java Normal file
View File

@ -0,0 +1,63 @@
package sig.plugin.TwosideKeeper.HelperStructures;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import org.bukkit.Material;
import org.bukkit.block.Hopper;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import sig.plugin.TwosideKeeper.PlayerStructure;
import sig.plugin.TwosideKeeper.TwosideKeeper;
import sig.plugin.TwosideKeeper.HelperStructures.Utils.ItemCubeUtils;
import sig.plugin.TwosideKeeper.HelperStructures.Utils.TextUtils;
public class FilterCubeItem {
public static void populateFilterCubeItemList(Player p) {
HashMap<Material, List<Integer>> structure = GrabFilterCubeStructure(p);
structure.clear();
for (ItemStack item : p.getInventory().getContents()) {
if (item!=null && CustomItem.isFilterCube(item)) {
Hopper h = ItemCubeUtils.getFilterCubeHopper(ItemCubeUtils.getItemCubeID(item));
for (ItemStack it : h.getInventory()) {
if (it!=null) {
int id = ItemCubeUtils.getItemCubeID(item);
if (structure.containsKey(it.getType())) {
List<Integer> filterCubes = structure.get(it.getType());
filterCubes.add(id);
} else {
List<Integer> filterCubeList = new ArrayList<Integer>();
filterCubeList.add(id);
structure.put(it.getType(), filterCubeList);
}
}
}
}
}
//TwosideKeeper.log("New Map: \n"+TextUtils.outputHashmap(structure), 0);
}
public static HashMap<Material, List<Integer>> GrabFilterCubeStructure(Player p) {
PlayerStructure pd = PlayerStructure.GetPlayerStructure(p);
HashMap<Material,List<Integer>> structure = pd.filtercubestructure;
return structure;
}
public static boolean ItemHasFilterCube(ItemStack item, Player p) {
HashMap<Material, List<Integer>> structure = GrabFilterCubeStructure(p);
return structure.containsKey(item.getType());
}
public static List<Integer> getFilterCubeIDsToInsertItem(ItemStack item, Player p) {
HashMap<Material, List<Integer>> structure = GrabFilterCubeStructure(p);
if (structure.containsKey(item.getType())) {
return structure.get(item.getType());
} else {
return new ArrayList<Integer>();
}
}
}

39
src/sig/plugin/TwosideKeeper/HelperStructures/ItemCube.java
View File

@ -5,8 +5,12 @@ import org.bukkit.Sound;
import org.bukkit.entity.Player;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.ItemStack;
import org.jgrapht.graph.DefaultEdge;
import sig.plugin.TwosideKeeper.PlayerStructure;
import sig.plugin.TwosideKeeper.TwosideKeeper;
import sig.plugin.TwosideKeeper.HelperStructures.Utils.InventoryUtils;
import sig.plugin.TwosideKeeper.HelperStructures.Utils.ItemCubeUtils;
import sig.plugin.TwosideKeeper.HelperStructures.Utils.SoundUtils;
public class ItemCube {
@ -35,6 +39,41 @@ public class ItemCube {
}
return null; //Didn't find anything.
}
/**
* @deprecated Redundant and unnecessary.
*/
@Deprecated
public static void addItemCubeToAllViewerGraphs(int id, ItemStack cursor, Player checker) {
for (Player p : Bukkit.getOnlinePlayers()) {
if (checker==null || !p.equals(checker)) {
if (p.getOpenInventory()!=null && p.getOpenInventory().getTitle().contains("Item Cube #"+id) &&
ItemCubeUtils.isItemCube(cursor)) {
int itemcubeID = ItemCubeUtils.getItemCubeID(cursor);
PlayerStructure pd = PlayerStructure.GetPlayerStructure(p);
TwosideKeeper.itemCubeGraph.addVertex(itemcubeID);
DefaultEdge edge = TwosideKeeper.itemCubeGraph.addEdge(id, itemcubeID);
TwosideKeeper.log("Added edge "+edge+" for player "+p.getName(), 0);
}
}
}
}
/**
* @deprecated Redundant and unnecessary.
*/
@Deprecated
public static void removeItemCubeFromAllViewerGraphs(int id, ItemStack cursor, Player checker) {
for (Player p : Bukkit.getOnlinePlayers()) {
if (checker==null || !p.equals(checker)) {
if (p.getOpenInventory()!=null && p.getOpenInventory().getTitle().contains("Item Cube #"+id) &&
ItemCubeUtils.isItemCube(cursor)) {
int itemcubeID = ItemCubeUtils.getItemCubeID(cursor);
PlayerStructure pd = PlayerStructure.GetPlayerStructure(p);
DefaultEdge edge = TwosideKeeper.itemCubeGraph.removeEdge(id, itemcubeID);
TwosideKeeper.log("Removed edge "+edge+" for player "+p.getName(), 0);
}
}
}
}
public static void displayErrorMessage(Player p) {
SoundUtils.playLocalSound(p, Sound.BLOCK_NOTE_PLING, 0.6f, 4.0f);
p.sendMessage("Someone is currently using this Item Cube! Please wait for them to finish.");

36
src/sig/plugin/TwosideKeeper/HelperStructures/Utils/InventoryUtils.java
View File

@ -15,6 +15,7 @@ import org.bukkit.inventory.ItemStack;
import sig.plugin.TwosideKeeper.TwosideKeeper;
import sig.plugin.TwosideKeeper.HelperStructures.CubeType;
import sig.plugin.TwosideKeeper.HelperStructures.CustomItem;
import sig.plugin.TwosideKeeper.HelperStructures.FilterCubeItem;
import sig.plugin.TwosideKeeper.HelperStructures.ItemCube;
import sig.plugin.TwosideKeeper.HelperStructures.Common.GenericFunctions;
import sig.plugin.TwosideKeeper.HelperStructures.Common.ItemContainer;
@ -48,6 +49,7 @@ public class InventoryUtils {
List<ItemContainer> itemcube_list = new ArrayList<ItemContainer>();
for (int i=0;i<virtualinventory.getSize();i++) {
itemslist.add(virtualinventory.getItem(i));
if (ItemUtils.isValidItem(virtualinventory.getItem(i))) {
boolean found=false;
for (int j=0;j<itemcube_list.size();j++) {
@ -66,11 +68,15 @@ public class InventoryUtils {
Inventory collectionOfItems = AddItemsThatHaveBeenAddedToOurInventoryForOtherVacuumCubeViewers(p,
remaining, itemCubeContents, remainingitems);
if (remainingitems.size()==0) {
ItemCubeUtils.addItemCubeToGraphFromCube(id,remaining[0],p);
}
//TwosideKeeper.log(Arrays.toString(collectionOfItems.getContents()), 0);
ItemCube.addToViewersOfItemCube(id,collectionOfItems.getContents(),null);
TwosideKeeper.itemCube_saveConfig(id, itemslist, CubeType.VACUUM);
TwosideKeeper.itemcube_updates.put(id, itemcube_list);//This Item Cube can be saved.
/*for (ItemStack i : remainingitems.values()) {
TwosideKeeper.log("Item "+i+" remains", 0);
}*/
@ -105,7 +111,7 @@ public class InventoryUtils {
}
public static ItemStack[] insertItemsInFilterCube(Player p,ItemStack...items) {
ItemStack[] remaining = items;
for (ItemStack itemStacks : p.getInventory().getContents()) {
/*for (ItemStack itemStacks : p.getInventory().getContents()) {
if (itemStacks!=null && CustomItem.isFilterCube(itemStacks)) {
//Insert as many items as possible in here.
int id = Integer.parseInt(ItemUtils.GetLoreLineContainingSubstring(itemStacks, ChatColor.DARK_PURPLE+"ID#").split("#")[1]);
@ -122,6 +128,25 @@ public class InventoryUtils {
remaining = remainingitems.values().toArray(new ItemStack[0]);
GenericFunctions.UpdateItemLore(itemStacks);
}
}*/
for (int j=0;j<remaining.length;j++) {
if (FilterCubeItem.ItemHasFilterCube(remaining[j], p)) {
for (Integer id : FilterCubeItem.getFilterCubeIDsToInsertItem(remaining[j], p)) {
//Insert as many items as possible in here.
List<ItemStack> itemCubeContents = TwosideKeeper.itemCube_loadConfig(id);
Inventory virtualinventory = Bukkit.createInventory(p, 27);
for (int i=0;i<virtualinventory.getSize();i++) {
if (itemCubeContents.get(i)!=null) {
virtualinventory.setItem(i, itemCubeContents.get(i));
}
}
//THIS IS WHERE YOU DO THE FILTERING.
HashMap<Integer,ItemStack> remainingitems = ItemCubeUtils.AttemptingToAddItemToFilterCube(id,virtualinventory,remaining);
GenericFunctions.UpdateItemLore(remaining[j]);
remaining = remainingitems.values().toArray(new ItemStack[0]);
}
}
}
return remaining;
}
@ -144,6 +169,15 @@ public class InventoryUtils {
}
return true;
}
public static boolean hasFullInventory(Inventory inv) {
ItemStack[] inventory = inv.getContents();
for (ItemStack i : inventory) {
if (i==null || i.getType()==Material.AIR) {
return false;
}
}
return true;
}
public static boolean hasEmptyInventory(Inventory inv) {
ItemStack[] inventory = inv.getContents();
for (ItemStack i : inventory) {

172
src/sig/plugin/TwosideKeeper/HelperStructures/Utils/ItemCubeUtils.java
View File

@ -6,6 +6,7 @@ import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Set;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
@ -16,10 +17,15 @@ import org.bukkit.block.Hopper;
import org.bukkit.configuration.file.FileConfiguration;
import org.bukkit.configuration.file.YamlConfiguration;
import org.bukkit.entity.Player;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.event.inventory.InventoryType;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.ItemStack;
import org.jgrapht.Graph;
import org.jgrapht.UndirectedGraph;
import org.jgrapht.graph.DefaultEdge;
import sig.plugin.TwosideKeeper.PlayerStructure;
import sig.plugin.TwosideKeeper.TwosideKeeper;
import sig.plugin.TwosideKeeper.HelperStructures.CubeType;
import sig.plugin.TwosideKeeper.HelperStructures.ItemCube;
@ -29,8 +35,11 @@ public class ItemCubeUtils {
public final static String SUCTION_STRING = ChatColor.GRAY+"Block Collection: ";
public final static String FILTER_STRING = ChatColor.GRAY+"Filter Blocks: ";
public static int getItemCubeID(ItemStack item) {
if (isItemCube(item)) {
return Integer.parseInt(ItemUtils.GetLoreLineContainingSubstring(item, ChatColor.DARK_PURPLE+"ID#").split("#")[1]);
}
return -1;
}
public static Location getFilterCubeLoc(int id) {
int posx = id % 960;
int posy = 64;
@ -84,6 +93,8 @@ public class ItemCubeUtils {
TwosideKeeper.itemCube_saveConfig(id, itemslist);
TwosideKeeper.itemcube_updates.put(id, itemcube_list);//This Item Cube can be saved.
}
ItemCubeUtils.addItemCubeToGraphFromCube(id, it, (Player)cube_inv.getHolder());
} else {
for (ItemStack i : extras.values()) {
reject_items.put(reject_items.size(), i);
@ -409,4 +420,165 @@ public class ItemCubeUtils {
}
TwosideKeeper.itemcube_updates.put(ItemCubeUtils.getItemCubeID(item), itemcube_list);
}
public static void populateItemCubeGraph(Player p) {
PlayerStructure pd = PlayerStructure.GetPlayerStructure(p);
UndirectedGraph<Integer,DefaultEdge> graph = TwosideKeeper.itemCubeGraph;
graph.addVertex(PlayerStructure.getPlayerNegativeHash(p)); //Root Vertex.
for (ItemStack it : p.getInventory().getContents()) {
if (ItemUtils.isValidItem(it) && isItemCube(it)) {
int id = getItemCubeID(it);
graph.addVertex(id);
graph.addEdge(PlayerStructure.getPlayerNegativeHash(p), id);
IterateAndAddToGraph(id,graph);
}
}
for (DefaultEdge edge : graph.edgeSet()) {
TwosideKeeper.log(" "+edge.toString(), 0);
}
}
public static void IterateAndAddToGraph(int id, UndirectedGraph<Integer, DefaultEdge> graph) {
List<ItemStack> contents = getItemCubeContents(id);
for (ItemStack it : contents) {
if (ItemUtils.isValidItem(it) && isItemCube(it)) {
int newid = getItemCubeID(it);
if (id!=newid) { //We don't need to link to itself.
graph.addVertex(newid);
graph.addEdge(id, newid);
IterateAndAddToGraph(newid,graph);
}
}
}
}
public static void pickupAndAddItemCubeToGraph(ItemStack item, Player p) {
if (ItemCubeUtils.isItemCube(item)) {
int id = ItemCubeUtils.getItemCubeID(item);
PlayerStructure pd = PlayerStructure.GetPlayerStructure(p);
UndirectedGraph<Integer,DefaultEdge> graph = TwosideKeeper.itemCubeGraph;
graph.addVertex(id);
DefaultEdge edge = graph.addEdge(PlayerStructure.getPlayerNegativeHash(p), id);
//TwosideKeeper.log("Added edge "+edge, 0);
ItemCubeUtils.IterateAndAddToGraph(id, graph);
}
}
public static void addItemCubeToGraphFromCube(int sourceCubeID, ItemStack item, Player p) {
if (ItemCubeUtils.isItemCube(item)) {
int id = ItemCubeUtils.getItemCubeID(item);
PlayerStructure pd = PlayerStructure.GetPlayerStructure(p);
UndirectedGraph<Integer,DefaultEdge> graph = TwosideKeeper.itemCubeGraph;
graph.addVertex(id);
DefaultEdge edge = graph.addEdge(sourceCubeID, id);
//TwosideKeeper.log("Added edge "+edge, 0);
ItemCubeUtils.IterateAndAddToGraph(id, graph);
}
}
public static void removeAndUpdateAllEdgesDroppedItem(int id, Player p) {
PlayerStructure pd = PlayerStructure.GetPlayerStructure(p);
UndirectedGraph<Integer,DefaultEdge> graph = TwosideKeeper.itemCubeGraph;
DestroyAllSourceEdges(PlayerStructure.getPlayerNegativeHash(p), graph);
reestablishAllRootEdges(p, graph);
}
public static void removeAndUpdateAllEdges(int id, Player p) {
PlayerStructure pd = PlayerStructure.GetPlayerStructure(p);
UndirectedGraph<Integer,DefaultEdge> graph = TwosideKeeper.itemCubeGraph;
DestroyAllSourceEdges(id, graph);
reestablishAllEdges(id, graph);
}
private static void reestablishAllEdges(int id, UndirectedGraph<Integer, DefaultEdge> graph) {
List<ItemStack> contents = getItemCubeContents(id);
for (ItemStack it : contents) {
if (ItemUtils.isValidItem(it) && isItemCube(it)) {
int newid = getItemCubeID(it);
if (id!=newid) { //We don't need to link to itself.
graph.addVertex(newid);
DefaultEdge edge = graph.addEdge(id, newid);
//TwosideKeeper.log("Reconnected edge "+edge, 0);
}
}
}
}
private static void reestablishAllRootEdges(Player p, UndirectedGraph<Integer, DefaultEdge> graph) {
for (ItemStack it : p.getInventory().getContents()) {
if (ItemUtils.isValidItem(it) && isItemCube(it)) {
int newid = getItemCubeID(it);
graph.addVertex(newid);
DefaultEdge edge = graph.addEdge(PlayerStructure.getPlayerNegativeHash(p), newid);
//TwosideKeeper.log("Reconnected edge "+edge, 0);
}
}
}
public static void DestroyAllSourceEdges(int id, UndirectedGraph<Integer, DefaultEdge> graph) {
Set<DefaultEdge> edges = graph.edgesOf(id);
List<DefaultEdge> destroyed = new ArrayList<DefaultEdge>();
for (DefaultEdge e : edges) {
if (graph.getEdgeSource(e)==id) {
destroyed.add(e);
}
}
while (destroyed.size()>0) {
DefaultEdge edge = destroyed.remove(0);
//TwosideKeeper.log("Destroyed edge "+edge, 0);
graph.removeEdge(edge);
}
}
public static void DestroyAllTargetEdges(int id, UndirectedGraph<Integer, DefaultEdge> graph) {
Set<DefaultEdge> edges = graph.edgesOf(id);
List<DefaultEdge> destroyed = new ArrayList<DefaultEdge>();
for (DefaultEdge e : edges) {
if (graph.getEdgeTarget(e)==id) {
destroyed.add(e);
}
}
while (destroyed.size()>0) {
DefaultEdge edge = destroyed.remove(0);
//TwosideKeeper.log("Destroyed edge "+edge, 0);
graph.removeEdge(edge);
}
}
/*public static void removeItemCubeFromGraph(int sourceCubeID, ItemStack item, Player p) {
}*/
/*public static void handleInventoryClickWithGraphs(InventoryClickEvent ev) {
Player p = (Player)ev.getWhoClicked();
PlayerStructure pd = PlayerStructure.GetPlayerStructure(p);
boolean isViewingItemCube = pd.isViewingItemCube;
Inventory inv = ev.getClickedInventory();
if (inv.getType()==InventoryType.CHEST) {
if (isViewingItemCube &&
inv.getTitle()!=null && inv.getTitle().contains("Item Cube #")) {
}
}
}*/
public static boolean isConnectedToRootNode(Graph<Integer,DefaultEdge> g, Integer vertex) {
Set<DefaultEdge> edges = g.edgesOf(vertex);
for (DefaultEdge e : edges) {
Integer target = g.getEdgeTarget(e);
Integer newvertex = g.getEdgeSource(e);
//TwosideKeeper.log("Vertex: "+vertex+" - "+newvertex+" : "+target,0);
if (Integer.compare(target, vertex)==0) {
TwosideKeeper.log(e.toString(),0);
if (Integer.compare(newvertex,vertex)==0) {
return false;
}
if (newvertex<0) {
return true;
} else {
return isConnectedToRootNode(g,newvertex);
}
}
}
return false;
}
}

26
src/sig/plugin/TwosideKeeper/HelperStructures/Utils/TextUtils.java
View File

@ -1,5 +1,8 @@
package sig.plugin.TwosideKeeper.HelperStructures.Utils;
import java.util.HashMap;
import java.util.List;
import org.bukkit.ChatColor;
public class TextUtils {
@ -44,4 +47,27 @@ public class TextUtils {
return ChatColor.DARK_RED;
}
}
public static String outputHashmap(HashMap map) {
StringBuilder builder = new StringBuilder();
for (Object o : map.keySet()) {
Object val = map.get(o);
builder.append(o.toString()+": ");
if (val instanceof List) {
builder.append("\n");
boolean first=true;
for (Object obj : (List)val) {
if (first) {
builder.append(" "+obj.toString());
} else {
builder.append("\n "+obj.toString());
}
}
} else {
builder.append(val.toString());
}
builder.append("\n");
}
return builder.toString();
}
}

11
src/sig/plugin/TwosideKeeper/PlayerStructure.java
View File

@ -20,9 +20,13 @@ import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.BookMeta;
import org.bukkit.potion.PotionEffect;
import org.jgrapht.UndirectedGraph;
import org.jgrapht.graph.DefaultEdge;
import org.jgrapht.graph.SimpleGraph;
import sig.plugin.TwosideKeeper.HelperStructures.BowMode;
import sig.plugin.TwosideKeeper.HelperStructures.DeathStructure;
import sig.plugin.TwosideKeeper.HelperStructures.FilterCubeItem;
import sig.plugin.TwosideKeeper.HelperStructures.PlayerMode;
import sig.plugin.TwosideKeeper.HelperStructures.ServerType;
import sig.plugin.TwosideKeeper.HelperStructures.Common.GenericFunctions;
@ -197,6 +201,9 @@ public class PlayerStructure {
List<ItemStack> equipmentset = new ArrayList<ItemStack>();
public HashMap<Material,List<Integer>> filtercubestructure = new HashMap<Material, List<Integer>>();
public List<UUID> ignoreItemsList = new ArrayList<UUID>();
//Needs the instance of the player object to get all other info. Only to be called at the beginning.
@SuppressWarnings("deprecation")
public PlayerStructure(Player p, long serverTickTime) {
@ -559,4 +566,8 @@ public class PlayerStructure {
return TwosideKeeper.playerdata.put(p.getUniqueId(), new PlayerStructure(p,TwosideKeeper.getServerTickTime()));
}
}
public static int getPlayerNegativeHash(Player p) {
return Math.min(p.getUniqueId().hashCode(), -p.getUniqueId().hashCode());
}
}

300
src/sig/plugin/TwosideKeeper/TwosideKeeper.java
View File

@ -119,8 +119,10 @@ import org.bukkit.event.entity.ProjectileLaunchEvent;
import org.bukkit.event.entity.EntityRegainHealthEvent.RegainReason;
import org.bukkit.event.inventory.ClickType;
import org.bukkit.event.inventory.CraftItemEvent;
import org.bukkit.event.inventory.InventoryAction;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.event.inventory.InventoryCloseEvent;
import org.bukkit.event.inventory.InventoryDragEvent;
import org.bukkit.event.inventory.InventoryMoveItemEvent;
import org.bukkit.event.inventory.InventoryOpenEvent;
import org.bukkit.event.inventory.InventoryPickupItemEvent;
@ -178,6 +180,9 @@ import org.bukkit.potion.PotionEffectTypeWrapper;
import org.bukkit.potion.PotionType;
import org.bukkit.util.Vector;
import org.inventivetalent.glow.GlowAPI;
import org.jgrapht.UndirectedGraph;
import org.jgrapht.graph.DefaultEdge;
import org.jgrapht.graph.SimpleGraph;
import com.google.common.collect.ImmutableSet;
@ -186,6 +191,7 @@ import com.google.common.collect.ImmutableSet;
import aPlugin.API.Chests;
import events.PlayerGainItemEvent;
import events.PlayerManualPickupItemEvent;
import events.PluginLoadEvent;
import net.md_5.bungee.api.chat.ClickEvent;
import net.md_5.bungee.api.chat.ComponentBuilder;
@ -197,6 +203,8 @@ import sig.plugin.AutoPluginUpdate.AnnounceUpdateEvent;
import sig.plugin.TwosideKeeper.Boss.Arena;
import sig.plugin.TwosideKeeper.Boss.SendMiningFatigueToAllNearbyElderGuardians;
import sig.plugin.TwosideKeeper.Events.EntityDamagedEvent;
import sig.plugin.TwosideKeeper.Events.InventoryUpdateEvent;
import sig.plugin.TwosideKeeper.Events.InventoryUpdateEvent.UpdateReason;
import sig.plugin.TwosideKeeper.Events.PlayerDodgeEvent;
import sig.plugin.TwosideKeeper.HelperStructures.AnvilItem;
import sig.plugin.TwosideKeeper.HelperStructures.ArtifactAbility;
@ -209,6 +217,7 @@ import sig.plugin.TwosideKeeper.HelperStructures.CustomItem;
import sig.plugin.TwosideKeeper.HelperStructures.CustomPotion;
import sig.plugin.TwosideKeeper.HelperStructures.CustomRecipe;
import sig.plugin.TwosideKeeper.HelperStructures.DamageStructure;
import sig.plugin.TwosideKeeper.HelperStructures.FilterCubeItem;
import sig.plugin.TwosideKeeper.HelperStructures.ItemCube;
import sig.plugin.TwosideKeeper.HelperStructures.ItemSet;
import sig.plugin.TwosideKeeper.HelperStructures.LivingEntityDifficulty;
@ -560,6 +569,8 @@ public class TwosideKeeper extends JavaPlugin implements Listener {
public static boolean PLAYERJOINTOGGLE=false;
public static UndirectedGraph<Integer,DefaultEdge> itemCubeGraph = new SimpleGraph<>(DefaultEdge.class);
private final class GivePlayerPurchasedItems implements Runnable {
private final Chest cc;
@ -802,9 +813,11 @@ public class TwosideKeeper extends JavaPlugin implements Listener {
TwosideKeeper.HeartbeatLogger.AddEntry("Lava Plume Handling", (int)(System.nanoTime()-time));time=System.nanoTime();
for (Player p : Bukkit.getOnlinePlayers()) {
long time1 = System.nanoTime();
runServerHeartbeat.runFilterCubeCollection(p);
List<UUID> itemsIgnored = new ArrayList<UUID>();
runServerHeartbeat.runFilterCubeCollection(p,itemsIgnored);
TwosideKeeper.HeartbeatLogger.AddEntry("Player Cycle Handling->Filter Cube Handling", (int)(System.nanoTime()-time1));time1=System.nanoTime();
runServerHeartbeat.runVacuumCubeSuckup(p);
runServerHeartbeat.runVacuumCubeSuckup(p,itemsIgnored);
TwosideKeeper.HeartbeatLogger.AddEntry("Player Cycle Handling->Vacuum Cube Handling", (int)(System.nanoTime()-time1));time1=System.nanoTime();
if (PlayerStructure.GetPlayerStructure(p).last_rejuvenate+200>TwosideKeeper.getServerTickTime()) {
GenericFunctions.HealEntity(p, 5);
@ -1221,6 +1234,8 @@ public class TwosideKeeper extends JavaPlugin implements Listener {
int ite2 = GetFullStructureMap("ite");
int las = GetFullStructureMap("las");
int blo2 = GetFullStructureMap("blo2");
int graphedge = itemCubeGraph.edgeSet().size();
int graphvert = itemCubeGraph.vertexSet().size();
DecimalFormat df = new DecimalFormat("0.00");
sender.sendMessage(ChatColor.WHITE+"TPS: "+GetTPSColor(tps)+df.format(tps));
sender.sendMessage(ChatColor.WHITE+Display("SNO",sno)+Display("PLA",pla)+Display("LIV",liv));
@ -1234,6 +1249,7 @@ public class TwosideKeeper extends JavaPlugin implements Listener {
sender.sendMessage(ChatColor.WHITE+Display("ITE",ite)+Display("PRI",pri)+Display("P-OPE",ope));
sender.sendMessage(ChatColor.WHITE+Display("P-DEA",dea)+Display("P-HIT",hit)+Display("P-ITE2",ite2));
sender.sendMessage(ChatColor.WHITE+Display("P-LAS",las)+Display("P-BLO2",blo2)+Display("P-DAM",dam));
sender.sendMessage(ChatColor.WHITE+Display("G-EDG",graphedge)+Display("G-VERT",graphvert));
sender.sendMessage(ChatColor.WHITE+DisplayPlayerBar());
sender.sendMessage(ChatColor.WHITE+"To view a specific player's usage, use "+ChatColor.GREEN+"\"/debugreport <name>\"");
sender.sendMessage(ChatColor.WHITE+"To view specific entities' usage, use "+ChatColor.GREEN+"\"/debugreport ALLENTS\"");
@ -2520,6 +2536,8 @@ public class TwosideKeeper extends JavaPlugin implements Listener {
ev.getPlayer().getScoreboard().getTeam(ev.getPlayer().getName().toLowerCase()).setSuffix(createHealthbar(((ev.getPlayer().getHealth())/ev.getPlayer().getMaxHealth())*100,ev.getPlayer()));
ev.getPlayer().getScoreboard().getTeam(ev.getPlayer().getName().toLowerCase()).setPrefix(GenericFunctions.PlayerModePrefix(ev.getPlayer()));
ev.getPlayer().getAttribute(Attribute.GENERIC_ATTACK_SPEED).setBaseValue(4.0d);
ItemCubeUtils.populateItemCubeGraph(ev.getPlayer());
}
public static void AnnounceDealOfTheDay(Player p) {
@ -3038,8 +3056,6 @@ public class TwosideKeeper extends JavaPlugin implements Listener {
@EventHandler(priority=EventPriority.LOW)
public void onPlayerInteract(PlayerInteractEntityEvent ev) {
log("Clicked with "+ ev.getHand().name(),5);
log("Clicked on: "+ev.getRightClicked().getName(),5);
Player p = ev.getPlayer();
PlayerStructure pd = PlayerStructure.GetPlayerStructure(ev.getPlayer());
if (ev.getRightClicked() instanceof LivingEntity &&
@ -3148,10 +3164,6 @@ public class TwosideKeeper extends JavaPlugin implements Listener {
LinkPlayerToOtherPlayer(p,pl);
}
}
/*if (ev.getRightClicked() instanceof Monster) {
TwosideKeeperAPI.DealDamageToEntity(TwosideKeeperAPI.getFinalDamage(500.0, ev.getPlayer(), (Monster)ev.getRightClicked(), true, "ROFL"), (Monster)ev.getRightClicked(), ev.getPlayer());
}*/
///if (ev.getHand()==EquipmentSlot.OFF_HAND) {aPlugin.API.swingOffHand(ev.getPlayer());};
}
private void LinkPlayerToOtherPlayer(Player p, Player pl) {
@ -4735,6 +4747,8 @@ public class TwosideKeeper extends JavaPlugin implements Listener {
@EventHandler(priority=EventPriority.LOW,ignoreCancelled = true)
public void onPlayerDropItem(PlayerDropItemEvent ev) {
InventoryUpdateEvent.TriggerUpdateInventoryEvent(ev.getPlayer(),ev.getItemDrop().getItemStack(),UpdateReason.DROPPEDITEM);
if (GenericFunctions.isArtifactEquip(ev.getItemDrop().getItemStack())) {
ev.getItemDrop().setInvulnerable(true);
}
@ -4865,6 +4879,20 @@ public class TwosideKeeper extends JavaPlugin implements Listener {
ev.setCancelled(true);
}
}
if (ItemCubeUtils.isItemCube(ev.getItemDrop().getItemStack())) {
ItemCubeUtils.removeAndUpdateAllEdgesDroppedItem(ItemCubeUtils.getItemCubeID(ev.getItemDrop().getItemStack()),ev.getPlayer());
if (ev.getPlayer().getOpenInventory()!=null &&
ev.getPlayer().getOpenInventory().getTitle()!=null &&
ev.getPlayer().getOpenInventory().getTitle().contains("Item Cube #") &&
PlayerStructure.GetPlayerStructure(ev.getPlayer()).isViewingItemCube) {
//We are viewing an item cube. Update it.
int id = Integer.parseInt(ev.getPlayer().getOpenInventory().getTitle().split("#")[1]);
ItemCubeUtils.removeAndUpdateAllEdges(id,ev.getPlayer());
}
}
return;
}
@ -4947,6 +4975,7 @@ public class TwosideKeeper extends JavaPlugin implements Listener {
CubeType cub = p.getOpenInventory().getTopInventory().getSize()==9?CubeType.NORMAL:p.getOpenInventory().getTopInventory().getSize()==54?CubeType.VACUUM:CubeType.LARGE;
SoundUtils.playLocalSound(p, Sound.BLOCK_CHEST_CLOSE, 1.0f, 1.0f);
itemCube_saveConfig(id,itemcube_contents,cub);
ItemCubeUtils.removeAndUpdateAllEdges(id,p);
itemcube_updates.put(id, itemcube_list);//This Item Cube can be saved.
if (!pd.opened_another_cube) {
ItemCubeWindow.removeAllItemCubeWindows(p);
@ -5112,6 +5141,17 @@ public class TwosideKeeper extends JavaPlugin implements Listener {
}
}
@EventHandler(priority=EventPriority.LOW,ignoreCancelled = true)
public void onInventoryUpdate(InventoryUpdateEvent ev) {
FilterCubeItem.populateFilterCubeItemList(ev.getPlayer());
ClearOutIgnoredUUIDs(ev.getPlayer());
}
private void ClearOutIgnoredUUIDs(Player p) {
PlayerStructure pd = PlayerStructure.GetPlayerStructure(p);
pd.ignoreItemsList.clear();
}
@SuppressWarnings("deprecation")
@EventHandler(priority=EventPriority.LOW,ignoreCancelled = true)
public void onInventoryClick(InventoryClickEvent ev) {
@ -5123,6 +5163,8 @@ public class TwosideKeeper extends JavaPlugin implements Listener {
////////////////////////DO NOT PUT ANYTHING HERE! DEATH STRUCTURE NEEDS TO OVERRIDE ALL BEHAVIORS.
InventoryUpdateEvent.TriggerUpdateInventoryEvent(player,ev.getCursor(),UpdateReason.INVENTORYUPDATE);
if (DeathManager.deathStructureExists(player) && ev.getInventory().getTitle().equalsIgnoreCase("Death Loot")) {
//See how many items are in our inventory. Determine final balance.
//Count the occupied slots.
@ -5433,7 +5475,7 @@ public class TwosideKeeper extends JavaPlugin implements Listener {
//We clicked an item cube. Check its ID.
int clicked_id = Integer.parseInt(ev.getCurrentItem().getItemMeta().getLore().get(i).split("#")[1]);
log("ID is "+clicked_id+" and we are viewing "+itemcubeid,5);
if (clicked_id==itemcubeid) {
/*if (clicked_id==itemcubeid) {
//The inventory we are viewing is the same as the item cube we have clicked on!
//Stop this before the player does something dumb!
//Player p = ((Player)ev.getWhoClicked());
@ -5441,7 +5483,7 @@ public class TwosideKeeper extends JavaPlugin implements Listener {
//TwosideKeeper.log("In here Item Cubes..", 0);
ev.setCancelled(true);
return;
}
}*/
}
}
}
@ -5524,6 +5566,23 @@ public class TwosideKeeper extends JavaPlugin implements Listener {
//Make sure we are not already inside the cube we're placing into.
{
CubeType cub = clicked_size==9?CubeType.NORMAL:clicked_size==54?CubeType.VACUUM:CubeType.LARGE;
if (ItemCubeUtils.isItemCube(ev.getCursor())) {
//We need to see if this is allowed then.
//idnumb is the ID we're inserting into.
int id = ItemCubeUtils.getItemCubeID(ev.getCursor());
//TwosideKeeper.itemCubeGraph.addEdge(idnumb, id);
//Does this make a root connection?
if (!ItemCubeUtils.isConnectedToRootNode(TwosideKeeper.itemCubeGraph, idnumb)) {
//This is not allowed!
TwosideKeeper.log("No ROOT NODE found! Do not allow this.", 0);
//TwosideKeeper.itemCubeGraph.removeEdge(idnumb, id);
ev.setCursor(ev.getCursor());
ev.setCancelled(true);
return;
}
}
/*if (cub==CubeType.VACUUM) {
//A Vacuum Cube only accepts blocks, not items.
TwosideKeeper.log("Cursor is "+ev.getCursor(), 5);
@ -5706,46 +5765,204 @@ public class TwosideKeeper extends JavaPlugin implements Listener {
}
}
}
if (ev.getClickedInventory()!=null) {
Player p = (Player)ev.getWhoClicked();
if (ev.getAction()==InventoryAction.HOTBAR_SWAP || ev.getAction()==InventoryAction.HOTBAR_MOVE_AND_READD) {
Inventory clickedinv = p.getOpenInventory().getTopInventory();
ItemStack item1 = p.getInventory().getItem(ev.getHotbarButton()); //Bottom to Top
ItemStack item2 = p.getOpenInventory().getItem(ev.getRawSlot()); //Top to Bottom
TwosideKeeper.log(item1+" ||| "+item2, 0);
if (clickedinv!=null && clickedinv.getTitle()!=null && clickedinv.getTitle().contains("Item Cube #") &&
ev.getRawSlot()<p.getOpenInventory().getTopInventory().getSize()) {
int id = Integer.parseInt(clickedinv.getTitle().split("#")[1]);
if (ItemCubeUtils.isItemCube(item1)) {
int cubeid = ItemCubeUtils.getItemCubeID(item1);
try {
DefaultEdge edge = TwosideKeeper.itemCubeGraph.addEdge(id, cubeid);
edge = TwosideKeeper.itemCubeGraph.removeEdge(PlayerStructure.getPlayerNegativeHash(p), cubeid);
} catch (IllegalArgumentException ex) {
ev.setCancelled(true);
ev.setCursor(ev.getCursor());
return;
}
if (!ItemCubeUtils.isConnectedToRootNode(TwosideKeeper.itemCubeGraph, id)) {
try {
DefaultEdge edge = TwosideKeeper.itemCubeGraph.addEdge(PlayerStructure.getPlayerNegativeHash(p), cubeid);
edge = TwosideKeeper.itemCubeGraph.removeEdge(id, cubeid);
//TwosideKeeper.log("Added edge "+edge, 0);
} catch (IllegalArgumentException ex) {
ev.setCancelled(true);
ev.setCursor(ev.getCursor());
return;
}
ev.setCancelled(true);
ev.setCursor(ev.getCursor());
return;
}
}
if (ItemCubeUtils.isItemCube(item2)) {
int cubeid = ItemCubeUtils.getItemCubeID(item2);
try {
DefaultEdge edge = TwosideKeeper.itemCubeGraph.addEdge(PlayerStructure.getPlayerNegativeHash(p), cubeid);
edge = TwosideKeeper.itemCubeGraph.removeEdge(id, cubeid);
//TwosideKeeper.log("Added edge "+edge, 0);
} catch (IllegalArgumentException ex) {
ev.setCancelled(true);
ev.setCursor(ev.getCursor());
return;
}
}
}
}
//TODO Implement Graphs.
/*protected void BuildItemCubeGraph(Player p) {
PlayerStructure pd = PlayerStructure.GetPlayerStructure(p);
pd.graph = GraphBuilder.undirected().build();
for (ItemStack it : p.getInventory().getContents()) {
if (ItemCubeUtils.isItemCube(it)) {
int id = ItemCubeUtils.getItemCubeID(it);
pd.graph.addNode(id);
TwosideKeeper.log("Added Node "+id+" ["+pd.graph.nodes().size()+"]", 0);
ContinueBuildingItemCubeGraph(id,p);
if (ev.getAction()==InventoryAction.MOVE_TO_OTHER_INVENTORY && ItemCubeUtils.isItemCube(ev.getCurrentItem())) {
if (ev.getClickedInventory().getType()==InventoryType.PLAYER) {
//Check the top slot to see if it's an item cube inventory.
Inventory clickedinv = p.getOpenInventory().getTopInventory();
if (pd.isViewingItemCube && clickedinv.getTitle()!=null &&
clickedinv.getTitle().contains("Item Cube #")) {
if (!InventoryUtils.hasFullInventory(clickedinv)) {
int id = Integer.parseInt(clickedinv.getTitle().split("#")[1]);
int clickedid = ItemCubeUtils.getItemCubeID(ev.getCurrentItem());
if (!ItemCubeUtils.isConnectedToRootNode(TwosideKeeper.itemCubeGraph, id)) {
ev.setCancelled(true);
ev.setCursor(ev.getCursor());
return;
}
try {
DefaultEdge edge = TwosideKeeper.itemCubeGraph.addEdge(id, clickedid);
edge = TwosideKeeper.itemCubeGraph.removeEdge(PlayerStructure.getPlayerNegativeHash(p), clickedid);
//TwosideKeeper.log("Added edge "+edge, 0);
} catch (IllegalArgumentException ex) {
ev.setCancelled(true);
ev.setCursor(ev.getCursor());
return;
}
}
}
} else
{
if (!InventoryUtils.hasFullInventory(p)) {
int clickedid = ItemCubeUtils.getItemCubeID(ev.getCurrentItem());
Inventory clickedinv = p.getOpenInventory().getTopInventory();
try {
DefaultEdge edge = TwosideKeeper.itemCubeGraph.addEdge(PlayerStructure.getPlayerNegativeHash(p), clickedid);
if (pd.isViewingItemCube && clickedinv.getTitle()!=null &&
clickedinv.getTitle().contains("Item Cube #")) {
int id = Integer.parseInt(clickedinv.getTitle().split("#")[1]);
edge = TwosideKeeper.itemCubeGraph.removeEdge(id, clickedid);
}
//TwosideKeeper.log("Added edge "+edge, 0);
} catch (IllegalArgumentException ex) {
ev.setCancelled(true);
ev.setCursor(ev.getCursor());
return;
}
}
}
}
}*/
//TODO Implement Graphs.
/*private void ContinueBuildingItemCubeGraph(int id, Player p) {
if (ItemCubeUtils.isItemCube(ev.getCursor())) {
Inventory clickedinv = ev.getClickedInventory();
if (pd.isViewingItemCube && clickedinv.getTitle()!=null &&
clickedinv.getTitle().contains("Item Cube #")) {
int id = Integer.parseInt(clickedinv.getTitle().split("#")[1]);
int clickedid = ItemCubeUtils.getItemCubeID(ev.getCursor());
if (!ItemCubeUtils.isConnectedToRootNode(TwosideKeeper.itemCubeGraph, id)) {
ev.setCancelled(true);
ev.setCursor(ev.getCursor());
return;
}
try {
DefaultEdge edge = TwosideKeeper.itemCubeGraph.addEdge(id, clickedid);
//TwosideKeeper.log("Added edge "+edge, 0);
} catch (IllegalArgumentException ex) {
ev.setCancelled(true);
ev.setCursor(ev.getCursor());
return;
}
//ItemCube.addItemCubeToAllViewerGraphs(id, ev.getCursor(), p);
} else
if (clickedinv.getType()==InventoryType.PLAYER) {
int clickedid = ItemCubeUtils.getItemCubeID(ev.getCursor());
try {
DefaultEdge edge = TwosideKeeper.itemCubeGraph.addEdge(PlayerStructure.getPlayerNegativeHash(p), clickedid);
//TwosideKeeper.log("Added edge "+edge, 0);
} catch (IllegalArgumentException ex) {
ev.setCancelled(true);
ev.setCursor(ev.getCursor());
return;
}
}
}
if (!ItemUtils.isValidItem(ev.getCursor()) && ItemCubeUtils.isItemCube(ev.getCurrentItem()) && ev.isLeftClick()) {
Inventory clickedinv = ev.getClickedInventory();
if (pd.isViewingItemCube && clickedinv.getTitle()!=null &&
clickedinv.getTitle().contains("Item Cube #")) {
int id = Integer.parseInt(clickedinv.getTitle().split("#")[1]);
int clickedid = ItemCubeUtils.getItemCubeID(ev.getCurrentItem());
//TwosideKeeper.itemCubeGraph.addEdge(id, clickedid);
DefaultEdge edge = TwosideKeeper.itemCubeGraph.removeEdge(id, clickedid);
//TwosideKeeper.log("Destroyed edge "+edge, 0);
//ItemCubeUtils.DestroyAllTargetEdges(clickedid, TwosideKeeper.itemCubeGraph);
} else
if (clickedinv.getType()==InventoryType.PLAYER) {
int clickedid = ItemCubeUtils.getItemCubeID(ev.getCurrentItem());
DefaultEdge edge = TwosideKeeper.itemCubeGraph.removeEdge(PlayerStructure.getPlayerNegativeHash(p), clickedid);
//TwosideKeeper.log("Destroyed edge "+edge, 0);
}
}
}
}
@EventHandler(priority=EventPriority.LOW,ignoreCancelled = true)
public void onInventoryDrag(InventoryDragEvent ev) {
for (Integer i : ev.getNewItems().keySet()) {
ItemStack item = ev.getNewItems().get(i);
if (ItemCubeUtils.isItemCube(item)) {
Player p = (Player)ev.getWhoClicked();
PlayerStructure pd = PlayerStructure.GetPlayerStructure(p);
CubeType size = ItemCubeUtils.getCubeType(id);
int slots = CubeType.getSlotsFromType(size);
Inventory virtualinventory = null;
virtualinventory = ItemCube.getViewingItemCubeInventory(id, p);
if (virtualinventory==null) {
virtualinventory = Bukkit.createInventory(p, slots);
List<ItemStack> items = itemCube_loadConfig(id);
for (int i=0;i<virtualinventory.getSize();i++) {
if (items.get(i)!=null) {
ItemStack testitem = items.get(i);
if (ItemCubeUtils.isItemCube(testitem)) {
int newid = ItemCubeUtils.getItemCubeID(testitem);
pd.graph.addNode(newid);
pd.graph.putEdge(id, newid);
TwosideKeeper.log("Added Node "+newid+" ["+pd.graph.nodes().size()+"]", 0);
ContinueBuildingItemCubeGraph(newid,p);
Inventory clickedinv = ev.getInventory();
Integer clickedslot = ev.getRawSlots().iterator().next();
TwosideKeeper.log("Size is "+clickedinv.getSize(), 0);
if (pd.isViewingItemCube && clickedinv.getTitle()!=null &&
clickedinv.getTitle().contains("Item Cube #") &&
clickedslot<clickedinv.getSize()) {
int id = Integer.parseInt(clickedinv.getTitle().split("#")[1]);
int clickedid = ItemCubeUtils.getItemCubeID(item);
if (!ItemCubeUtils.isConnectedToRootNode(TwosideKeeper.itemCubeGraph, id)) {
ev.setCancelled(true);
ev.setCursor(ev.getCursor());
return;
}
try {
DefaultEdge edge = TwosideKeeper.itemCubeGraph.addEdge(id, clickedid);
TwosideKeeper.log("Added edge "+edge, 0);
} catch (IllegalArgumentException ex) {
ev.setCancelled(true);
ev.setCursor(ev.getCursor());
return;
}
} else
{
TwosideKeeper.log("Clicked "+clickedslot, 0);
if (clickedslot>=clickedinv.getSize()) {
int clickedid = ItemCubeUtils.getItemCubeID(item);
try {
DefaultEdge edge = TwosideKeeper.itemCubeGraph.addEdge(PlayerStructure.getPlayerNegativeHash(p), clickedid);
TwosideKeeper.log("Added edge "+edge, 0);
} catch (IllegalArgumentException ex) {
ev.setCancelled(true);
ev.setCursor(ev.getCursor());
return;
}
}
}
}
}
}
}*/
@ -7749,6 +7966,7 @@ public class TwosideKeeper extends JavaPlugin implements Listener {
return;
}
Player p = ev.getPlayer();
InventoryUpdateEvent.TriggerUpdateInventoryEvent(p,ev.getItem().getItemStack(),UpdateReason.PICKEDUPITEM);
ItemStack newstack = InventoryUtils.AttemptToFillPartialSlotsFirst(p,ev.getItem().getItemStack());
if (newstack==null || newstack.getType()==Material.AIR) {
SoundUtils.playGlobalSound(ev.getPlayer().getLocation(), Sound.ENTITY_ITEM_PICKUP, 0.6f, SoundUtils.DetermineItemPitch(ev.getItem().getItemStack()));
@ -7837,6 +8055,8 @@ public class TwosideKeeper extends JavaPlugin implements Listener {
}
}
ItemCubeUtils.pickupAndAddItemCubeToGraph(ev.getItem().getItemStack(), p);
ev.setCancelled(true);
ItemStack givenitem = ev.getItem().getItemStack().clone();
GenericFunctions.giveItem(p, givenitem);

6
src/sig/plugin/TwosideKeeper/TwosideKeeperAPI.java
View File

@ -260,6 +260,12 @@ public final class TwosideKeeperAPI {
public static boolean isItemCube(ItemStack item) {
return ItemCubeUtils.isItemCube(item);
}
/**
* Returns a negative number if the item specified is not an item cube.
*/
public static int getItemCubeID(ItemStack item) {
return ItemCubeUtils.getItemCubeID(item);
}
/**
* Returns the CubeType of a given Item Cube ID.
* CubeType contains the number of slots each type is supposed to have

25
src/sig/plugin/TwosideKeeper/runServerHeartbeat.java
View File

@ -37,6 +37,8 @@ import org.inventivetalent.glow.GlowAPI.Color;
import aPlugin.DiscordMessageSender;
import net.minecraft.server.v1_9_R1.EnumParticle;
import net.minecraft.server.v1_9_R1.MinecraftServer;
import sig.plugin.TwosideKeeper.Events.InventoryUpdateEvent;
import sig.plugin.TwosideKeeper.Events.InventoryUpdateEvent.UpdateReason;
import sig.plugin.TwosideKeeper.HelperStructures.ArtifactAbility;
import sig.plugin.TwosideKeeper.HelperStructures.BankSession;
import sig.plugin.TwosideKeeper.HelperStructures.DamageStructure;
@ -621,12 +623,12 @@ final class runServerHeartbeat implements Runnable {
}
}
public static void runFilterCubeCollection(Player p) {
public static void runFilterCubeCollection(Player p, List<UUID> ignoredItems) {
if (InventoryUtils.hasFullInventory(p) && InventoryUtils.isCarryingFilterCube(p)) {
List<Entity> ents = p.getNearbyEntities(1, 1, 1);
int count=0;
for (Entity ent : ents) {
if (ent instanceof Item && GenericFunctions.itemCanBeSuckedUp((Item)ent)) {
if (ent instanceof Item && GenericFunctions.itemCanBeSuckedUp((Item)ent,p)) {
Item it = (Item)ent;
if (it.getPickupDelay()<=0) {
events.PlayerManualPickupItemEvent ev = new events.PlayerManualPickupItemEvent(p, it.getItemStack());
@ -636,20 +638,26 @@ final class runServerHeartbeat implements Runnable {
if (!handled) {
ItemStack[] remaining = InventoryUtils.insertItemsInFilterCube(p, it.getItemStack());
if (remaining.length==0) {
InventoryUpdateEvent.TriggerUpdateInventoryEvent(ev.getPlayer(),ev.getItemStack(),UpdateReason.PICKEDUPITEM);
SoundUtils.playGlobalSound(p.getLocation(), Sound.ENTITY_ITEM_PICKUP, 0.6f, SoundUtils.DetermineItemPitch(it.getItemStack()));
TwosideKeeper.PlayPickupParticle(p,it);
it.remove();
}
} else {
InventoryUpdateEvent.TriggerUpdateInventoryEvent(ev.getPlayer(),ev.getItemStack(),UpdateReason.PICKEDUPITEM);
TwosideKeeper.PlayPickupParticle(p,it);
it.remove();
}
} else {
TwosideKeeper.PlayPickupParticle(p,it);
it.remove();
}
}
if (it.isValid()) {
ignoredItems.add(it.getUniqueId());
}
count++;
if (count>8) {
if (count>=8) {
return;
}
}
@ -657,14 +665,14 @@ final class runServerHeartbeat implements Runnable {
}
}
public static void runVacuumCubeSuckup(Player p) {
public static void runVacuumCubeSuckup(Player p, List<UUID> ignoredItems) {
if (InventoryUtils.isCarryingVacuumCube(p)) {
//Suck up nearby item entities.
PlayerStructure pd = PlayerStructure.GetPlayerStructure(p);
List<Entity> ents = p.getNearbyEntities(6, 6, 6);
int count=0;
for (Entity ent : ents) {
if (ent instanceof Item && GenericFunctions.itemCanBeSuckedUp((Item)ent)) {
if (ent instanceof Item && GenericFunctions.itemCanBeSuckedUp((Item)ent,p)) {
//Pull towards the player.
double SPD = 0.2;
double deltax = ent.getLocation().getX()-p.getLocation().getX();
@ -705,10 +713,12 @@ final class runServerHeartbeat implements Runnable {
if (remaining.length==0) {
SoundUtils.playGlobalSound(p.getLocation(), Sound.ENTITY_ITEM_PICKUP, 0.6f, SoundUtils.DetermineItemPitch(((Item) ent).getItemStack()));
TwosideKeeper.PlayPickupParticle(p,(Item)ent);
InventoryUpdateEvent.TriggerUpdateInventoryEvent(ev.getPlayer(),ev.getItemStack(),UpdateReason.PICKEDUPITEM);
ent.remove();
return;
}
} else {
InventoryUpdateEvent.TriggerUpdateInventoryEvent(ev.getPlayer(),ev.getItemStack(),UpdateReason.PICKEDUPITEM);
ent.remove();
return;
}
@ -722,6 +732,11 @@ final class runServerHeartbeat implements Runnable {
ent.setVelocity(new Vector(xvel,yvel,zvel));
}
}
if (ent.isValid()) {
if (ignoredItems.contains(ent.getUniqueId())) {
pd.ignoreItemsList.add(ent.getUniqueId());
}
}
/*if (ent.getLocation().getX()<p.getLocation().getX()) {
ent.setVelocity(ent.getVelocity().setX(SPD*(10-Math.min(10,Math.abs()))));
} else {