");
+
+ }
+
+// public boolean parseSelfRankUp(Player pPlayer, String[] args)
+// {
+// String className = "";
+// if (plugin.config.isOnlyoneclass() == false)
+// {
+// if (args.length == 0)
+// {
+// //zeigt command description aus Plugi.yml
+// cmdRankUpInfo (pPlayer);
+// return true;
+// }
+// className = args[0];
+// // rankUp [classname] | Add yourself to a class
+// } else
+// {
+//
+// }
+// String world = "";
+//
+// //world name auswerten und setzen
+// world = getWorldArg(world, args);
+// plugin.db.i("precheck successful");
+// // Add Rank
+//
+// rankUp(pPlayer, pPlayer, className, world);
+// return true;
+// }
+
+
+ /**
+ *
+ * The main switch for the command usage. Check for known commands,
+ * permissions, arguments, and commit whatever is wanted.
+ *
+ *
+
+ /class [rankup] [playername] {world} | Rank user up
+
+ * @param pPlayer , the sender of the command
+ * @param args , arguments of the Command /class
+ * @return
+ *
+ */
+ public boolean parseCommand(Player pPlayer, String[] args)
+ {
+// Player player = pPlayer;
+ plugin.db.i("parsing player " + pPlayer + ", command: " + FormatManager.formatStringArray(args));
+
+ boolean isSelf = plugin.perms.hasPerms(pPlayer, "classranks.self.rank", pPlayer.getWorld().getName());
+ String world = "all";
+ String className = "";
+
+ if (pPlayer.isOp())
+ {
+ isSelf = true;
+ }
+
+ if (args.length == 0)
+ {
+ //zeigt command description aus Plugi.yml
+ cmdRankInfo (pPlayer);
+ return true;
+ }
+
+ if (isSelf == false)
+ {
+ plugin.msg(pPlayer,ChatColor.RED+"permission classranks.self.rank not set to you , call your admin!");
+ return true;
+ }
+
+
+ //RANKUP for multiClasses
+ if (plugin.config.isOnlyoneclass() == false)
+ {
+ // rank up or down
+ if (args.length == 0)
+ {
+ plugin.msg(pPlayer,ChatColor.RED+"Not enough arguments ("+ String.valueOf(args.length) + ")!");
+ plugin.msg(pPlayer,ChatColor.GREEN+" /rankup [classname] {world} | Rank user up");
+ return true;
+ }
+ if (args.length > 1)
+ {
+ world = args[1];
+ }
+ className = args[0];
+ return rankUp(pPlayer, pPlayer, className, world);
+ } else
+ {
+ if (isSelf == false)
+ {
+ plugin.msg(pPlayer,ChatColor.RED+"You don't have permission to rankup your class!");
+ return true;
+ } else
+ {
+ Rank rank = ClazzList.getRankByPermName(plugin.perms.getPlayerGroups(pPlayer));
+ if (rank != null)
+ {
+ className = ClazzList.getClassNameByPermName(rank.getPermName());
+ if (existClass(className))
+ {
+ rankUp(pPlayer, pPlayer, className, world);
+ return true;
+ } else
+ {
+ plugin.msg(pPlayer,ChatColor.RED+"The class name are not found!");
+ plugin.msg(pPlayer,ChatColor.RED+"Are you have any class or rank ?");
+ plugin.msg(pPlayer,"/class get, show your class and rank");
+ return true;
+ }
+ } else
+ {
+ plugin.msg(pPlayer,ChatColor.RED+"The class name are not found!");
+ plugin.msg(pPlayer,ChatColor.RED+"Are you have any class or rank ?");
+ plugin.msg(pPlayer,"/class get, show your class and rank");
+ return true;
+ }
+ }
+ }
+ }
+
}
diff --git a/src/net/slipcor/classranks/core/Class.java b/src/net/slipcor/classranks/core/Class.java
deleted file mode 100644
index 7658d9f..0000000
--- a/src/net/slipcor/classranks/core/Class.java
+++ /dev/null
@@ -1,48 +0,0 @@
-package net.slipcor.classranks.core;
-
-import java.util.ArrayList;
-
-import org.bukkit.ChatColor;
-import org.bukkit.inventory.ItemStack;
-
-/**
- * class class
- *
- * @version v0.3.0
- *
- * @author slipcor
- */
-
-public class Class {
- public final ArrayList ranks = new ArrayList();
- public String name;
-
- /**
- * create a class instance
- * @param sClassName the class name
- */
- public Class(String sClassName) {
- this.name = sClassName;
- }
-
- /**
- * add a rank to class
- * @param sPermName the rank permissions name
- * @param sDispName the rank display name
- * @param cColor the rank color
- * @param isItems the rank items cost
- * @param dCost the rank cost
- * @param iExp the rank exp cost
- */
- public void add(String sPermName, String sDispName, ChatColor cColor, ItemStack[] isItems, double dCost, int iExp) {
- this.ranks.add(new Rank(sPermName, sDispName, cColor, this, isItems, dCost, iExp));
- }
-
- /**
- * remove a string from class
- * @param sPermName the rank name to remove
- */
- public void remove(String sPermName) {
- this.ranks.remove(sPermName);
- }
-}
diff --git a/src/net/slipcor/classranks/core/Clazz.java b/src/net/slipcor/classranks/core/Clazz.java
new file mode 100644
index 0000000..44bfb40
--- /dev/null
+++ b/src/net/slipcor/classranks/core/Clazz.java
@@ -0,0 +1,196 @@
+package net.slipcor.classranks.core;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+
+import org.bukkit.ChatColor;
+import org.bukkit.inventory.ItemStack;
+
+/**
+ * realize a objekt with multiple ranks. Each rank is a name of a
+ * permissionGroup
+ * - ClassName
+ * - [0] = Rankname 0
+ * - [1] = Rankname 1
+ * - [2] = Rankname 2
+ * - [3] = Rankname 3
+ * and so on. The rank is given by position in the list.
+ * You can go rankUp or rankDown in the list.
+ * A player can have one rank in each Clazz.
+ *
+ * a Clazzname be unique
+ * a Rankname must be unique in all Clazzes
+ *
+ * @version v 0.7.1 krglok
+ * *
+ * @version v0.3.0
+ * @author slipcor
+ */
+
+public class Clazz
+{
+ public HashMap ranks = new HashMap();
+ public String clazzName;
+
+ /**
+ * create a class instance
+ *
+ * @param sClassName
+ * the class name
+ */
+ public Clazz(String sClassName)
+ {
+ this.clazzName = sClassName;
+ }
+
+ public boolean containRank(String sPermName)
+ {
+ for (Rank rank : ranks.values())
+ {
+ if (rank.sPermissionName.equalsIgnoreCase(sPermName) == true)
+ {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * add a rank to class
+ *
+ * @param sPermName the rank permissions name
+ * @param sDispName the rank display name
+ * @param cColor the rank color
+ * @param isItems the array of rank items cost
+ * @param dCost the rank cost (money)
+ * @param iExp the rank exp cost
+ */
+ public void add(String sPermName, String sDispName, ChatColor cColor,
+ ItemStack[] isItems, double dCost, int iExp)
+ {
+ if (containRank(sPermName) == false)
+ {
+ int nextIndex = this.ranks.size()+1;
+ this.ranks.put(nextIndex,new Rank(sPermName, sDispName, cColor, this, isItems,
+ dCost, iExp));
+ }
+ }
+
+ /**
+ * remove a string from class
+ * be carefull, this reindex the ranks !!!
+ *
+ * @param sPermName the rank name to remove
+ */
+ public void remove(String sPermName)
+ {
+ if (containRank(sPermName))
+ {
+ HashMap newRanks = new HashMap();
+ for (Rank rank : ranks.values())
+ {
+ if (rank.sPermissionName.equalsIgnoreCase(sPermName) == false)
+ {
+ int nextIndex = this.ranks.size()+1;
+ newRanks.put(nextIndex, rank);
+ }
+ }
+ ranks = newRanks;
+ }
+ }
+
+ /**
+ * search for next rank in ranklist
+ *
+ * @param sPermName
+ * @return sPermissionName or null
+ */
+ public String nextRankPerm(String sPermName)
+ {
+ int lastIndex = 0;
+ for (Integer key : this.ranks.keySet())
+ {
+
+ if (key < lastIndex)
+ {
+ Rank rank = this.ranks.get(key+1);
+ return rank.sPermissionName;
+ }
+ }
+ return null;
+ }
+
+
+ public Rank nextRank(String sPermName)
+ {
+ int lastIndex = 0;
+ for (Integer key : this.ranks.keySet())
+ {
+
+ if (key < lastIndex)
+ {
+ Rank rank = this.ranks.get(key+1);
+ return rank;
+ }
+ }
+ return null;
+ }
+
+ /**
+ * search for prev rank in ranklist
+ *
+ * @param sPermName
+ * @return sPermissionName or null
+ */
+ public String prevRankName(String sPermName)
+ {
+ for (Integer key : this.ranks.keySet())
+ {
+ Rank rank = this.ranks.get(key);
+ if (rank.sPermissionName.equalsIgnoreCase(sPermName))
+ {
+ if (key > 1)
+ {
+ rank = this.ranks.get(key-1);
+ return rank.sPermissionName;
+ }
+ return null;
+ }
+ }
+ return null;
+ }
+
+
+ public Rank prevRank(String sPermName)
+ {
+ for (Integer key : this.ranks.keySet())
+ {
+ Rank rank = this.ranks.get(key);
+ if (rank.sPermissionName.equalsIgnoreCase(sPermName))
+ {
+ if (key > 1)
+ {
+ rank = this.ranks.get(key-1);
+ return rank;
+ }
+ return null;
+ }
+ }
+ return null;
+ }
+
+
+ public int getIndexOf(Rank rRank)
+ {
+ String sPermName = rRank.getPermName();
+ for (Integer key : this.ranks.keySet())
+ {
+ Rank rank = this.ranks.get(key);
+ if (rank.sPermissionName.equalsIgnoreCase(sPermName))
+ {
+ return key;
+ }
+ }
+ return 0;
+ }
+}
diff --git a/src/net/slipcor/classranks/core/Item.java b/src/net/slipcor/classranks/core/Item.java
new file mode 100644
index 0000000..88528be
--- /dev/null
+++ b/src/net/slipcor/classranks/core/Item.java
@@ -0,0 +1,64 @@
+package net.slipcor.classranks.core;
+
+
+import org.bukkit.Material;
+
+/**
+ *
+ * Independent type for blocks and items
+ * make it possible to separate the model from the minecraft server
+ * property:
+ * String sRef;
+ * Integer iValue;
+ * @author krglok
+ *
+ *
+ */
+
+
+public class Item
+{
+ private Material sRef;
+ private Integer iValue;
+
+ public Item()
+ {
+ sRef = Material.AIR;
+ iValue = 0;
+ }
+
+ public Item(Material itemRef, int value)
+ {
+ this.sRef = itemRef;
+ this.iValue = value;
+
+ }
+
+ public Material ItemRef()
+ {
+ return sRef;
+ }
+
+ public Integer value()
+ {
+// System.out.println(iValue);
+ return iValue;
+ }
+
+ public void setItemRef(Material itemRef)
+ {
+ sRef = itemRef;
+ }
+
+ public void setValue(int value)
+ {
+ iValue = value;
+ }
+
+ public void addValue(int value)
+ {
+ iValue = iValue + value;
+ }
+
+}
+
diff --git a/src/net/slipcor/classranks/core/ItemList.java b/src/net/slipcor/classranks/core/ItemList.java
new file mode 100644
index 0000000..869bd3f
--- /dev/null
+++ b/src/net/slipcor/classranks/core/ItemList.java
@@ -0,0 +1,290 @@
+package net.slipcor.classranks.core;
+
+import org.bukkit.Material;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+
+/**
+ * list of items, hold each item type unique
+ * if item exists the value are added
+ *
+ * @author oduda
+ *
+ */
+public class ItemList extends HashMap
+{
+/**
+ *
+ */
+ private static final long serialVersionUID = -3351533128792676311L;
+ // private Map itemList;
+ protected int itemCount;
+
+ public ItemList()
+ {
+// itemList = new HashMap();
+ itemCount = 0;
+ }
+
+// public Map getItemList() {
+// return itemList;
+// }
+//
+// public void setItemList(Map itemList) {
+// this.itemList = itemList;
+// }
+
+ /**
+ * add item to the list
+ * if exist values are add to exiting items
+ * @param item
+ */
+ public boolean addItem(Item item)
+ {
+ if (this.containsKey(item.ItemRef()))
+ {
+ Item exist = this.get(item.ItemRef());
+ exist.setValue(exist.value()+item.value());
+ } else
+ {
+ this.put(item.ItemRef(), item);
+ }
+ itemCount = itemCount + item.value();
+// Item item = new Item(itemRef, iValue);
+ return true;
+ }
+
+ /**
+ * add item to the list
+ * if exist values are overwrite
+ * @param itemRef
+ * @param iValue
+ * @return added item or null
+ */
+ public boolean addItem(Material itemRef, int iValue)
+ {
+ if (this.containsKey(itemRef))
+ {
+ Item exist = this.get(itemRef);
+ exist.setValue(exist.value()+iValue);
+ } else
+ {
+ this.put(itemRef, new Item(itemRef, iValue));
+ }
+ itemCount = itemCount + iValue;
+// Item item = new Item(itemRef, iValue);
+ return true;
+ }
+
+ /**
+ * add value to the item in the list
+ * if not exist add item
+ * @param itemRef
+ * @param iValue
+ * @return
+ */
+ public Item putItem(Material itemRef, int iValue)
+ {
+ Item item;
+ if (this.containsKey(itemRef))
+ {
+ item = this.get(itemRef);
+ item.setValue(item.value()+iValue);
+ itemCount = itemCount + iValue;
+ return item;
+ }
+ item = new Item(itemRef,iValue);
+ this.addItem(item);
+ return item;
+ }
+
+ /**
+ *
+ * @param itemRef
+ * @return
+ */
+ public Item getItem(Material itemRef)
+ {
+ return this.get(itemRef);
+ }
+
+// public Boolean isEmpty()
+// {
+// return itemList.isEmpty();
+// }
+
+ /**
+ * add value to item value
+ * if item not exist in list it will be created
+ * @param itemRef
+ * @param value
+ */
+ public void depositItem(Material itemRef, int iValue)
+ {
+ Item item;
+ if (containsKey(itemRef))
+ {
+ item = this.get(itemRef);
+// System.out.println("deposit: "+iValue);
+ item.setValue(item.value()+iValue);
+// put(itemRef, get(itemRef)+value);
+ } else
+ {
+ this.addItem(itemRef, iValue);
+ }
+ itemCount = itemCount + iValue;
+ }
+
+ /**
+ * bucht value von item ab ,
+ * wenn bestand > 0
+ * @param itemRef
+ * @param value
+ * @return
+ */
+ public Boolean withdrawItem(Material itemRef, int value)
+ {
+ int actual = 0;
+ if(this.containsKey(itemRef))
+ {
+ actual = this.get(itemRef).value();
+ }
+ if ((actual-value) >= 0)
+ {
+ value = value * -1;
+// System.out.println("withdraw: "+value);
+ this.depositItem(itemRef, (value));
+ return true;
+ }
+
+ return false;
+ }
+
+ public int getValue(Material itemRef)
+ {
+ Item item = get(itemRef);
+ if (item != null)
+ {
+ return item.value();
+ } else
+ {
+ return 0;
+ }
+ }
+
+ public void setValue(Material itemRef, int value)
+ {
+ putItem(itemRef, value);
+ }
+
+
+
+ public int getItemCount()
+ {
+ return itemCount;
+ }
+
+ /**
+ * calculate item count new form item values
+ */
+ public void setItemCount()
+ {
+ itemCount = 0;
+ for (Item item : this.values())
+ {
+ itemCount = itemCount + item.value();
+ }
+ }
+
+ public ArrayList sortItems()
+ {
+ ArrayList sortedItems = new ArrayList();
+ for (Material s : this.keySet())
+ {
+ sortedItems.add(s);
+ }
+ if (sortedItems.size() > 1)
+ {
+ Collections.sort
+ (sortedItems);
+ }
+ return sortedItems;
+ }
+
+ public void addAll(ItemList newList)
+ {
+ for (Item item : newList.values())
+ {
+ put(item.ItemRef(), item);
+ }
+ }
+
+
+ /**
+ * make a dowb count for required list by the amopunt
+ *
+ */
+ public void reduceRequired()
+ {
+ ArrayList deleteList = new ArrayList();
+ for (Item item : this.values())
+ {
+ if (item.value() > 0)
+ {
+ item.setValue(item.value()-1);
+ } else
+ {
+ deleteList.add(item.ItemRef());
+ }
+ }
+ for (Material key : deleteList )
+ {
+ this.remove(key);
+ }
+ }
+
+ public String asString()
+ {
+ int count = 0;
+ String value ="";
+ for (Material key : this.keySet())
+ {
+ if (count == 0)
+ {
+ value = key.name();
+ } else
+ {
+ value = value + ", "+key.name() ;
+ }
+ }
+ return value;
+ }
+
+ public void addList( ItemStack[] items)
+ {
+ if (items == null)
+ {
+ return;
+ }
+ for (int i=0;i
+{
+
+ /**
+ *
+ */
+ private static final long serialVersionUID = -3071712660629867671L;
+
+ private String uuid;
+ private String playername;
+
+ // private ArrayList playerClassRanks;
+
+ public PlayerClazzList(String uuid, String playerName)
+ {
+ super();
+ this.uuid =uuid;
+ this.playername = playername;
+ this.put("name", playerName);
+ }
+
+ /**
+ * @return the uuid
+ */
+ public String getUuid()
+ {
+ return uuid;
+ }
+
+ /**
+ * @param uuid the uuid to set
+ */
+ public void setUuid(String uuid)
+ {
+ this.uuid = uuid;
+ }
+
+
+ public void setPlayerName(String playerName)
+ {
+ this.setUuid(playerName);
+ this.put("name", playerName);
+ }
+
+ public String getPlayerName()
+ {
+ if (this.containsKey("name"))
+ {
+ return "";
+ }
+ return this.get("name");
+ }
+
+ public boolean equalsIgnoreCaseName(String playerName)
+ {
+ return playerName.equalsIgnoreCase(playerName);
+ }
+
+ public boolean addPlayerClassRank(String className, String rankName)
+ {
+ this.put(className, rankName);
+
+ return true;
+ }
+
+ public String getPlayerRank(String className)
+ {
+
+ return this.get(className);
+ }
+
+ public boolean equalsIgnoreCaseClass(String className)
+ {
+ for (String name : this.keySet())
+ {
+ if (name.equalsIgnoreCase(className))
+ {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ public boolean equalsIgnoreCaseRank(String rankName)
+ {
+ for (String rank : this.values())
+ {
+ if (rank.equalsIgnoreCase(rankName))
+ {
+ return true;
+ }
+ }
+ return false;
+ }
+
+
+}
diff --git a/src/net/slipcor/classranks/core/PlayerClazzRank.java b/src/net/slipcor/classranks/core/PlayerClazzRank.java
new file mode 100644
index 0000000..7b18cb4
--- /dev/null
+++ b/src/net/slipcor/classranks/core/PlayerClazzRank.java
@@ -0,0 +1,27 @@
+package net.slipcor.classranks.core;
+
+/**
+ *
+ * @author Windu
+ *
+ * define a Player Rank in a Clazz , will be used to track player clazzes
+ * - className = name of the ClassRank
+ * - rankName = name of the rank or permissionGroup
+ * The player can go rankUp or rankDown in the Clazz
+ * A player can have only one rank in each Clazz, given by this key/value
+ *
+ */
+public class PlayerClazzRank
+{
+ public String className;
+
+ public String rankName;
+
+ public PlayerClazzRank(String className, String rankName)
+ {
+ super();
+ this.className = className;
+ this.rankName = rankName;
+ }
+
+}
diff --git a/src/net/slipcor/classranks/core/Rank.java b/src/net/slipcor/classranks/core/Rank.java
index 5e43312..e754e96 100644
--- a/src/net/slipcor/classranks/core/Rank.java
+++ b/src/net/slipcor/classranks/core/Rank.java
@@ -6,18 +6,24 @@
import org.bukkit.inventory.ItemStack;
/**
- * rank class
+ * the class define a rank for a clazz. there multiple parameter for a rank.
+ * @param sPermName the permission name to use
+ * @param sDispName the display name
+ * @param cC the name ChatColor
+ * @param crc the class to add to
+ * @param isItems the rank items cost is a array of Items
+ * @param dCost the rank cost
+ * @param iExp the rank experience cost
*
* @version v0.3.0
- *
* @author slipcor
*/
-
-public class Rank {
- String sPermissionName;
+public class Rank
+{
+ String sPermissionName; // is also the rankName for references
String sDisplayName;
ChatColor cColor;
- Class crcSuper;
+ Clazz crcSuper;
ItemStack[] items;
private Double cost;
@@ -26,23 +32,16 @@ public class Rank {
/**
* create a rank instance
*
- * @param sPermName
- * the permission name to use
- * @param sDispName
- * the display name
- * @param cC
- * the name ChatColor
- * @param crc
- * the class to add to
- * @param isItems
- * the rank items cost
- * @param dCost
- * the rank cost
- * @param iExp
- * the rank experience cost
+ * @param sPermName the permission name to use
+ * @param sDispName the display name
+ * @param cC the name ChatColor
+ * @param crc the class to add to
+ * @param isItems the rank items cost
+ * @param dCost the rank cost
+ * @param iExp the rank experience cost
*/
- public Rank(String sPermName, String sDispName, ChatColor cC, Class crc,
- ItemStack[] isItems, double dCost, int iExp) {
+ public Rank(String sPermName, String sDispName, ChatColor cC, Clazz crc, ItemStack[] isItems, double dCost, int iExp)
+ {
this.sPermissionName = sPermName;
this.sDisplayName = sDispName;
this.cColor = cC;
@@ -57,7 +56,8 @@ public Rank(String sPermName, String sDispName, ChatColor cC, Class crc,
*
* @return the display name
*/
- public String getDispName() {
+ public String getDispName()
+ {
return this.sDisplayName;
}
@@ -66,7 +66,8 @@ public String getDispName() {
*
* @return the color
*/
- public ChatColor getColor() {
+ public ChatColor getColor()
+ {
return this.cColor;
}
@@ -75,7 +76,8 @@ public ChatColor getColor() {
*
* @return the class
*/
- public Class getSuperClass() {
+ public Clazz getSuperClass()
+ {
return this.crcSuper;
}
@@ -84,7 +86,8 @@ public Class getSuperClass() {
*
* @return the permission name
*/
- public String getPermName() {
+ public String getPermName()
+ {
return sPermissionName;
}
@@ -94,7 +97,8 @@ public String getPermName() {
* @param sDisplayName
* the display to use
*/
- public void setDispName(String sDisplayName) {
+ public void setDispName(String sDisplayName)
+ {
this.sDisplayName = sDisplayName;
}
@@ -104,31 +108,40 @@ public void setDispName(String sDisplayName) {
* @param cColor
* the color to use
*/
- public void setColor(ChatColor cColor) {
+ public void setColor(ChatColor cColor)
+ {
this.cColor = cColor;
}
- public Double getCost() {
+ public Double getCost()
+ {
return cost;
}
- public ArrayList getItems() {
- if (items == null) {
+ public ArrayList getItems()
+ {
+ if (items == null)
+ {
return null;
}
ArrayList result = new ArrayList();
- for (ItemStack i : items) {
- if (i == null) {
+ for (ItemStack item : items)
+ {
+ if (item == null) {
continue;
}
- if (i.getDurability() != 0) {
- result.add(i.getType().toString() + ":" + i.getDurability() + ":"+i.getAmount());
- } else {
- if (i.getAmount() != 0) {
- result.add(i.getType().toString() + ":"+i.getAmount());
- } else {
- result.add(i.getType().toString());
+ if (item.getDurability() != 0)
+ {
+ result.add(item.getType().toString() + ":" + item.getDurability() + ":"+item.getAmount());
+ } else
+ {
+ if (item.getAmount() != 0)
+ {
+ result.add(item.getType().toString() + ":"+item.getAmount());
+ } else
+ {
+ result.add(item.getType().toString());
}
}
}
diff --git a/src/net/slipcor/classranks/handlers/CRHandler.java b/src/net/slipcor/classranks/handlers/CRHandler.java
index aa6819a..fb9d92d 100644
--- a/src/net/slipcor/classranks/handlers/CRHandler.java
+++ b/src/net/slipcor/classranks/handlers/CRHandler.java
@@ -10,17 +10,99 @@
* @author slipcor
*/
-public abstract class CRHandler {
- public abstract boolean isInGroup(String world, String permName, String player);
+public abstract class CRHandler
+{
+ /**
+ * check if user in group
+ * use world = null for search in all worlds
+ *
+ * @param world
+ * @param permName
+ * @param player
+ * @return
+ */
+ public abstract boolean isInGroup(String world, String permName, Player player);
+
+ /**
+ * initialize permission provider
+ *
+ * @return
+ */
public abstract boolean setupPermissions();
- public abstract boolean hasPerms(Player comP, String string, String world);
- public abstract void classAdd(String world, String player, String cString);
- public abstract void classAddGlobal(String player, String cString);
- public abstract void rankAdd(String world, String player, String rank);
- public abstract void rankAddGlobal(String player, String rank);
- public abstract void rankRemove(String world, String player, String cString);
- public abstract void rankRemoveGlobal(String player, String cString);
- public abstract String getPermNameByPlayer(String world, String player);
- public abstract String getPermNameByPlayerGlobal(String player);
+
+ /**
+ * check permission
+ * use world = null for check in all worlds
+ *
+ * @param player
+ * @param string
+ * @param world
+ * @return
+ */
+ public abstract boolean hasPerms(Player player, String string, String world);
+
+ /**
+ * Add rank/group to player permission
+ * use classAddGlobal if congig allWorlds = true
+ *
+ * @param world
+ * @param player
+ * @param cString
+ */
+ public abstract void classAdd(String world, Player player, String cString);
+
+ /**
+ * add rank/group to player permission in all worlds
+ * use world = null
+ *
+ * @param player
+ * @param cString
+ */
+ public abstract void classAddGlobal(Player player, String cString);
+
+ /**
+ * Add rank/group to player permission
+ * use rankAddGlobal if congig allWorlds = true
+ *
+ * @param world
+ * @param player
+ * @param rank
+ */
+ public abstract void rankAdd( Player player, String rank);
+
+ /**
+ * add rank/group to player permission in all worlds
+ * use world = null
+ *
+ * @param player
+ * @param rank
+ */
+ public abstract void rankAddGlobal(Player player, String rank);
+
+ /**
+ * remove rank/group from player
+ * use rankRemoveGlobal if congig allWorlds = true
+ *
+ * @param world
+ * @param player
+ * @param cString
+ */
+ public abstract void rankRemove(Player player, String cString);
+
+ /**
+ * remove rank/group from player permission in all worlds
+ * use world = null
+ *
+ * @param player
+ * @param cString
+ */
+ public abstract void rankRemoveGlobal(Player player, String cString);
+
+ public abstract String getPermNameByPlayer(String world, Player player);
+
+ public abstract String getPermNameByPlayerGlobal(Player player);
+
public abstract void removeGroups(Player player);
+
+ public abstract String[] getPlayerGroups(Player player);
}
diff --git a/src/net/slipcor/classranks/handlers/HandleBPerms.java b/src/net/slipcor/classranks/handlers/HandleBPerms.java
deleted file mode 100644
index 9056f10..0000000
--- a/src/net/slipcor/classranks/handlers/HandleBPerms.java
+++ /dev/null
@@ -1,207 +0,0 @@
-package net.slipcor.classranks.handlers;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.logging.Level;
-
-import net.slipcor.classranks.ClassRanks;
-import net.slipcor.classranks.managers.ClassManager;
-import net.slipcor.classranks.managers.DebugManager;
-import net.slipcor.classranks.managers.PlayerManager;
-
-import org.bukkit.World;
-import org.bukkit.entity.Player;
-
-import de.bananaco.bpermissions.api.ApiLayer;
-import de.bananaco.bpermissions.api.util.CalculableType;
-
-/**
- * bPermissions handler class
- *
- * @version v0.4.3
- *
- * @author slipcor
- */
-
-public class HandleBPerms extends CRHandler {
- private final ClassRanks plugin;
- private final DebugManager db;
-
- public HandleBPerms(ClassRanks cr) {
- plugin = cr;
- db = new DebugManager(cr);
- }
-
- @Override
- public boolean isInGroup(String world, String permName, String player) {
- return ApiLayer.hasGroupRecursive(world, CalculableType.USER, player,
- permName);
- }
-
- /*
- * Function that tries to setup the permissions system, returns result
- */
- @Override
- public boolean setupPermissions() {
- // try to load permissions, return result
- try {
- ApiLayer al = new ApiLayer();
- plugin.log("<3 bPermissions", Level.INFO);
- return (al.toString() != null);
- } catch (Exception e) {
- db.i("bPerms not found");
- return false;
- }
- }
-
- @Override
- public boolean hasPerms(Player comP, String string, String world) {
- return comP.hasPermission(string);
- }
-
- /*
- * Add a user to a given class in the given world
- */
- @Override
- public void classAdd(String world, String player, String cString) {
- player = PlayerManager.search(player); // auto-complete playername
-
- String[] worlds = { world };
- if (world.equalsIgnoreCase("all")) {
- List lWorlds = plugin.getServer().getWorlds();
-
- worlds = new String[lWorlds.size()];
- for (int i = 0; i < lWorlds.size(); i++) {
- worlds[i] = lWorlds.get(i).getName();
- }
- }
- for (int i = 0; i < worlds.length; i++) {
- try {
- ApiLayer.addGroup(worlds[i], CalculableType.USER, player,
- cString);
- db.i("added group " + cString + " to player " + player
- + " in world " + worlds[i]);
- } catch (Exception e) {
- plugin.log("PermName " + cString + " or user " + player
- + " not found in world " + worlds[i], Level.WARNING);
- }
- }
- }
-
- /*
- * Add a user to a given rank in the given world
- */
- @Override
- public void rankAdd(String world, String player, String rank) {
- player = PlayerManager.search(player); // auto-complete playername
-
- String[] worlds = { world };
- if (world.equalsIgnoreCase("all")) {
- List lWorlds = plugin.getServer().getWorlds();
-
- worlds = new String[lWorlds.size()];
- for (int i = 0; i < lWorlds.size(); i++) {
- worlds[i] = lWorlds.get(i).getName();
- }
- }
- for (int i = 0; i < worlds.length; i++) {
- try {
- ApiLayer.addGroup(worlds[i], CalculableType.USER, player, rank);
- db.i("added rank " + rank + " to player " + player
- + " in world " + worlds[i]);
- } catch (Exception e) {
- plugin.log("PermName " + rank + " or user " + player
- + " not found in world " + worlds[i], Level.WARNING);
- }
- }
- }
-
- /*
- * Remove a user from the class he has in the given world
- */
- @Override
- public void rankRemove(String world, String player, String cString) {
- player = PlayerManager.search(player); // auto-complete playername
-
- String[] worlds = { world };
- if (world.equalsIgnoreCase("all")) {
- List lWorlds = plugin.getServer().getWorlds();
-
- worlds = new String[lWorlds.size()];
- for (int i = 0; i < lWorlds.size(); i++) {
- worlds[i] = lWorlds.get(i).getName();
- }
- }
- for (int i = 0; i < worlds.length; i++) {
- try {
- ApiLayer.removeGroup(worlds[i], CalculableType.USER, player,
- cString);
- db.i("removed rank " + cString + " from player " + player
- + " in world " + worlds[i]);
- } catch (Exception e) {
- plugin.log("PermName " + cString + " or user " + player
- + " not found in world " + worlds[i], Level.WARNING);
- }
- }
- }
-
- @Override
- public String getPermNameByPlayer(String world, String player) {
- player = PlayerManager.search(player); // auto-complete playername
- ArrayList permGroups = new ArrayList();
-
- String[] worlds = { world };
- if (world.equalsIgnoreCase("all")) {
- List lWorlds = plugin.getServer().getWorlds();
-
- worlds = new String[lWorlds.size()];
- for (int i = 0; i < lWorlds.size(); i++) {
- worlds[i] = lWorlds.get(i).getName();
- }
- }
- for (int i = 0; i < worlds.length; i++) {
- db.i("checking world "+worlds[i]);
- String[] list = ApiLayer.getGroups(worlds[i], CalculableType.USER,
- player);
- for (String sRank : list) {
- db.i("checking rank "+sRank);
- if (ClassManager.rankExists(sRank)) {
- permGroups.add(sRank);
- }
- }
-
- }
-
- db.i("player has groups: " + permGroups.toString());
- return ClassManager.getLastPermNameByPermGroups(permGroups);
- }
-
- @Override
- public void classAddGlobal(String player, String cString) {
-
- }
-
- @Override
- public void rankAddGlobal(String player, String rank) {
-
- }
-
- @Override
- public void rankRemoveGlobal(String player, String cString) {
-
- }
-
- @Override
- public String getPermNameByPlayerGlobal(String player) {
- return null;
- }
-
- @Override
- public void removeGroups(Player player) {
- String[] list = ApiLayer.getGroups(player.getWorld().getName(), CalculableType.USER, player.getName());
- for (String group : list) {
- ApiLayer.removeGroup(player.getWorld().getName(), CalculableType.USER, player.getName(),
- group);
- }
- }
-}
diff --git a/src/net/slipcor/classranks/handlers/HandlePEX.java b/src/net/slipcor/classranks/handlers/HandlePEX.java
deleted file mode 100644
index 171ba42..0000000
--- a/src/net/slipcor/classranks/handlers/HandlePEX.java
+++ /dev/null
@@ -1,213 +0,0 @@
-package net.slipcor.classranks.handlers;
-
-import java.util.ArrayList;
-import java.util.logging.Level;
-
-import net.slipcor.classranks.ClassRanks;
-import net.slipcor.classranks.managers.ClassManager;
-import net.slipcor.classranks.managers.DebugManager;
-import net.slipcor.classranks.managers.PlayerManager;
-
-import org.bukkit.entity.Player;
-
-import ru.tehkode.permissions.PermissionManager;
-
-/**
- * PermissionsEX handler class
- *
- * @version v0.4.3
- *
- * @author slipcor
- */
-
-public class HandlePEX extends CRHandler {
- private final ClassRanks plugin;
- private PermissionManager permissionHandler;
- private final DebugManager db;
-
- public HandlePEX(ClassRanks cr) {
- plugin = cr;
- db = new DebugManager(cr);
- }
-
- @Override
- public boolean isInGroup(String world, String permName, String player) {
- db.i("isInGroup: player "
- + player
- + ", world: "
- + world
- + ", perms: "
- + permName
- + ": "
- + String.valueOf(permissionHandler.getUser(player).inGroup(
- permName)));
-
- return permissionHandler.getUser(player).inGroup(permName);
- }
-
- @Override
- public boolean setupPermissions() {
- // try to fetch the PEX handler, return result
-
- permissionHandler = ru.tehkode.permissions.bukkit.PermissionsEx
- .getPermissionManager();
- if (permissionHandler == null) {
- db.i("PEX not found");
- return false;
- }
- plugin.log("<3 PEX", Level.INFO); // success!
- return true;
- }
-
- @Override
- public boolean hasPerms(Player comP, String string, String world) {
- db.i("player hasPerms: "
- + comP.getName()
- + ", world: "
- + world
- + ", perm: "
- + string
- + " : "
- + String.valueOf(comP.hasPermission(string) ? true
- : permissionHandler.has(comP.getName(), string, world)));
- return comP.hasPermission(string) ? true : permissionHandler.has(
- comP.getName(), string, world);
- }
-
- @Override
- public void classAdd(String world, String player, String cString) {
- player = PlayerManager.search(player); // auto-complete playername
-
- if (world.equalsIgnoreCase("all")) {
- classAddGlobal(player, cString);
- return;
- }
- try {
- permissionHandler.getUser(player).addGroup(cString, world);
- db.i("added group " + cString + " to player " + player
- + " in world " + world);
- } catch (Exception e) {
- plugin.log("PermName " + cString + " or user " + player
- + " not found in world " + world, Level.WARNING);
- }
- }
-
- @Override
- public void rankAdd(String world, String player, String rank) {
- player = PlayerManager.search(player); // auto-complete playername
-
- if (world.equalsIgnoreCase("all")) {
- rankAddGlobal(player, rank);
- return;
- }
- try {
- permissionHandler.getUser(player).addGroup(rank, world);
- db.i("added rank " + rank + " to player " + player
- + " in world " + world);
- } catch (Exception e) {
- plugin.log("PermName " + rank + " or user " + player
- + " not found in world " + world, Level.WARNING);
- }
- }
-
- @Override
- public void rankRemove(String world, String player, String cString) {
- player = PlayerManager.search(player); // auto-complete playername
-
- if (world.equalsIgnoreCase("all")) {
- rankRemoveGlobal(player, cString);
- return;
- }
- try {
- permissionHandler.getUser(player).removeGroup(cString,
- world);
- db.i("removed rank " + cString + " from player " + player
- + " in world " + world);
- } catch (Exception e) {
- plugin.log("PermName " + cString + " or user " + player
- + " not found in world " + world, Level.WARNING);
- }
- }
-
- @Override
- public String getPermNameByPlayer(String world, String player) {
- ArrayList permGroups = new ArrayList();
- player = PlayerManager.search(player); // auto-complete playername
-
- if (world.equalsIgnoreCase("all")) {
- return getPermNameByPlayerGlobal(player);
- }
- String[] groups = permissionHandler.getUser(player)
- .getGroupsNames(world);
-
- for (String group : groups)
- permGroups.add(group);
-
- db.i("player has groups: " + permGroups.toString());
- return ClassManager.getLastPermNameByPermGroups(permGroups);
- }
-
- @Override
- public void classAddGlobal(String player, String cString) {
- player = PlayerManager.search(player); // auto-complete playername
-
- try {
- permissionHandler.getUser(player).addGroup(cString);
- db.i("added group " + cString + " to player " + player);
- } catch (Exception e) {
- plugin.log("PermName " + cString + " or user " + player
- + " not found", Level.WARNING);
- }
- }
-
- @Override
- public void rankAddGlobal(String player, String rank) {
- player = PlayerManager.search(player); // auto-complete playername
-
- try {
- permissionHandler.getUser(player).addGroup(rank);
- db.i("added rank " + rank + " to player " + player);
- } catch (Exception e) {
- plugin.log("PermName " + rank + " or user " + player
- + " not found", Level.WARNING);
- }
- }
-
- @Override
- public void rankRemoveGlobal(String player, String cString) {
- player = PlayerManager.search(player); // auto-complete playername
-
- try {
- permissionHandler.getUser(player).removeGroup(cString);
- db.i("added rank " + cString + " to player " + player);
- } catch (Exception e) {
- plugin.log("PermName " + cString + " or user " + player
- + " not found", Level.WARNING);
- }
- }
-
- @Override
- public String getPermNameByPlayerGlobal(String player) {
- ArrayList permGroups = new ArrayList();
- player = PlayerManager.search(player); // auto-complete playername
-
- String[] groups = permissionHandler.getUser(player)
- .getGroupsNames();
-
- for (String group : groups)
- permGroups.add(group);
-
- db.i("player has groups: " + permGroups.toString());
- return ClassManager.getLastPermNameByPermGroups(permGroups);
- }
-
- @Override
- public void removeGroups(Player player) {
- String[] groups = permissionHandler.getUser(player)
- .getGroupsNames();
-
- for (String group : groups) {
- permissionHandler.getUser(player).removeGroup(group);
- }
- }
-}
diff --git a/src/net/slipcor/classranks/handlers/HandleSuperPerms.java b/src/net/slipcor/classranks/handlers/HandleSuperPerms.java
deleted file mode 100644
index 26c54b6..0000000
--- a/src/net/slipcor/classranks/handlers/HandleSuperPerms.java
+++ /dev/null
@@ -1,147 +0,0 @@
-package net.slipcor.classranks.handlers;
-
-import java.util.ArrayList;
-import java.util.Map;
-import java.util.logging.Level;
-
-import org.bukkit.entity.Player;
-
-import net.slipcor.classranks.ClassRanks;
-import net.slipcor.classranks.managers.ClassManager;
-import net.slipcor.classranks.managers.DebugManager;
-
-/**
- * SuperPermissions handler class
- *
- * @version v0.4.3
- *
- * @author slipcor
- */
-
-public class HandleSuperPerms extends CRHandler {
- private final ClassRanks plugin;
- private final DebugManager db;
-
- public HandleSuperPerms(ClassRanks cr) {
- plugin = cr;
- db = new DebugManager(cr);
- }
-
- @Override
- public boolean isInGroup(String world, String permName, String player) {
- Map nodes = plugin.getConfig().getConfigurationSection("players." + player).getValues(true);
-
- if (nodes != null)
- for (Object key : nodes.values())
- if (((String) key).equals(permName)) {
-
- db.i("isInGroup: player " + player + ", world: " + world + ", perms: " + permName + ": " + String.valueOf(true));
- return true;
- }
-
- db.i("isInGroup: player " + player + ", world: " + world + ", perms: " + permName + ": " + String.valueOf(false));
- return false;
- }
-
-
- /*
- * Function that tries to setup the permissions system, returns result
- */
- @Override
- public boolean setupPermissions() {
- plugin.log("No permissions plugin found, defaulting to SuperPerms.", Level.INFO); // success!
- return true;
- }
-
- @Override
- public boolean hasPerms(Player comP, String string, String world) {
- db.i("player hasPerms: " + comP.getName() + ", world: " + world + ", perm: " + string + " : " + String.valueOf( comP.hasPermission(string)));
- return comP.hasPermission(string);
- }
-
-
- /*
- * Add a user to a given class in the given world
- */
- @Override
- public void classAdd(String world, String player, String cString) {
- String firstRank = null;
- if (plugin.trackRanks) {
- firstRank = ClassManager.getFirstPermNameByClassName(cString, player);
- } else {
- firstRank = ClassManager.getFirstPermNameByClassName(cString);
- }
- plugin.getConfig().set("players." + player + "." + cString, firstRank);
- db.i("added group " + cString + " to player " + player + ", no world support");
- plugin.saveConfig();
- }
-
- /*
- * Add a user to a given rank in the given world
- */
- @Override
- public void rankAdd(String world, String player, String rank) {
- String cString = ClassManager.getClassNameByPermName(rank);
- plugin.getConfig().set("players." + player + "." + cString, rank);
- db.i("added rank " + rank + " to player " + player + ", no world support");
- plugin.saveConfig();
- }
-
- /*
- * Remove a user from the class he has in the given world
- */
- @Override
- public void rankRemove(String world, String player, String cString) {
- plugin.getConfig().set("players." + player, null);
- db.i("removed rank " + cString + " from player " + player + ", no world support");
- plugin.saveConfig();
- }
-
- @Override
- public String getPermNameByPlayer(String world, String player) {
- ArrayList permGroups = new ArrayList();
-
- Map groups = null;
- try {
- groups = plugin.getConfig().getConfigurationSection("players." + player).getValues(true);
- } catch (Exception e) {
-
- }
-
- if (groups == null) {
- return "";
- }
-
- for (Object group : groups.values())
- permGroups.add((String) group);
-
- db.i("player has groups: " + permGroups.toString());
- return ClassManager.getLastPermNameByPermGroups(permGroups);
- }
-
- @Override
- public void classAddGlobal(String player, String cString) {
- classAdd(null, player, cString);
- }
-
- @Override
- public void rankAddGlobal(String player, String rank) {
- rankAdd(null, player, rank);
- }
-
- @Override
- public void rankRemoveGlobal(String player, String cString) {
- rankRemove(null, player, cString);
- }
-
- @Override
- public String getPermNameByPlayerGlobal(String player) {
- return getPermNameByPlayer(null, player);
- }
-
- @Override
- public void removeGroups(Player player) {
- plugin.getConfig().set("players."+player.getName(), null);
- plugin.saveConfig();
- }
-}
diff --git a/src/net/slipcor/classranks/handlers/HandleVaultPerms.java b/src/net/slipcor/classranks/handlers/HandleVaultPerms.java
index 8eaecef..c9e09b0 100644
--- a/src/net/slipcor/classranks/handlers/HandleVaultPerms.java
+++ b/src/net/slipcor/classranks/handlers/HandleVaultPerms.java
@@ -1,208 +1,356 @@
package net.slipcor.classranks.handlers;
import java.util.ArrayList;
+import java.util.Map;
import java.util.logging.Level;
import net.milkbowl.vault.permission.Permission;
import net.slipcor.classranks.ClassRanks;
-import net.slipcor.classranks.managers.ClassManager;
-import net.slipcor.classranks.managers.DebugManager;
+import net.slipcor.classranks.managers.ClazzList;
+//import net.slipcor.classranks.managers.DebugManager;
import net.slipcor.classranks.managers.PlayerManager;
import org.bukkit.Bukkit;
+import org.bukkit.OfflinePlayer;
import org.bukkit.entity.Player;
import org.bukkit.plugin.RegisteredServiceProvider;
/**
* Vault permissions handler class
- *
+ * This will be the default Handler for permissions
* @version v0.4.3
*
- * @author slipcor
+ * @author slipcor, Krglok
*/
public class HandleVaultPerms extends CRHandler {
private final ClassRanks plugin;
- private final DebugManager db;
+// private final DebugManager db;
public static Permission permission = null;
- public HandleVaultPerms(ClassRanks cr) {
- plugin = cr;
- db = new DebugManager(cr);
+ public HandleVaultPerms(ClassRanks plugin) {
+ this.plugin = plugin;
+// db = new DebugManager(cr);
}
+// public boolean isInGroup(String world, String permName, String player)
+// {
+// return permission.playerInGroup(world, player, permName);
+// }
+//
@Override
- public boolean isInGroup(String world, String permName, String player) {
- return permission.playerInGroup(world, player, permName);
+ public boolean isInGroup(String world, String permName, Player player)
+ {
+ if (plugin.config.isDefaultrankallworlds())
+ {
+// return permission.playerInGroup(world, player, permName);
+ world = null;
+ return permission.playerInGroup(world,player.getName(), permName);
+ } else
+ {
+ return permission.playerInGroup(player, permName);
+ }
}
-
+
/*
* Function that tries to setup the permissions system, returns result
*/
@Override
- public boolean setupPermissions() {
+ public boolean setupPermissions()
+ {
// try to load permissions, return result
- RegisteredServiceProvider permissionProvider = Bukkit.getServicesManager().getRegistration(net.milkbowl.vault.permission.Permission.class);
- if (permissionProvider != null) {
- try {
- permission = permissionProvider.getProvider();
- getPermNameByPlayer(Bukkit.getWorlds().get(0).getName(), "slipcor");
- } catch (Exception e) {
- permission = null;
+// RegisteredServiceProvider permissionProvider = Bukkit.getServicesManager().getRegistration(net.milkbowl.vault.permission.Permission.class);
+ try
+ {
+ permission = plugin.permission;
+ permission.getGroups(); // test for permission is instanced
+// getPermNameByPlayer(Bukkit.getWorlds().get(0).getName(), "slipcor");
+ } catch (Exception e)
+ {
+ return false;
}
- }
- return (permission != null);
+ return true;
}
@Override
- public boolean hasPerms(Player comP, String string, String world) {
- return permission.has(world, comP.getName(), string);
+ public boolean hasPerms(Player player, String perm, String world)
+ {
+ if (world == null) world = "";
+ if (perm == null) return false;
+ if (permission == null)
+ {
+ System.out.println("no VAULT not instance !");
+ return false;
+ }
+ if (plugin.config.isDefaultrankallworlds())
+ {
+ world = null;
+ return permission.playerHas(world, player.getName(), perm);
+ } else
+ {
+// return permission.playerHas(world, player, perm);
+ return permission.playerHas(player, perm);
+ }
}
/*
* Add a user to a given class in the given world
+ * diese funktion ist wahrscheinlich unnötig !!
*/
@Override
- public void classAdd(String world, String player, String cString) {
+ public void classAdd(String world, Player player, String cString)
+ {
- player = PlayerManager.search(player); // auto-complete playername
+// player = PlayerManager.searchName(player); // auto-complete playername
- if (world.equalsIgnoreCase("all")) {
+ if (plugin.config.isDefaultrankallworlds())
+ {
classAddGlobal(player, cString);
return;
}
- try {
- permission.playerAddGroup(world, player, cString);
- db.i("added group " + cString + " to player " + player
- + " in world " + world);
+ try
+ {
+
+// permission.playerAddGroup(world, player, cString);
+ permission.playerAddGroup(player, cString);
+ plugin.db.i("added group " + cString + " to player " + player+ " in world " + world);
+ } catch (Exception e)
+ {
+ ClassRanks.log("Exception Add Class " + cString + " or user " + player + " not found in world " + world, Level.WARNING);
+ }
+ }
+
+
+ @Override
+ /**
+ * Add Class/rank in all worlds
+ * world set to null
+ *
+ */
+ public void classAddGlobal(Player player, String cString)
+ {
+// player = PlayerManager.searchName(player); // auto-complete playername
+ String world = null;
+ try
+ {
+ if (permission.playerAddGroup(player, cString) == false)
+ {
+ ClassRanks.log("ERROR ADD PermName " + cString + " or user " + player + " ", Level.SEVERE);
+
+ } else
+ {
+ ClassRanks.log("Vault Global PermName " + cString + ": user " + player , Level.INFO);
+ plugin.db.i("Added Class/Rank " + cString + " to player " + player);
+ }
} catch (Exception e) {
- plugin.log("PermName " + cString + " or user " + player
- + " not found in world " + world, Level.WARNING);
+ ClassRanks.log("Exception Add Class Global " + cString + " or user " + player, Level.SEVERE);
}
}
-
+
/*
* Add a user to a given rank in the given world
+ * if world = all then rank added without world
+ * stores player Rank also in the config
*/
@Override
- public void rankAdd(String world, String player, String rank) {
- player = PlayerManager.search(player); // auto-complete playername
-
- if (world.equalsIgnoreCase("all")) {
+ public void rankAdd(Player player, String rank)
+ {
+ if (plugin.config.isDefaultrankallworlds())
+ {
+ System.out.println("CR rankAddGlobal");
rankAddGlobal(player, rank);
- return;
- }
- try {
- permission.playerAddGroup(world, player, rank);
- db.i("added rank " + rank + " to player " + player
- + " in world " + world);
- } catch (Exception e) {
- plugin.log("PermName " + rank + " or user " + player
- + " not found in world " + world, Level.WARNING);
+ } else
+ {
+ try
+ {
+ if (permission.playerAddGroup(player, rank))
+ {
+ plugin.db.i("Vault added rank " + rank + " to player " + player + " in world " + player.getWorld().getName());
+// String cString = ClazzList.getClassNameByPermName(rank);
+// plugin.getConfig().set("players." + player + "." + cString, rank);
+// plugin.getConfig().set("worlds." + player.getWorld().getName() + "." + player, rank);
+// plugin.saveConfig();
+ plugin.db.i("Vault PermName " + rank + ": user " + player + " set " + player.getWorld().getName());
+
+ } else {
+ plugin.db.i("ERROR Vault added rank " + rank + " to player " + player + " in world " + player.getWorld().getName());
+ }
+ } catch (Exception e) {
+ ClassRanks.log("Exception added rank " + rank + " or user " + player + " not found in world " + player.getWorld().getName(), Level.WARNING);
+ }
}
}
- /*
- * Remove a user from the class he has in the given world
+ /**
+ * add rank/group in all worlds
+ * world set to null
*/
@Override
- public void rankRemove(String world, String player, String cString) {
- player = PlayerManager.search(player); // auto-complete playername
-
- if (world.equalsIgnoreCase("all")) {
- rankRemoveGlobal(player, cString);
- return;
- }
- try {
- permission.playerRemoveGroup(world, player, cString);
- db.i("removed rank " + cString + " from player " + player
- + " in world " + world);
- } catch (Exception e) {
- plugin.log("PermName " + cString + " or user " + player
- + " not found in world " + world, Level.WARNING);
+ public void rankAddGlobal(Player player, String rank)
+ {
+ ClassRanks.log("ADD PermName " + rank + " or user " + player + " ", Level.INFO);
+// player = PlayerManager.searchName(player); // auto-complete playername
+ String cString = ClazzList.getClassNameByPermName(rank);
+ String world = null;
+ try
+ {
+ if (permission.playerAddGroup(world, player.getName(), rank)==false)
+// if (permission.playerAddGroup(player, rank)==false)
+ {
+ ClassRanks.log("ERROR ADD PermName " + rank + " or user " + player + " ", Level.SEVERE);
+
+ } else
+ {
+ ClassRanks.log("Vault Global PermName " + rank + ": user " + player , Level.INFO);
+ plugin.db.i("Global added rank " + rank + " to player " + player);
+
+ }
+ } catch (Exception e)
+ {
+ ClassRanks.log("Exception ADD GLOBAL RANK " + rank + " or user " + player, Level.SEVERE);
+ ClassRanks.log(e.getMessage(), Level.SEVERE);
+ ClassRanks.log(e.getClass().getName(), Level.SEVERE);
+ ClassRanks.log(e.getCause().getMessage(), Level.SEVERE);
}
}
- @Override
- public String getPermNameByPlayer(String world, String player) {
- player = PlayerManager.search(player); // auto-complete playername
- ArrayList permGroups = new ArrayList();
- if (world.equalsIgnoreCase("all")) {
- return getPermNameByPlayerGlobal(player);
- }
- db.i("checking world "+world);
- String[] list = permission.getPlayerGroups(world, player);
- for (String sRank : list) {
- db.i("checking rank "+sRank);
- if (ClassManager.rankExists(sRank)) {
- permGroups.add(sRank);
+ /* (non-Javadoc)
+ * @see net.slipcor.classranks.handlers.CRHandler#getPermNameByPlayer(java.lang.String, java.lang.String)
+ */
+ @Override
+ public String getPermNameByPlayer(String world, Player player)
+ {
+ String[] groups = null;
+ String cPerm = "";
+
+ if (plugin.config.isDefaultrankallworlds())
+ {
+ try
+ {
+// groups = plugin.getConfig().getConfigurationSection("players." + player).getValues(true);
+// groups = permission.getPlayerGroups(player);
+ groups = permission.getPlayerGroups(world,player.getName());
+ } catch (Exception e) {
+ plugin.db.i("Exception GetPermByPlayer : GetPlayerGroups");
+ return "";
+ }
+
+ if (groups.length == 0)
+ {
+ return "";
+ }
+ // Set last Value as result
+ return groups[groups.length];
+ } else
+ {
+ try {
+// groups = (Map) plugin.getConfig().getConfigurationSection("worlds." + world);
+ groups = permission.getPlayerGroups(world,player.getName());
+ } catch (Exception e) {
+ plugin.db.i("Exception GetPermByPlayer : GetConfigurationSection");
+ return "";
+ }
+
+ if (groups.length == 0)
+ {
+ return "";
}
+ return groups[groups.length];
+
}
- db.i("player has groups: " + permGroups.toString());
- return ClassManager.getLastPermNameByPermGroups(permGroups);
}
@Override
- public void classAddGlobal(String player, String cString) {
- player = PlayerManager.search(player); // auto-complete playername
- try {
- permission.playerAddGroup(Bukkit.getPlayer(player), cString);
- db.i("added rank " + cString + " to player " + player);
- } catch (Exception e) {
- plugin.log("PermName " + cString + " or user " + player
- + " not found", Level.WARNING);
+ public String getPermNameByPlayerGlobal(Player player)
+ {
+// player = PlayerManager.searchName(player); // auto-complete playername
+ ArrayList permGroups = new ArrayList();
+ String world = null;
+ String[] list = permission.getPlayerGroups(world,player.getName());
+ for (String sRank : list)
+ {
+ plugin.db.i("checking rank "+sRank);
+ if (ClazzList.rankExists(sRank))
+ {
+ permGroups.add(sRank);
+ }
}
+ plugin.db.i("player has groups: " + permGroups.toString());
+ return ClazzList.getLastPermNameByPermGroups(permGroups);
}
+
+
+ /**
+ * Remove a user from the Rank in world that is current
+ * if world = all then rank added without world
+ * Remove player Rank also in the config
+ */
@Override
- public void rankAddGlobal(String player, String rank) {
- player = PlayerManager.search(player); // auto-complete playername
- try {
- permission.playerAddGroup(Bukkit.getPlayer(player), rank);
- db.i("added rank " + rank + " to player " + player);
- } catch (Exception e) {
- plugin.log("PermName " + rank + " or user " + player
- + " not found", Level.WARNING);
+ public void rankRemove(Player player, String rank)
+ {
+// player = PlayerManager.searchName(player); // auto-complete playername
+ if (plugin.config.isDefaultrankallworlds())
+ {
+ System.out.println("CR rankRemoveGlobal");
+ rankRemoveGlobal(player, rank);
+ } else
+ {
+ try
+ {
+ if (permission.playerRemoveGroup(player, rank))
+ {
+ plugin.db.i("removed rank " + rank + " from player " + player.getDisplayName()+ " in world ");
+ } else
+ {
+ plugin.db.i("NOT removed rank " + rank + " from " + player.getDisplayName()+ " in world ");
+ }
+ } catch (Exception e) {
+ ClassRanks.log("Exception Remove Rank " + rank + " or user " + player+ " not found in world " , Level.WARNING);
+ }
}
}
@Override
- public void rankRemoveGlobal(String player, String cString) {
-
- player = PlayerManager.search(player); // auto-complete playername
-
- try {
- permission.playerRemoveGroup(Bukkit.getPlayer(player), cString);
- db.i("removed rank " + cString + " from player " + player);
+ public void rankRemoveGlobal(Player player, String rank)
+ {
+ String world = null;
+ try
+ {
+ permission.playerRemoveGroup(world,player.getName(), rank);
+ plugin.db.i("removed rank " + rank + " from player " + player.getDisplayName());
} catch (Exception e) {
- plugin.log("PermName " + cString + " or user " + player
- + " not found ", Level.WARNING);
+ ClassRanks.log("Exception Remove Group Global" + rank + " or user " + player.getDisplayName()+ " not found ", Level.SEVERE);
}
}
+
+ /**
+ * This function remove ALL groups from the player
+ *
+ */
@Override
- public String getPermNameByPlayerGlobal(String player) {
- player = PlayerManager.search(player); // auto-complete playername
- ArrayList permGroups = new ArrayList();
-
- String[] list = permission.getPlayerGroups(Bukkit.getPlayer(player));
- for (String sRank : list) {
- db.i("checking rank "+sRank);
- if (ClassManager.rankExists(sRank)) {
- permGroups.add(sRank);
+ public void removeGroups(Player player)
+ {
+ String[] list = permission.getPlayerGroups(player);
+ if (list != null)
+ {
+ for (String sRank : list)
+ {
+ permission.playerRemoveGroup(player, sRank);
}
}
- db.i("player has groups: " + permGroups.toString());
- return ClassManager.getLastPermNameByPermGroups(permGroups);
}
- @Override
- public void removeGroups(Player player) {
- String[] list = permission.getPlayerGroups(player);
- for (String sRank : list) {
- permission.playerRemoveGroup(player, sRank);
- }
+
+
+ @Override
+ public String[] getPlayerGroups(Player player)
+ {
+ String world = null;
+ return permission.getPlayerGroups(world,player.getName());
+// return permission.getPlayerGroups(player);
}
}
diff --git a/src/net/slipcor/classranks/listeners/CRServerListener.java b/src/net/slipcor/classranks/listeners/CRServerListener.java
index fde59a2..d4dca14 100644
--- a/src/net/slipcor/classranks/listeners/CRServerListener.java
+++ b/src/net/slipcor/classranks/listeners/CRServerListener.java
@@ -4,7 +4,7 @@
import net.slipcor.classranks.ClassRanks;
import net.slipcor.classranks.Update;
-import net.slipcor.classranks.managers.CommandManager;
+import net.slipcor.classranks.commands.PlayerCommands;
import net.slipcor.classranks.managers.DebugManager;
import net.slipcor.classranks.register.payment.Methods;
@@ -26,22 +26,24 @@
*
* -
*
- * @version v0.4.0
+ * @version v0.4.6
*
- * @author slipcor
+ * @author slipcor/krglog
*/
-public class CRServerListener implements Listener {
+public class CRServerListener implements Listener
+{
private final Methods methods;
private final ClassRanks plugin;
- private final CommandManager cmdMgr;
+ private final PlayerCommands cmdMgr;
private final DebugManager db;
- public CRServerListener(ClassRanks plugin, CommandManager classes) {
+ public CRServerListener(ClassRanks plugin, PlayerCommands cmdMgr)
+ {
this.plugin = plugin;
this.methods = new Methods();
- cmdMgr = classes;
+ this.cmdMgr = cmdMgr;
db = new DebugManager(plugin);
}
@@ -63,7 +65,8 @@ public void onPlayerInteract(PlayerInteractEvent event) {
db.i("right block click!");
// we clicked a block
- if (cmdMgr.signCheck[0] == null) {
+ if ((plugin.config.isSigncheck() == false) || (plugin.config.isSigncheck() == null))
+ {
return; // no sign usage => OUT
}
db.i("we want to check for sign usage!");
@@ -74,23 +77,38 @@ public void onPlayerInteract(PlayerInteractEvent event) {
}
db.i("we clicked a sign!");
// we clicked a sign!
- Sign s = (Sign) bBlock.getState();
+ Sign sign = (Sign) bBlock.getState();
+ db.i("sign 0: "+plugin.config.getSigns()[0]);
- if (s.getLine(0).equals(cmdMgr.signCheck[0])) {
- db.i("parsing command " + s.getLine(1));
- String[] sArgs = {s.getLine(1)}; // parse the command!
+ if (sign.getLine(0).equals(plugin.config.getSigns()[0]))
+ {
+ db.i("parsing command " + sign.getLine(1));
+ String[] sArgs = new String[3];
+ sArgs[0] = "ADD";
+ sArgs[1] = event.getPlayer().getName();
+ sArgs[2] = sign.getLine(1); // parse the command!
cmdMgr.parseCommand(event.getPlayer(), sArgs);
- } else {
+ } else
+ {
db.i("searching for rank commands");
- for (int i = 0 ; i <= 3; i++) {
- if (s.getLine(i).equals(cmdMgr.signCheck[1])) {
+ for (int i = 0 ; i <= 3; i++)
+ {
+ if (sign.getLine(i).equals(plugin.config.getSigns()[1]))
+ {
db.i("rankup found, parsing...");
- String[] sArgs = {"rankup"};
+ String[] sArgs = new String[3];
+ sArgs[0] = "RANKUP";
+ sArgs[1] = event.getPlayer().getName();
+ sArgs[2] = sign.getLine(1); // parse the command!
cmdMgr.parseCommand(event.getPlayer(), sArgs);
return;
- } else if (s.getLine(i).equals(cmdMgr.signCheck[2])) {
+ } else if (sign.getLine(i).equals(plugin.config.getSigns()[2]))
+ {
db.i("rankup found, parsing");
- String[] sArgs = {"rankdown"};
+ String[] sArgs = new String[3];
+ sArgs[0] = "RANKDOWN";
+ sArgs[1] = event.getPlayer().getName();
+ sArgs[2] = sign.getLine(1); // parse the command!
cmdMgr.parseCommand(event.getPlayer(), sArgs);
return;
}
@@ -127,5 +145,6 @@ public void onPluginEnable(PluginEnableEvent event) {
plugin.log("<3 " + plugin.method.getName() + " version: " + plugin.method.getVersion(),Level.INFO);
}
}
+ // Autoupdate are not used
}
}
\ No newline at end of file
diff --git a/src/net/slipcor/classranks/managers/ClassManager.java b/src/net/slipcor/classranks/managers/ClassManager.java
deleted file mode 100644
index 2761f42..0000000
--- a/src/net/slipcor/classranks/managers/ClassManager.java
+++ /dev/null
@@ -1,265 +0,0 @@
-package net.slipcor.classranks.managers;
-
-import java.util.ArrayList;
-
-import net.slipcor.classranks.ClassRanks;
-import net.slipcor.classranks.core.Class;
-import net.slipcor.classranks.core.Rank;
-
-import org.bukkit.Bukkit;
-import org.bukkit.ChatColor;
-import org.bukkit.entity.Player;
-import org.bukkit.inventory.ItemStack;
-
-/**
- * class manager class
- *
- * @version v0.3.0
- *
- * @author slipcor
- */
-
-public class ClassManager {
- private static ArrayList classes = new ArrayList();
- private static ClassRanks plugin;
- private static DebugManager db;
-
- public ClassManager(ClassRanks cr) {
- plugin = cr;
- db = new DebugManager(cr);
- }
-
- public void add(String sClassName) {
- classes.add(new Class(sClassName));
- }
-
- public static String getFirstPermNameByClassName(String cString) {
- // standard version: get first rank
- for (Class c : classes) {
- for (Rank r : c.ranks) {
- if (c.name.equals(cString))
- return r.getPermName();
- }
- }
- return null;
- }
-
- public static String getFirstPermNameByClassName(String cString, String sPlayer) {
- // extended version: get rank
- for (Class c : classes) {
- if (c.name.equals(cString))
- return c.ranks.get(ClassManager.loadClassProcess(Bukkit.getPlayer(sPlayer), c)).getPermName();
- }
- return null;
- }
-
- public static String getClassNameByPermName(String rank) {
- for (Class c : classes) {
- for (Rank r : c.ranks) {
- if (r.getPermName().equals(rank))
- return c.name;
- }
- }
- return null;
- }
-
- public static String getLastPermNameByPermGroups(ArrayList permGroups) {
- String sPermName = "";
- for (Class c : classes) {
- for (Rank r : c.ranks) {
- db.i(c.name + " => " + r.getPermName());
- if (permGroups.contains(r.getPermName()))
- sPermName = r.getPermName();
- }
- }
- return sPermName;
- }
-
- public static Rank getRankByPermName(String sPermName) {
- for (Class c : classes) {
- for (Rank r : c.ranks) {
- if (r.getPermName().equals(sPermName))
- return r;
- }
- }
- return null;
- }
-
- public static Rank getNextRank(Rank rank, int rankOffset) {
- return rank.getSuperClass().ranks.get(rank.getSuperClass().ranks.indexOf(rank)+rankOffset);
- }
-
- private static Class getClassbyClassName(String sClassName) {
- for (Class c : classes) {
- if (c.name.equals(sClassName))
- return c;
- }
- return null;
- }
-
- public static boolean rankExists(String sRank) {
- for (Class c : classes) {
- for (Rank r : c.ranks) {
- if (r.getPermName().equals(sRank))
- return true;
- }
- }
- return false;
- }
-
- public static ArrayList getClasses() {
- return classes;
- }
-
- public static boolean configClassRemove(String sClassName, Player pPlayer) {
- Class cClass = getClassbyClassName(sClassName);
- if (cClass != null) {
- classes.remove(cClass);
- plugin.msg(pPlayer, "Class removed: " + sClassName);
- plugin.save_config();
- return true;
- }
- plugin.msg(pPlayer, "Class not found: " + sClassName);
- return true;
- }
-
- public static boolean configRankRemove(String sClassName, String sPermName, Player pPlayer) {
- Class cClass = getClassbyClassName(sClassName);
- if (cClass != null) {
- Rank rank = getRankByPermName(sPermName);
- if (rank != null) {
- ChatColor cColor = rank.getColor();
- cClass.ranks.remove(rank);
- plugin.msg(pPlayer, "Rank removed: " + cColor + sPermName);
- plugin.save_config();
- return true;
- }
- plugin.msg(pPlayer, "Rank not found: " + sPermName);
- return true;
- }
- plugin.msg(pPlayer, "Class not found: " + sClassName);
- return true;
- }
-
-
- public static boolean configClassAdd(String sClassName, String sPermName, String sDispName, String sColor, ItemStack[] isItems, double dCost, int iExp, Player pPlayer) {
- Class cClass = getClassbyClassName(sClassName);
- if (cClass == null) {
- Class c = new Class(sClassName);
- c.add(sPermName, sDispName, (FormatManager.formatColor(sColor)), isItems, dCost, iExp);
- classes.add(c);
- if (pPlayer == null)
- db.i("Class added: " + sClassName);
- else
- plugin.msg(pPlayer, "Class added: " + sClassName);
- plugin.save_config();
- return true;
-
- }
- if (pPlayer == null)
- db.i("Class already exists: " + sClassName);
- else
- plugin.msg(pPlayer, "Class already exists: " + sClassName);
- return true;
- }
-
- public static boolean configRankAdd(String sClassName, String sPermName, String sDispName, String sColor, ItemStack[] isItems, double dCost, int iExp, Player pPlayer) {
- Class cClass = getClassbyClassName(sClassName);
- if (cClass != null) {
- cClass.ranks.add(new Rank(sPermName, sDispName, (FormatManager.formatColor(sColor)), cClass, isItems, dCost, iExp));
- if (pPlayer == null)
- db.i("Rank added: " + (FormatManager.formatColor(sColor)) + sPermName);
- else
- plugin.msg(pPlayer, "Rank added: " + (FormatManager.formatColor(sColor)) + sPermName);
- plugin.save_config();
- return true;
- }
- if (pPlayer == null)
- db.i("Class not found: " + sClassName);
- else
- plugin.msg(pPlayer, "Class not found: " + sClassName);
- return true;
- }
-
- public static boolean configClassChange(String sClassName, String sClassNewName, Player pPlayer) {
- Class cClass = getClassbyClassName(sClassName);
- if (cClass != null) {
- cClass.name = sClassNewName;
- plugin.msg(pPlayer, "Class changed: " + sClassName + " => " + sClassNewName);
- plugin.save_config();
- return true;
- }
- plugin.msg(pPlayer, "Class not found: " + sClassName);
- return true;
- }
-
- public static boolean configRankChange(String sClassName, String sPermName, String sDispName, String sColor, Player pPlayer) {
- Class cClass = getClassbyClassName(sClassName);
- if (cClass != null) {
- Rank rank = getRankByPermName(sPermName);
- if (rank != null) {
- rank.setDispName(sDispName);
- rank.setColor((FormatManager.formatColor(sColor)));
- plugin.msg(pPlayer, "Rank updated: " + (FormatManager.formatColor(sColor)) + sPermName);
- plugin.save_config();
- return true;
- }
- plugin.msg(pPlayer, "Rank not found: " + sPermName);
- }
- plugin.msg(pPlayer, "Class not found: " + sClassName);
- return true;
- }
-
- public static void saveClassProgress(Player pPlayer) {
- db.i("saving class process");
- String s = plugin.getConfig().getString("progress."+pPlayer.getName());
- db.i("progress of "+pPlayer.getName()+": "+s);
- Rank rank = ClassManager.getRankByPermName(plugin.perms.getPermNameByPlayer(pPlayer.getWorld().getName(), pPlayer.getName()));
- if (rank == null) {
- db.i("rank is null!");
- return;
- }
-
- int rankID = rank.getSuperClass().ranks.indexOf(rank);
- db.i("rank ID: "+rankID);
- int classID = classes.indexOf(rank.getSuperClass());
- db.i("classID: "+classID);
-
- if (s != null && s.length() == classes.size()) {
-
- char[] c = s.toCharArray();
- c[classID] = String.valueOf(rankID).charAt(0);
- db.i("new c[classID]: "+c[classID]);
-
- db.i("saving: "+c.toString());
- plugin.getConfig().set("progress."+pPlayer.getName(), String.valueOf(c.toString()));
-
- return;
- }
-
- db.i("no entry yet!");
- String result = "";
- for (int i = 0; i clazzes = new HashMap();
+ private ClassRanks plugin;
+
+ // private static DebugManager db;
+
+ public ClazzList(ClassRanks cr)
+ {
+ this.plugin = cr;
+ // db = new DebugManager(cr);
+ }
+
+ public int getIndex(Clazz cClazz)
+ {
+ int index = 0;
+ for (Clazz clazz : clazzes.values())
+ {
+ if (clazz.clazzName.equalsIgnoreCase(cClazz.clazzName))
+ {
+ return index;
+ }
+ index++;
+ }
+ return 0;
+ }
+
+ /**
+ * search for ClazzName with ignoreCase
+ *
+ * @param sClassname
+ * @return true if found
+ */
+ public boolean containClazz(String sClassname)
+ {
+ for (String key : clazzes.keySet())
+ {
+ if (key.equalsIgnoreCase(sClassname))
+ {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * create new Clazz and add to the List of clazzes
+ * check if clazzName are always available
+ * the key is uppercase , ignoreCase in the list
+ *
+ * @param sClassName
+ */
+ public void add(String sClassName)
+ {
+ if (this.containClazz(sClassName) == false)
+ {
+ String key = sClassName.toUpperCase();
+ clazzes.put(key,new Clazz(sClassName));
+ }
+ }
+
+ public String getFirstPermNameByClassName(String sClassName)
+ {
+ // standard version: get first rank
+ if (this.containClazz(sClassName))
+ {
+ String key = sClassName.toUpperCase();
+ Clazz clazz = this.clazzes.get(key);
+ if (clazz.ranks.size() > 0)
+ {
+ return clazz.ranks.get(1).getPermName();
+ }
+ }
+ return null;
+ }
+
+// public static String getFirstPermNameByClassName(String cString, String sPlayer)
+// {
+// // extended version: get rank
+// for (Clazz c : clazzes)
+// {
+// if (c.name.equals(cString))
+// {
+// return c.ranks
+// .get(ClazzList.loadClassProcess(
+// Bukkit.getPlayer(sPlayer), c)).getPermName();
+// }
+// }
+// return null;
+// }
+
+ /**
+ * search for classname by Rank / sPermname
+ *
+ * @param rank
+ * @return clazzName or null
+ */
+ public String getClassNameByPermName(String permName)
+ {
+ for (Clazz clazz : clazzes.values())
+ {
+ for (Rank r : clazz.ranks.values())
+ {
+ if (r.getPermName().equalsIgnoreCase(permName))
+ return clazz.clazzName;
+ }
+ }
+ return null;
+ }
+
+ /**
+ * search permissionName in permissionGroup (via Vault)
+ *
+ * @param permGroups
+ * @return permissionName or emptyString
+ */
+ public String getLastPermNameByPermGroups(
+ ArrayList permGroups)
+ {
+ String sPermName = "";
+ for (Clazz clazz : clazzes.values())
+ {
+ for (Rank rank : clazz.ranks.values())
+ {
+ plugin.db.i(clazz.clazzName + " => " + rank.getPermName());
+ if (permGroups.contains(rank.getPermName()))
+ {
+ sPermName = rank.getPermName();
+ }
+ }
+ }
+ return sPermName;
+ }
+
+
+ /**
+ * search for Rank by permissionName
+ *
+ * @param sPermName
+ * @return Rank or null
+ */
+ public Rank getRankByPermName(String sPermName)
+ {
+ for (Clazz clazz : clazzes.values())
+ {
+ for (Rank rank : clazz.ranks.values())
+ {
+ if (rank.getPermName().equals(sPermName))
+ {
+ return rank;
+ }
+ }
+ }
+ return null;
+ }
+
+ /**
+ * search for Rank in a List of PermissionName
+ *
+ * @param sPermName
+ * @return Rank or null
+ */
+ public Rank getRankByPermName(String[] sPermName)
+ {
+ for (Clazz clazz : clazzes.values())
+ {
+ for (Rank rank : clazz.ranks.values())
+ {
+ for (String permName : sPermName)
+ {
+ plugin.db.i("Rank: " + rank.getPermName() + " Group: "+ permName);
+ if (rank.getPermName().equals(permName))
+ {
+ return rank;
+ }
+ }
+ }
+ }
+ return null;
+ }
+
+ public Clazz getClazzByRank(Rank rank)
+ {
+ for (Clazz clazz : this.clazzes.values())
+ {
+ if (clazz.clazzName.equalsIgnoreCase(rank.getSuperClass().clazzName))
+ {
+ return clazz;
+ }
+ }
+ return null;
+ }
+
+ public Rank getNextRank(Rank rank, int rankIndex)
+ {
+ Clazz clazz = getClazzByRank(rank);
+ if (clazz != null)
+ {
+ return clazz.nextRank(rank.getPermName());
+ }
+
+// if (rankIndex + 1 < rank.getSuperClass().ranks.size())
+// {
+// return rank.getSuperClass().ranks.get(rankIndex + 1);
+// } else
+// {
+// return null;
+// }
+ return null;
+ }
+
+ public Rank getPrevRank(Rank rank, int rankIndex)
+ {
+ Clazz clazz = getClazzByRank(rank);
+ if (clazz != null)
+ {
+ return clazz.prevRank(rank.getPermName());
+ }
+// if (rankIndex > 0)
+// {
+// return rank.getSuperClass().ranks.get(rankIndex - 1);
+// } else
+// {
+// return null;
+// }
+ return null;
+ }
+
+ private Clazz getClassbyClassName(String sClassName)
+ {
+ if (this.containClazz(sClassName))
+ {
+ sClassName = sClassName.toUpperCase();
+ return this.getClassbyClassName(sClassName);
+ }
+// for (Clazz c : clazzes)
+// {
+// if (c.name.equals(sClassName))
+// return c;
+// }
+ return null;
+ }
+
+ public boolean rankExists(String sRank)
+ {
+ for (Clazz clazz : clazzes.values())
+ {
+ for (Rank r : clazz.ranks.values())
+ {
+ if (r.getPermName().equals(sRank))
+ {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ public HashMap getClasses()
+ {
+ return clazzes;
+ }
+
+ public boolean configClassRemove(String sClassName, Player pPlayer)
+ {
+ Clazz cClass = getClassbyClassName(sClassName);
+ if (cClass != null)
+ {
+ clazzes.remove(cClass);
+ plugin.msg(pPlayer, "Clazz removed: " + sClassName);
+ plugin.config.save_config();
+ return true;
+ }
+ plugin.msg(pPlayer, "Clazz not found: " + sClassName);
+ return true;
+ }
+
+ public boolean configRankRemove(String sClassName, String sPermName,
+ Player pPlayer)
+ {
+ Clazz cClass = getClassbyClassName(sClassName);
+ if (cClass != null)
+ {
+ Rank rank = getRankByPermName(sPermName);
+ if (rank != null)
+ {
+ ChatColor cColor = rank.getColor();
+ cClass.ranks.remove(rank);
+ plugin.msg(pPlayer, "Rank removed: " + cColor + sPermName);
+ plugin.config.save_config();
+ return true;
+ }
+ plugin.msg(pPlayer, "Rank not found: " + sPermName);
+ return true;
+ }
+ plugin.msg(pPlayer, "Clazz not found: " + sClassName);
+ return true;
+ }
+
+ public boolean configClassAdd(String sClassName, String sPermName,
+ String sDispName, String sColor, ItemStack[] isItems, double dCost,
+ int iExp, Player pPlayer)
+ {
+ Clazz cClass = getClassbyClassName(sClassName);
+ if (cClass == null)
+ {
+ Clazz clazz = new Clazz(sClassName);
+ clazz.add(sPermName, sDispName, (FormatManager.formatColor(sColor)),
+ isItems, dCost, iExp);
+ // add Clazz to ClazzList
+ String key = clazz.clazzName.toUpperCase();
+ clazzes.put(key,clazz);
+ if (pPlayer == null)
+ {
+ ClassRanks.log("Clazz added:" + sClassName, Level.INFO);
+
+ // db.i("Clazz added: " + sClassName);
+ } else
+ {
+ plugin.msg(pPlayer, "Clazz added: " + sClassName);
+ }
+ // plugin.config.save_config();
+ return true;
+ }
+ if (pPlayer == null)
+ plugin.db.i("Clazz already exists: " + sClassName);
+ else
+ plugin.msg(pPlayer, "Clazz already exists for " + pPlayer);
+ return true;
+ }
+
+ public boolean configRankAdd(String sClassName, String sPermName,
+ String sDispName, String sColor, ItemStack[] isItems, double dCost,
+ int iExp, Player pPlayer)
+ {
+ Clazz cClass = getClassbyClassName(sClassName);
+ if (cClass != null)
+ {
+ int nextIndex = cClass.ranks.size()+1;
+ cClass.ranks.put(nextIndex, new Rank(sPermName, sDispName, (FormatManager
+ .formatColor(sColor)), cClass, isItems, dCost, iExp));
+ if (pPlayer == null)
+ {
+ // plugin.db.i("Rank added: " +
+ // (FormatManager.formatColor(sColor)) + sPermName);
+ // plugin.config.save_config();
+ } else
+ {
+ plugin.msg(pPlayer,
+ "Rank added: " + (FormatManager.formatColor(sColor))
+ + sPermName + "/" + pPlayer);
+ plugin.config.save_config();
+ }
+ return true;
+ }
+ if (pPlayer == null)
+ plugin.db.i("Clazz not found: " + sClassName);
+ else
+ plugin.msg(pPlayer, "Clazz not found: " + sClassName);
+ return true;
+ }
+
+ public boolean configClassChange(String sClassName,
+ String sClassNewName, Player pPlayer)
+ {
+ Clazz cClass = getClassbyClassName(sClassName);
+ if (cClass != null)
+ {
+ cClass.clazzName = sClassNewName;
+ plugin.msg(pPlayer, "Clazz changed: " + sClassName + " => "
+ + sClassNewName);
+ plugin.config.save_config();
+ return true;
+ }
+ plugin.msg(pPlayer, "Clazz not found: " + sClassName);
+ return true;
+ }
+
+ public boolean configRankChange(String sClassName, String sPermName,
+ String sDispName, String sColor, Player pPlayer)
+ {
+ Clazz cClass = getClassbyClassName(sClassName);
+ if (cClass != null)
+ {
+ Rank rank = getRankByPermName(sPermName);
+ if (rank != null)
+ {
+ rank.setDispName(sDispName);
+ rank.setColor((FormatManager.formatColor(sColor)));
+ plugin.msg(pPlayer,
+ "Rank updated: " + (FormatManager.formatColor(sColor))
+ + sPermName);
+ plugin.config.save_config();
+ return true;
+ }
+ plugin.msg(pPlayer, "Rank not found: " + sPermName);
+ }
+ plugin.msg(pPlayer, "Clazz not found: " + sClassName);
+ return true;
+ }
+
+ public void saveClassProgress(Player pPlayer)
+ {
+ plugin.db.i("saving Clazz process");
+ String s = plugin.getConfig()
+ .getString("progress." + pPlayer.getName());
+ plugin.db.i("progress of " + pPlayer.getName() + ": " + s);
+ Rank rank = getRankByPermName(plugin.perms.getPermNameByPlayer(pPlayer.getWorld().getName(), pPlayer));
+ if (rank == null)
+ {
+ plugin.db.i("rank is null!");
+ return;
+ }
+
+ int rankID = rank.getSuperClass().getIndexOf(rank);
+ plugin.db.i("rank ID: " + rankID);
+ int classID = this.getIndex(rank.getSuperClass());
+ plugin.db.i("classID: " + classID);
+
+ if (s != null && s.length() == clazzes.size())
+ {
+
+ char[] c = s.toCharArray();
+ c[classID] = String.valueOf(rankID).charAt(0);
+ plugin.db.i("new c[classID]: " + c[classID]);
+
+ plugin.db.i("saving: " + c.toString());
+ plugin.getConfig().set("progress." + pPlayer.getName(),
+ String.valueOf(c.toString()));
+
+ return;
+ }
+
+ plugin.db.i("no entry yet!");
+ String result = "";
+ for (int i = 0; i < clazzes.size(); i++)
+ {
+ if (i == classID)
+ {
+ result += String.valueOf(rankID);
+ } else
+ {
+ result += "0";
+ }
+ }
+ plugin.db.i("setting: " + result);
+ plugin.getConfig().set("progress." + pPlayer.getName(),
+ String.valueOf(result));
+ plugin.saveConfig();
+ }
+
+ public int loadClassProcess(Player pPlayer, Clazz cClass)
+ {
+ try
+ {
+ String s = plugin.getConfig().getString(
+ "progress." + pPlayer.getName());
+ int classID = this.getIndex(cClass);
+
+ int rankID = Integer.parseInt(String.valueOf(s.charAt(classID)));
+ return rankID;
+ } catch (Exception e)
+ {
+ return 0;
+ }
+ }
+
+ public int getRankIndex(Rank rank, Clazz clazz)
+ {
+ // init with 0 to set default to first Rank in Clazz
+ return clazz.getIndexOf(rank);
+// try
+// {
+// ArrayList ranks = oClass.ranks;
+// for (Rank oRank : ranks)
+// {
+// if (rank.getPermName().equals(oRank.getPermName()))
+// {
+// return rankID;
+// } else
+// {
+// rankID++;
+// }
+// }
+// return rankID;
+// } catch (Exception e)
+// {
+// return 0;
+// }
+ }
+
+}
diff --git a/src/net/slipcor/classranks/managers/CommandManager.java b/src/net/slipcor/classranks/managers/CommandManager.java
deleted file mode 100644
index 4b896c4..0000000
--- a/src/net/slipcor/classranks/managers/CommandManager.java
+++ /dev/null
@@ -1,922 +0,0 @@
-package net.slipcor.classranks.managers;
-
-import java.util.ArrayList;
-import java.util.logging.Level;
-
-import net.slipcor.classranks.ClassRanks;
-import net.slipcor.classranks.core.Class;
-import net.slipcor.classranks.core.Rank;
-import net.slipcor.classranks.managers.PlayerManager;
-import net.slipcor.classranks.register.payment.Method.MethodAccount;
-
-import org.bukkit.Bukkit;
-import org.bukkit.ChatColor;
-import org.bukkit.entity.Player;
-import org.bukkit.inventory.ItemStack;
-
-/**
- * command manager class
- *
- * @version v0.4.3
- *
- * @author slipcor
- */
-
-public class CommandManager {
- private final ClassRanks plugin;
- private final FormatManager fm;
- private final PlayerManager pm;
- private final DebugManager db;
-
- public double[] moneyCost = new double[ClassManager.getClasses().size()]; // Costs
- public int[] expCost = new int[ClassManager.getClasses().size()]; // EXP
- // Costs
- public boolean rankpublic; // do we spam changed to the public?
- public boolean defaultrankallworlds; // do ppl rank themselves in all
- // worlds?
- public boolean onlyoneclass; // only maintain one class
- public ItemStack[][] rankItems;
- public String[] signCheck = { null, null, null }; // SignCheck variable
-
- public CommandManager(ClassRanks plugin) {
- this.plugin = plugin;
- this.pm = new PlayerManager(plugin);
- this.fm = new FormatManager();
- this.db = new DebugManager(plugin);
- }
-
- /*
- * This function provides the main ranking process - including error
- * messages when stuff is not right. - check if permissions are there - get
- * old rank - calculate new rank - eventually delete from old rank - add to
- * new rank
- */
- public boolean rank(String[] args, Player comP) {
- db.i("ranking " + comP.getName() + " : "
- + FormatManager.formatStringArray(args));
- int cDown = pm.coolDownCheck(comP);
- if (cDown > 0) {
- plugin.msg(comP,
- "You have to wait " + ChatColor.RED + String.valueOf(cDown)
- + ChatColor.WHITE + " seconds!");
- return true; // cooldown timer still counting => OUT!
- }
- db.i("cooldown check positive");
-
- if ((!plugin.perms.hasPerms(comP, "classranks.rankdown", comP
- .getWorld().getName()))
- && args[0].equalsIgnoreCase("rankdown")) {
- // if we either are no OP or try to rank down, but we may not
- plugin.msg(comP, "You don't have permission to rank down!");
- return true;
- }
-
- db.i("perm check successful");
-
- String World = defaultrankallworlds ? "all" : comP.getWorld().getName(); // store
- // the
- // player's
- // world
- String changePlayer = comP.getName(); // store the player we want to
- // change
- Boolean self = true; // we want to change ourselves ... maybe
-
- if (args.length > 1) { // we have more than one argument. that means:
- changePlayer = PlayerManager.search(args[1]); // we want to change a
- // different player
- self = false; // we do not want to change ourselves
- if (args.length > 2) { // we even have more than two arguments. that
- // means:
- World = args[2]; // we want to specify a world where we change
- }
- }
-
- // does player have a rank?
-
- Rank rank = ClassManager.getRankByPermName(plugin.perms
- .getPermNameByPlayer(World, changePlayer));
-
- if (rank == null) {
- // No Rank
- if (self) {
- plugin.msg(comP, "You don't have a class!");
- return true;
- } else {
- plugin.msg(comP, "Player " + fm.formatPlayer(changePlayer)
- + " does not have a class !");
- return true;
- }
- }
-
- db.i("rank check successful");
-
- String cPermName = rank.getPermName(); // Permissions rank name
- String cDispName = rank.getDispName(); // Display rank name
- ChatColor c_Color = rank.getColor(); // Rank color
- Class cClass = rank.getSuperClass(); // Rank class
- int cRank = cClass.ranks.indexOf(rank); // Rank index
- int cMaxRank = cClass.ranks.size() - 1; // Classes max tree rank
- db.i("rank " + cRank + " of " + cMaxRank);
- // placeholder: cost
- double rank_cost = 0;
- // placeholder: items
- ItemStack[] items = null;
-
- // placeholders for new rank
- int rankOffset = 0;
-
- if (args[0].equalsIgnoreCase("rankup")) {
- // we want to rank up!
- if (cRank >= cMaxRank) {
- // if the player is in the maximum rank
- if (self) {
- plugin.msg(comP, "You are already at highest rank!");
- } else {
- plugin.msg(comP, "Player " + fm.formatPlayer(changePlayer)
- + " already at highest rank!");
- }
- return true;
- }
- if (self) {
- // if we rank ourselves, that might cost money
- // (otherwise, thats not the players problem ;) )
- try {
- rank_cost = moneyCost[cRank + 1];
- } catch (Exception e) {
- plugin.log("cost not set: "+(cRank + 1), Level.WARNING);
- }
-
- Rank rNext = ClassManager.getNextRank(rank, 1);
- if (rNext != null) {
- if (rNext.getCost() != -1337D) {
- rank_cost = rNext.getCost();
- }
- }
-
- if (ClassRanks.economy != null) {
-
- if (ClassRanks.economy.hasAccount(comP.getName())) {
- plugin.log("Account not found: " + comP.getName(),
- Level.SEVERE);
- return true;
- }
- if (!ClassRanks.economy.has(comP.getName(), rank_cost)) {
- // no money, no ranking!
- plugin.msg(comP,
- "You don't have enough money to rank up!");
- return true;
- }
- } else if (plugin.method != null) {
- MethodAccount ma = plugin.method.getAccount(comP.getName());
- if (ma == null) {
- plugin.log("Account not found: " + comP.getName(),
- Level.SEVERE);
- return true;
- }
- if (!ma.hasEnough(rank_cost)) {
- // no money, no ranking!
- plugin.msg(comP,
- "You don't have enough money to rank up!");
- return true;
- }
- }
-
- items = rankItems != null ? rankItems[cRank + 1] : null;
-
- if (rNext.getItemstacks() != null) {
- items = rNext.getItemstacks();
- }
- }
- rankOffset = 1;
- } else if (args[0].equalsIgnoreCase("rankdown")) {
- if (cRank < 1) {
- // We are at lowest rank
- if (self) {
- plugin.msg(comP, "You are already at lowest rank!");
- } else {
- plugin.msg(comP, "Player " + fm.formatPlayer(changePlayer)
- + " already at lowest rank!");
- }
- return true;
- }
- rankOffset = -1;
- }
-
- if (rankOffset > 0) {
-
- if (expCost != null && expCost.length > 0) {
- int exp_cost = -1;
-
- try {
- exp_cost = expCost[cRank + 1];
- } catch (Exception e) {
- plugin.log("Exp cost not set: "+cRank + 1, Level.WARNING);
- }
- Rank rNext = ClassManager.getNextRank(rank, 1);
- if (rNext != null && rNext.getExp() != -1) {
- exp_cost = rNext.getExp();
- }
-
- if (exp_cost > 0) {
- if (comP.getTotalExperience() < exp_cost) {
- plugin.msg(comP,
- "You don't have enough experience ("+comP.getTotalExperience()+")! You need "
- + exp_cost);
- return true;
- }
- int newExp = comP.getTotalExperience() - exp_cost;
- comP.setExp(0);
- comP.setLevel(0);
- comP.giveExp(newExp);
-
- plugin.msg(comP, "You paid " + exp_cost
- + " experience points!");
- }
- }
-
- if ((items != null)
- && (!FormatManager.formatItemStacks(items).equals(""))) {
- if (!pm.ifHasTakeItems(comP, items)) {
- plugin.msg(comP, "You don't have the required items!");
- plugin.msg(comP,
- "(" + FormatManager.formatItemStacks(items) + ")");
- return true;
- }
- }
- }
-
- if (onlyoneclass || rankOffset < 0) {
- // up and only OR down
- db.i("removing old class...");
- plugin.perms.rankRemove(World, changePlayer, cPermName);
- }
-
- rank = ClassManager.getNextRank(rank, rankOffset);
-
- cPermName = rank.getPermName();
- cDispName = rank.getDispName();
- c_Color = rank.getColor();
-
- db.i("adding new rank...");
- plugin.perms.rankAdd(World, changePlayer, cPermName);
-
- if ((rank_cost > 0)) {
- // take the money, inform the player
-
- if (ClassRanks.economy != null) {
- ClassRanks.economy.withdrawPlayer(comP.getName(), rank_cost);
- comP.sendMessage(ChatColor.DARK_GREEN + "[" + ChatColor.WHITE
- + "Money" + ChatColor.DARK_GREEN + "] " + ChatColor.RED
- + "Your account had " + ChatColor.WHITE
- + ClassRanks.economy.format(rank_cost) + ChatColor.RED
- + " debited.");
- } else if (plugin.method != null) {
- MethodAccount ma = plugin.method.getAccount(comP.getName());
- ma.subtract(rank_cost);
- comP.sendMessage(ChatColor.DARK_GREEN + "[" + ChatColor.WHITE
- + "Money" + ChatColor.DARK_GREEN + "] " + ChatColor.RED
- + "Your account had " + ChatColor.WHITE
- + plugin.method.format(rank_cost) + ChatColor.RED
- + " debited.");
- }
- }
-
- if (self && !rankpublic) {
- // we rank ourselves and do NOT want that to be public
- plugin.msg(comP,
- "You are now a " + c_Color + cDispName + ChatColor.WHITE
- + ChatColor.WHITE + " in " + fm.formatWorld(World)
- + "!");
- } else {
- plugin.getServer().broadcastMessage(
- "[" + ChatColor.AQUA + plugin.getConfig().getString("prefix") + ChatColor.WHITE
- + "] Player " + fm.formatPlayer(changePlayer)
- + " now is a " + c_Color + cDispName
- + ChatColor.WHITE + " in " + fm.formatWorld(World)
- + "!");
- }
- return true;
- }
-
- /*
- * The main switch for the command usage. Check for known commands,
- * permissions, arguments, and commit whatever is wanted.
- */
- public boolean parseCommand(Player pPlayer, String[] args) {
-
- db.i("parsing player " + pPlayer + ", command: "
- + FormatManager.formatStringArray(args));
- if (args.length > 1) {
- if (args[0].equalsIgnoreCase("get")) {
- String world = pPlayer.getWorld().getName();
- if (args.length > 2) {
- world = args[2];
- }
- args[1] = PlayerManager.search(args[1]);
-
- Rank rank = ClassManager.getRankByPermName(plugin.perms
- .getPermNameByPlayer(world, args[1]));
-
- if (rank == null) {
- plugin.msg(pPlayer, "Player " + fm.formatPlayer(args[1])
- + " has no class in " + fm.formatWorld(world) + "!");
- } else {
-
- String cDispName = rank.getDispName(); // Display rank name
- ChatColor c_Color = rank.getColor(); // Rank color
-
- plugin.msg(pPlayer, "Player " + fm.formatPlayer(args[1])
- + " is " + c_Color + cDispName + ChatColor.WHITE
- + " in " + fm.formatWorld(world) + "!");
- }
- return true;
- }
-
- // more than /class or /class rankup
- if (!plugin.perms.hasPerms(pPlayer, "classranks.admin.rank",
- pPlayer.getWorld().getName())) {
- plugin.msg(pPlayer,
- "You don't have permission to change other user's ranks!");
- return true;
- }
-
- if ((!args[0].equalsIgnoreCase("add"))
- && (!args[0].equalsIgnoreCase("remove"))) {
- if ((args[0].equalsIgnoreCase("rankup"))
- || (args[0].equalsIgnoreCase("rankdown"))) {
- // rank up or down
- if (args.length > 1) {
- return rank(args, pPlayer);
- } else {
- plugin.msg(
- pPlayer,
- "Not enough arguments ("
- + String.valueOf(args.length) + ")!");
- return false;
- }
- }
- plugin.msg(pPlayer, "Argument " + args[0] + " unrecognized!");
- return false;
- }
- // add / remove
- boolean self = true;
- String world = defaultrankallworlds ? "all" : pPlayer.getWorld()
- .getName();
- if (args[0].equalsIgnoreCase("remove")) {
- if (args.length > 2) {
- // => /class remove *name* world
- world = args[2];
- self = false;
- } else if (args.length > 1) {
- self = false;
- }
- } else if (args[0].equalsIgnoreCase("add")) {
- if (args.length > 3) {
- // => /class add *name* *classname* world
- world = args[3];
- } else if (args.length == 3) {
- // => /class add *name* *classname*
- self = false;
- } else if (args.length == 2) {
- // => /class add *classname*
-
- String[] tArgs = { args[0], pPlayer.getName(), args[1] };
-
- args = tArgs; // override : pretend to have said: //class
- // add me class
- } else if (args.length < 2) {
- // not enough arguments ;)
- plugin.msg(
- pPlayer,
- "Not enough arguments ("
- + String.valueOf(args.length) + ")!");
- return false;
- }
- }
- db.i("precheck successful");
-
- if (!self) {
- if (!plugin.perms.hasPerms(pPlayer,
- "classranks.admin.addremove", pPlayer.getWorld()
- .getName())) {
- // only if we are NOT op or may NOT add/remove classes
- plugin.msg(pPlayer,
- "You don't have permission to add/remove other player's classes!");
- return true;
- }
- }
- db.i("perm check successful");
-
- // get the class of the player we're talking about
- args[1] = PlayerManager.search(args[1]);
- String sPermName = plugin.perms.getPermNameByPlayer(world, args[1]);
- if (!sPermName.equals("")) {
- if (plugin.trackRanks) {
- ClassManager.saveClassProgress(Bukkit.getPlayer(args[1]));
- }
- int i = 0; // combo breaker
- while (!sPermName.equals("")) {
- db.i("removing rank " + sPermName);
-
- Rank tempRank = ClassManager.getRankByPermName(sPermName);
-
- String cDispName = tempRank.getDispName(); // Display rank
- // name
- ChatColor c_Color = tempRank.getColor(); // Rank color
-
- if (args[0].equalsIgnoreCase("add")) {
- // only one class per player :p
- plugin.msg(pPlayer,
- "Player " + fm.formatPlayer(args[1])
- + " already already has the rank "
- + c_Color + cDispName + "!");
- } else if (args[0].equalsIgnoreCase("remove")) {
- if (plugin.trackRanks) {
- ClassManager.saveClassProgress(Bukkit
- .getPlayer(args[1]));
- }
- plugin.perms.rankRemove(world, args[1],
- tempRank.getPermName()); // do it!
-
- if ((!pPlayer.getName().equalsIgnoreCase(args[1]))) {
- plugin.msg(pPlayer,
- "Player " + fm.formatPlayer(args[1])
- + " removed from rank " + c_Color
- + cDispName + ChatColor.WHITE
- + " in " + fm.formatWorld(world)
- + "!");
-
- Player chP = plugin.getServer().getPlayer(args[1]);
- try {
- if (chP.isOnline()) {
- chP.sendMessage("[" + ChatColor.AQUA
- + plugin.getConfig().getString("prefix") + ChatColor.WHITE
- + "] You were removed from rank "
- + c_Color + cDispName
- + ChatColor.WHITE + " in "
- + fm.formatWorld(world) + "!");
- }
- } catch (Exception e) {
- // do nothing, the player is not online
- }
- } else {
- // self remove successful!
- if (i == 0)
- plugin.msg(
- pPlayer,
- "You were removed from rank " + c_Color
- + cDispName + ChatColor.WHITE
- + " in "
- + fm.formatWorld(world) + "!");
- }
- }
- if (++i > 10) {
- plugin.log("Infinite loop! More than 10 ranks!?",
- Level.SEVERE);
- break;
- }
- sPermName = plugin.perms
- .getPermNameByPlayer(world, args[1]);
- }
- return true;
- }
- // player has no class
- if (!args[0].equalsIgnoreCase("add")) {
- // no class and trying to remove
- if (pPlayer.getName().equalsIgnoreCase(args[1])) {
- plugin.msg(pPlayer, "You don't have a class!");
- return true;
- } else {
- plugin.msg(pPlayer, "Player " + fm.formatPlayer(args[1])
- + " does not have a class!");
- return true;
- }
- }
- // ADD
- Rank tempRank = ClassManager.getRankByPermName(args[2]);
-
- if (tempRank == null) {
- plugin.msg(pPlayer,
- "The class you have entered does not exist!");
- return true;
- }
-
- String cPermName = tempRank.getPermName(); // Display rank name
- String cDispName = tempRank.getDispName(); // Display rank name
- ChatColor c_Color = tempRank.getColor(); // Rank color
-
- if (plugin.trackRanks) {
- int rID = ClassManager.loadClassProcess(
- Bukkit.getPlayer(args[1]), tempRank.getSuperClass());
-
- tempRank = tempRank.getSuperClass().ranks.get(rID);
-
- cPermName = tempRank.getPermName(); // Display rank name
- cDispName = tempRank.getDispName(); // Display rank name
- c_Color = tempRank.getColor(); // Rank color
-
- String sRank = tempRank.getPermName();
- plugin.perms.rankAdd(world, args[1], sRank);
- } else {
- plugin.perms.classAdd(world, args[1], cPermName);
- }
-
- if ((rankpublic) || (!pPlayer.getName().equalsIgnoreCase(args[1]))) {
- plugin.getServer().broadcastMessage(
- "[" + ChatColor.AQUA + plugin.getConfig().getString("prefix") + ChatColor.WHITE
- + "] " + fm.formatPlayer(args[1])
- + " now is a " + c_Color + cDispName);
- return true;
- } else {
- plugin.msg(pPlayer, "You now are a " + c_Color + cDispName);
- return true;
- }
- } else if (args.length > 0) {
- // only ONE argument!
-
- if (args[0].equalsIgnoreCase("reload")) {
- if (pPlayer.isOp()) {
- plugin.load_config();
- plugin.msg(pPlayer, "Config reloaded!");
- } else {
- plugin.msg(pPlayer, "You don't have permission to reload!");
- }
- return true;
- }
-
- if (args[0].equalsIgnoreCase("rankup")) {
- if (!plugin.perms.hasPerms(pPlayer, "classranks.self.rank",
- pPlayer.getWorld().getName())) {
- plugin.msg(pPlayer,
- "You don't have permission to rank yourself up!");
- return true;
- }
- return rank(args, pPlayer);
- } else if (args[0].equalsIgnoreCase("rankdown")) {
- if (!plugin.perms.hasPerms(pPlayer, "classranks.self.rank",
- pPlayer.getWorld().getName())) {
- plugin.msg(pPlayer,
- "You don't have permission to rank yourself down!");
- return true;
- }
- return rank(args, pPlayer);
- } else if (args[0].equalsIgnoreCase("remove")) {
- if (!plugin.perms.hasPerms(pPlayer,
- "classranks.self.addremove", pPlayer.getWorld()
- .getName())) {
- plugin.msg(pPlayer,
- "You don't have permission to add/remove your rank!");
- return true;
- }
- Rank rank = ClassManager.getRankByPermName(plugin.perms
- .getPermNameByPlayer(pPlayer.getWorld().getName(),
- pPlayer.getName()));
-
- if (rank == null) {
- plugin.msg(pPlayer, "You don't have a class!");
- return true;
- }
-
- String cDispName = rank.getDispName(); // Display rank name
- ChatColor c_Color = rank.getColor(); // Rank color
- if (plugin.trackRanks) {
- ClassManager.saveClassProgress(pPlayer);
- }
- plugin.perms.rankRemove(defaultrankallworlds ? "all" : pPlayer
- .getWorld().getName(), pPlayer.getName(), rank
- .getPermName());
-
- plugin.msg(
- pPlayer,
- "You were removed from rank "
- + c_Color
- + cDispName
- + ChatColor.WHITE
- + " in "
- + fm.formatWorld(defaultrankallworlds ? "all"
- : pPlayer.getWorld().getName()) + "!");
- return true;
- } else if (args[0].equalsIgnoreCase("add")) {
- plugin.msg(pPlayer, "Not enough arguments!");
- return true;
-
- } else if (args[0].equalsIgnoreCase("list")) {
- ArrayList classes = ClassManager.getClasses();
- plugin.msg(pPlayer, "Class List");
- plugin.msg(pPlayer, "--------------------");
-
- for (Class c : classes) {
- if (c.name.startsWith("%") && !pPlayer.isOp()) {
- continue;
- }
- plugin.msg(pPlayer, "Class §a" + c.name);
- for (Rank r : c.ranks) {
- plugin.msg(pPlayer, "=> " + r.getColor() + r.getDispName());
- }
- }
- return true;
- }
-
- // /class [classname]
- if (!plugin.perms.hasPerms(pPlayer, "classranks.self.rank", pPlayer
- .getWorld().getName())) {
- plugin.msg(pPlayer,
- "You don't have permission to choose your class!");
- return true;
- }
-
- String sRankInfo = plugin.perms.getPermNameByPlayer(pPlayer
- .getWorld().getName(), pPlayer.getName());
-
- if (!sRankInfo.equals("")) {
- plugin.msg(pPlayer, "You already have the rank " + sRankInfo
- + "!");
- return true;
- }
-
- String s = "";
-
- if (plugin.trackRanks) {
- s = ClassManager.getFirstPermNameByClassName(args[0],
- pPlayer.getName());
- } else {
- s = ClassManager.getFirstPermNameByClassName(args[0]);
- }
-
- if (s == null || s.equals("")) {
- plugin.msg(pPlayer,
- "The class you have entered does not exist!");
- return true;
- }
- Rank rank = ClassManager.getRankByPermName(s);
-
- if (rank == null) {
- plugin.msg(pPlayer, "Internal Error #1!");
- return true;
- }
- db.i("rank check successful");
-
- int rID = 0;
- if (plugin.trackRanks) {
- rID = ClassManager.loadClassProcess(pPlayer,
- rank.getSuperClass());
- }
- double rank_cost = 0D;
-
- try {
- rank_cost = moneyCost[rID];
- } catch (Exception e) {
- plugin.log("cost not set: "+rID, Level.WARNING);
- }
-
- if (rank.getCost() != -1337D) {
- rank_cost = rank.getCost();
- }
- // Check if the player has got the money
- if (ClassRanks.economy != null) {
- if (plugin.getConfig().getBoolean("checkprices")
- && ClassRanks.economy.has(pPlayer.getName(), rank_cost)) {
-
- plugin.msg(pPlayer,
- "You don't have enough money to choose your class! ("
- + ClassRanks.economy.format(rank_cost)
- + ")");
- return true;
- }
- } else if (plugin.method != null) {
- MethodAccount ma = plugin.method.getAccount(pPlayer.getName());
- if (plugin.getConfig().getBoolean("checkprices")
- && !ma.hasEnough(rank_cost)) {
-
- plugin.msg(pPlayer,
- "You don't have enough money to choose your class! ("
- + plugin.method.format(rank_cost)
- + ")");
- return true;
- }
- }
- db.i("money check successful");
- if (expCost != null && expCost.length > 0) {
- int exp_cost = -1;
-
- try {
- exp_cost = expCost[rID];
- } catch (Exception e) {
- plugin.log("Exp cost not set: "+rID, Level.WARNING);
- }
-
- if (rank.getExp() != -1) {
- exp_cost = rank.getExp();
- }
-
- if (exp_cost > 0) {
- if (pPlayer.getTotalExperience() < exp_cost) {
- plugin.msg(pPlayer,
- "You don't have enough experience! You need "
- + exp_cost);
- return true;
- }
- pPlayer.setTotalExperience(pPlayer.getTotalExperience()
- - exp_cost);
- plugin.msg(pPlayer, "You paid " + exp_cost
- + " experience points!");
- }
- }
- db.i("exp check successful");
-
- ItemStack[] items = null;
-
- if (rankItems != null && (rankItems[rID] != null)
- && (!FormatManager.formatItemStacks(rankItems[rID]).equals(
- ""))) {
- items = rankItems[rID];
- }
-
- if (rank.getItemstacks() != null) {
- items = rank.getItemstacks();
- }
-
- if (items != null) {
-
- if (!pm.ifHasTakeItems(pPlayer, items)) {
- plugin.msg(pPlayer, "You don't have the required items!");
- plugin.msg(
- pPlayer,
- "("
- + FormatManager
- .formatItemStacks(items)
- + ")");
- return true;
- }
- }
- db.i("item check successful");
-
- String cPermName = rank.getPermName(); // Display rank name
- String cDispName = rank.getDispName(); // Display rank name
- ChatColor c_Color = rank.getColor(); // Rank color
-
- // success!
-
- if (plugin.getConfig().getBoolean("clearranks")) {
- plugin.perms.removeGroups(pPlayer);
- }
-
- plugin.perms.rankAdd(defaultrankallworlds ? "all" : pPlayer
- .getWorld().getName(), pPlayer.getName(), cPermName);
- if (rankpublic) {
- plugin.getServer().broadcastMessage(
- "Player " + fm.formatPlayer(pPlayer.getName())
- + " has chosen a class, now has the rank "
- + c_Color + cDispName);
- } else {
- plugin.msg(pPlayer,
- "You have chosen your class! You now have the rank "
- + c_Color + cDispName);
- }
-
- if (plugin.getConfig().getBoolean("checkprices")
- && (rank_cost > 0)) {
- // if it costs anything at all
-
- if (ClassRanks.economy != null) {
- ClassRanks.economy.withdrawPlayer(pPlayer.getName(), rank_cost);
- pPlayer.sendMessage(ChatColor.DARK_GREEN + "["
- + ChatColor.WHITE + "Money" + ChatColor.DARK_GREEN
- + "] " + ChatColor.RED + "Your account had "
- + ChatColor.WHITE
- + ClassRanks.economy.format(rank_cost) + ChatColor.RED
- + " debited.");
- } else if ((plugin.method != null)) {
- MethodAccount ma = plugin.method.getAccount(pPlayer.getName());
- ma.subtract(rank_cost);
- pPlayer.sendMessage(ChatColor.DARK_GREEN + "["
- + ChatColor.WHITE + "Money" + ChatColor.DARK_GREEN
- + "] " + ChatColor.RED + "Your account had "
- + ChatColor.WHITE
- + plugin.method.format(rank_cost) + ChatColor.RED
- + " debited.");
- }
- }
- return true;
- }
- plugin.msg(pPlayer,
- "Not enough arguments (" + String.valueOf(args.length) + ")!");
- return false;
- }
-
- public boolean parseAdminCommand(Player pPlayer, String[] args) {
- db.i("parsing admin " + pPlayer.getName() + ", command: "
- + FormatManager.formatStringArray(args));
-
- if (!plugin.perms.hasPerms(pPlayer, "classranks.admin.admin", pPlayer
- .getWorld().getName())) {
- plugin.msg(pPlayer,
- "You don't have permission to administrate ranks!");
- return true;
- }
-
- db.i("perm check successful");
-
- if (args.length < 3) {
- plugin.msg(pPlayer,
- "Not enough arguments (" + String.valueOf(args.length)
- + ")!");
- return false;
- }
- db.i("enough arguments");
-
- if (args[0].equalsIgnoreCase("remove")) {
- /*
- * /classadmin remove class *classname* /classadmin remove rank
- * *classname* *rankname*
- */
- if (args[1].equalsIgnoreCase("class")) {
- if (args.length != 3) {
- plugin.msg(
- pPlayer,
- "Wrong number of arguments ("
- + String.valueOf(args.length) + ")!");
- return false;
- }
- return ClassManager.configClassRemove(args[2], pPlayer);
- } else if (args[1].equalsIgnoreCase("rank")) {
- if (args.length != 4) {
- plugin.msg(
- pPlayer,
- "Wrong number of arguments ("
- + String.valueOf(args.length) + ")!");
- return false;
- }
- return ClassManager.configRankRemove(args[2], args[3], pPlayer);
- }
- // second argument unknown
- return false;
- } else if (args[0].equalsIgnoreCase("add")) {
-
- /*
- * /classadmin add class *classname* *rankname* *displayname*
- * *color* /classadmin add rank *classname* *rankname* *displayname*
- * *color*
- */
-
- if (args.length != 9) {
- plugin.msg(
- pPlayer,
- "Wrong number of arguments ("
- + String.valueOf(args.length) + ")!");
- return false;
- }
- if (args[1].equalsIgnoreCase("class")) {// , ItemStack[] isItems,
- // double dCost, int iExp
- return ClassManager.configClassAdd(args[2], args[3], args[4],
- args[5],
- FormatManager.getItemStacksFromCommaString(args[6]),
- Double.parseDouble(args[7]), Integer.parseInt(args[8]),
- pPlayer);
- } else if (args[1].equalsIgnoreCase("rank")) {
- return ClassManager.configRankAdd(args[2], args[3], args[4],
- args[5],
- FormatManager.getItemStacksFromCommaString(args[6]),
- Double.parseDouble(args[7]), Integer.parseInt(args[8]),
- pPlayer);
- }
- // second argument unknown
- return false;
- } else if (args[0].equalsIgnoreCase("change")) {
-
- /*
- * /classadmin change rank *classname* *rankname* *displayname*
- * *color* /classadmin change class *classname* *newclassname*
- */
-
- if (args[1].equalsIgnoreCase("class")) {
- if (args.length != 4) {
- plugin.msg(
- pPlayer,
- "Wrong number of arguments ("
- + String.valueOf(args.length) + ")!");
- return false;
- }
- return ClassManager
- .configClassChange(args[2], args[3], pPlayer);
- } else if (args[1].equalsIgnoreCase("rank")) {
- if (args.length != 6) {
- plugin.msg(
- pPlayer,
- "Wrong number of arguments ("
- + String.valueOf(args.length) + ")!");
- return false;
- }
- return ClassManager.configRankChange(args[2], args[3], args[4],
- args[5], pPlayer);
- }
- // second argument unknown
- return false;
- }
- return false;
- }
-
- public FormatManager getFormatManager() {
- return fm;
- }
-}
diff --git a/src/net/slipcor/classranks/managers/ConfigManager.java b/src/net/slipcor/classranks/managers/ConfigManager.java
new file mode 100644
index 0000000..7ae03b2
--- /dev/null
+++ b/src/net/slipcor/classranks/managers/ConfigManager.java
@@ -0,0 +1,648 @@
+package net.slipcor.classranks.managers;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.logging.Level;
+
+import org.bukkit.Material;
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+//import org.bukkit.plugin.Plugin;
+import net.slipcor.classranks.ClassRanks;
+import net.slipcor.classranks.core.Clazz;
+import net.slipcor.classranks.core.PlayerClazzList;
+import net.slipcor.classranks.core.PlayerClazzRank;
+import net.slipcor.classranks.core.Rank;
+
+/*
+ * this Class read the config and make it persistaned
+ * each config node will be stored here.
+ * the config data stored in parameters, so not always read from file
+ * the ClassRank tree are stored in the ClazzList
+ *
+ * @version v0.4.6
+ *
+ * @author krglok
+ *
+ */
+public class ConfigManager {
+ public ClassRanks plugin;
+
+ public static String debugVersion = "0400";
+
+ private Map classes;
+ public Map getClasses() {
+ return classes;
+ }
+// private void setClasses(Map classes) {
+// this.classRanks = classes;
+// }
+ private Boolean autoUpdate = new Boolean(false);
+
+ public Boolean isAutoUpdate() {
+ return autoUpdate;
+ }
+
+ private Boolean updateCheck = new Boolean(false);
+
+ public Boolean isUpdateCheck() {
+ return updateCheck;
+ }
+
+ private boolean useUUID = new Boolean(false);
+ public Boolean isUUD()
+ {
+ return useUUID;
+ }
+
+ public void setUUID(Boolean value)
+ {
+ useUUID = value;
+ }
+
+ private Boolean clearranks = new Boolean(false);
+ public Boolean isClearranks()
+ {
+ return clearranks;
+ }
+
+ public void setClearranks(Boolean clearranks)
+ {
+ this.clearranks = clearranks;
+ }
+
+ private HashMap playersClazzList;
+
+ public HashMap getPlayers() {
+ return playersClazzList;
+ }
+
+// private Map playerClassList; // should store the playerClasses
+
+// private Map playerClassRank; // should store the playerRanks
+
+ private Double[] moneyCost;
+
+ public Double[] getMoneyCost() {
+ return moneyCost;
+ }
+
+ public Double getMoneyCost(int index)
+ {
+ if (index <= moneyCost.length)
+ {
+ return moneyCost[index];
+ } else
+ {
+ return moneyCost[moneyCost.length-1];
+ }
+ }
+
+ public void setMoneyCost(Double[] moneyCost) {
+ this.moneyCost = moneyCost;
+ }
+ private int[] expCost; //= new int[ClazzList.getClasses().size()]; // EXP
+ public int[] getExpCost() {
+ return expCost;
+ }
+ public int getExpCost(int index)
+ {
+ if (index < expCost.length)
+ {
+ return expCost[index];
+ } else
+ {
+ return expCost[expCost.length-1];
+ }
+ }
+
+
+ public ConfigManager(ClassRanks plugin) {
+ super();
+ this.plugin = plugin;
+ moneyCost = new Double[1];
+ expCost = new int[1];
+ signs = new String[3];
+ playersClazzList = new HashMap();
+ }
+
+ private Boolean debug = new Boolean(false);
+ public Boolean isDebug() {
+ return debug;
+ }
+ public void setDebug(Boolean debug) {
+ this.debug = debug;
+ }
+
+ private Boolean checkprices = new Boolean(false);
+ public Boolean isCheckprices() {
+ return checkprices;
+ }
+ public void setCheckprices(Boolean checkprices) {
+ this.checkprices = checkprices;
+ }
+
+ private Map prices;
+ public Map getPrices() {
+ return prices;
+ }
+ public void setPrices(Map prices) {
+ this.prices = prices;
+ }
+
+ private Boolean checkexp = new Boolean(false);
+ public Boolean isCheckexp() {
+ return checkexp;
+ }
+ public void setCheckexp(Boolean checkexp) {
+ this.checkexp = checkexp;
+ }
+
+ private Map expprices;
+ public Map getExpprices() {
+ return expprices;
+ }
+ public void setExpprices(Map expprices) {
+ this.expprices = expprices;
+ }
+
+ private Boolean trackRanks = new Boolean(false);
+ public Boolean isTrackRanks() {
+ return trackRanks;
+ }
+ public void setTrackRanks(Boolean trackRanks) {
+ this.trackRanks = trackRanks;
+ }
+
+ private Boolean rankPublic;
+ public Boolean isRankpublic() {
+ return rankPublic;
+ }
+ public void setRankpublic(Boolean rankpublic) {
+ this.rankPublic = rankpublic;
+ }
+
+ private Boolean signcheck = new Boolean(false);
+ public Boolean isSigncheck() {
+ return signcheck;
+ }
+ public void setSigncheck(Boolean signcheck) {
+ this.signcheck = signcheck;
+ }
+
+ private String[] signs; // = new String[];
+ public String[] getSigns() {
+ return signs;
+ }
+ public void setSigns(String[] signs) {
+ this.signs = signs;
+ }
+
+ private int coolDown;
+ public int getCoolDown() {
+ return coolDown;
+ }
+ public void setCoolDown(int coolDown) {
+ this.coolDown = coolDown;
+ }
+
+ private ItemStack[][] itemStacks;
+ public ItemStack[][] getItemStacks() {
+ return itemStacks;
+ }
+ public void setItemStacks(ItemStack[][] itemStacks) {
+ this.itemStacks = itemStacks;
+ }
+
+ private Boolean checkitems = new Boolean(false);
+ public Boolean isCheckitems() {
+ return checkitems;
+ }
+ public void setCheckitems(Boolean checkitems) {
+ this.checkitems = checkitems;
+ }
+
+ private Map items;
+ public Map getItems() {
+ return items;
+ }
+ public void setItems(Map items) {
+ this.items = items;
+ }
+
+ private ItemStack[][] rankItems;
+ public ItemStack[][] getRankItems()
+ {
+ return rankItems;
+ }
+ public void setRankItems(ItemStack[][] rankItems) {
+ this.rankItems = rankItems;
+ }
+
+ private boolean defaultRankAllWorlds; // do rank themselves in all worlds?
+ public Boolean isDefaultrankallworlds() {
+ return defaultRankAllWorlds;
+ }
+ public void setDefaultrankallworlds(boolean defaultrankallworlds) {
+ this.defaultRankAllWorlds = defaultrankallworlds;
+ }
+
+ private boolean onlyOneClass = new Boolean(false);
+ public Boolean isOnlyoneclass() {
+ return onlyOneClass;
+ }
+ public void setOnlyoneclass(boolean onlyoneclass) {
+ this.onlyOneClass = onlyoneclass;
+ }
+
+ /**
+ * Load Config file , stores data in parmeters
+ */
+ public void load_config() {
+
+ if (plugin.getConfig() == null
+ || !plugin.getConfig().getString("cversion").equals(debugVersion))
+ {
+ ClassRanks.log("creating default config.yml", Level.INFO);
+ plugin.getConfig().set("cversion", debugVersion);
+ plugin.getConfig().options().copyDefaults(true);
+ plugin.saveConfig();
+ }
+// DebugManager.active = plugin.getConfig().getBoolean("debug", false);
+ debug = plugin.getConfig().getBoolean("debug", false);
+ plugin.db.active = debug;
+ // AutoUpdate Config
+ autoUpdate = plugin.getConfig().getBoolean("autoupdate", false);
+ // UpdateCheck Config
+ updateCheck = plugin.getConfig().getBoolean("updatecheck", false);
+
+ // check for section is available
+ checkprices = plugin.getConfig().getBoolean("checkprices", false);
+
+ // useUUID
+ useUUID = plugin.getConfig().getBoolean("useUUID", false);
+
+ boolean isSection = false;
+ if (plugin.getConfig().getConfigurationSection("prices") != null)
+ {
+ isSection = true;
+ }
+
+// if ( isCheckprices() && isSection)
+ if (isSection)
+ {
+ plugin.db.i("Config prices reading...");
+ // set prices
+ prices = (Map) plugin.getConfig().getConfigurationSection("prices").getValues(true);
+
+ if (prices.size() > 0)
+ {
+ moneyCost = new Double[prices.size()];
+ } else
+ {
+ moneyCost = new Double[1];
+ }
+
+ int i = 0;
+ for (String Key : prices.keySet()) {
+ String sVal = (String) prices.get(Key);
+ try
+ {
+ moneyCost[i] = Double.parseDouble(sVal);
+ plugin.db.i("#" + i + " => " + String.valueOf(Double.parseDouble(sVal)));
+ } catch (Exception e)
+ {
+ moneyCost[i] = 0.0;
+ ClassRanks.log("Unrecognized cost key '" + String.valueOf(Key) + "': "
+ + sVal, Level.INFO);
+ }
+ i++;
+ }
+ }
+
+ // check for section is available
+
+ checkexp = plugin.getConfig().getBoolean("checkexp", false);
+ isSection = (plugin.getConfig().getConfigurationSection("exp") != null);
+// if ((isCheckexp()) && (isSection))
+
+ if (isSection)
+ {
+ // set exp prices
+ plugin.db.i("CONFG exp costs reading...");
+
+ expprices = (Map) plugin.getConfig().getConfigurationSection("exp").getValues(true);
+// cmdMgr.expCost = new int[expprices.size()];
+
+ int i = 0;
+ // array erweitern, wenn zu klein
+ if (expCost.length < expprices.size() )
+ {
+ expCost = new int [expprices.size()];
+ }
+ // config in array uebertragen
+ for (String Key : expprices.keySet())
+ {
+ String sVal = (String) expprices.get(Key);
+ ClassRanks.log("ExpPrice : "+sVal, Level.INFO);
+ try
+ {
+ expCost[i] = Integer.parseInt(sVal);
+ plugin.db.i("#" + i + " => "
+ + String.valueOf(Integer.parseInt(sVal)));
+ } catch (Exception e) {
+
+ expCost = new int[i+1];
+ expCost[i] = 0;
+ ClassRanks.log("Unrecognized exp cost key '" + String.valueOf(Key)
+ + "': " + sVal, Level.INFO);
+ }
+ i++;
+ }
+ }
+
+ // set subcolors
+ FormatManager.setColors(plugin.getConfig().getString("playercolor"),plugin.getConfig().getString("worldcolor"));
+
+ // set other variables
+ rankPublic = plugin.getConfig().getBoolean("rankpublic", false);
+
+ defaultRankAllWorlds = plugin.getConfig().getBoolean("defaultrankallworlds", false);
+
+ onlyOneClass = plugin.getConfig().getBoolean("onlyoneclass", true);
+
+ trackRanks = plugin.getConfig().getBoolean("trackRanks", false);
+
+ // Sign
+ signcheck = plugin.getConfig().getBoolean("signcheck", false);
+
+ plugin.db.i("sign check Read!");
+ signs[0] = plugin.getConfig().getString("signchoose",
+ "[choose]");
+ signs[1] = plugin.getConfig().getString("signrankup",
+ "[rankup]");
+ signs[2] = plugin.getConfig().getString("signrankdown",
+ "[rankdown]");
+
+ setClearranks(plugin.getConfig().getBoolean("clearranks", false));
+
+
+ ///PlayerManager.coolDown = plugin.getConfig().getInt("cooldown", 0);
+ coolDown = plugin.getConfig().getInt("cooldown", 0);
+
+ itemStacks = null;
+ checkitems = plugin.getConfig().getBoolean("checkitems");
+
+ // check section is available
+ plugin.db.i("read items section");
+ isSection = plugin.getConfig().getConfigurationSection("items") != null;
+ // item read and check
+ if (isSection)
+ {
+ plugin.db.i("items exist, parsing...");
+
+ items = (Map) plugin.getConfig()
+ .getConfigurationSection("items").getValues(false);
+ // items error check
+ if (items == null)
+ {
+ plugin.db.i("items invalid, setting to null");
+ itemStacks = new ItemStack[ClazzList.getClasses().size()][1];
+ } else
+ {
+ // for each items => ItemStack[][1,2,3]
+ int iI = 0;
+ itemStacks = new ItemStack[items.size()][];
+ for (String isKey : items.keySet())
+ {
+ plugin.db.i("Item Key : " + isKey.toString());
+ List values = plugin.getConfig().getList("items." + isKey);
+ itemStacks[iI] = new ItemStack[values.size()];
+ plugin.db.i("creating itemstack:");
+ for (int iJ = 0; iJ < values.size(); iJ++)
+ {
+ String[] vValue = (String.valueOf(values.get(iJ)))
+ .split(":");
+
+ int vAmount = vValue.length > 1 ? Integer.parseInt(vValue[1]) : 1;
+ try
+ {
+ itemStacks[iI][iJ] = new ItemStack(
+ Material.valueOf(vValue[0]), vAmount);
+
+ } catch (Exception e)
+ {
+
+ ClassRanks.log("Unrecognized reagent: " + vValue[0],
+ Level.WARNING);
+ continue;
+ }
+ }
+ plugin.db.i(iI + " - "
+ + FormatManager.formatItemStacks(itemStacks[iI]));
+ iI++;
+ }
+ }
+ }
+ setRankItems(itemStacks);
+
+ // read basis class and ranks initialize the object
+ classes = plugin.getConfig().getConfigurationSection("classes").getValues(false);
+ for (String sClassName : classes.keySet())
+ {
+ Map ranks = ((ConfigurationSection) classes
+ .get(sClassName)).getValues(false);
+ boolean newClass = true;
+ for (String sRankName : ranks.keySet())
+ {
+// Rank definition
+// this.sPermissionName = sPermName;
+// this.sDisplayName = sDispName;
+// this.cColor = cC;
+// this.crcSuper = crc;
+// this.items = isItems;
+// this.cost = dCost;
+// this.exp = iExp;
+
+ String rankName = null;
+ String rankColor = "&f";
+ double rankCost = -1337D;
+ ItemStack[] rankItems = null;
+ int rankExp = -1;
+
+ if (plugin.getConfig().get("classes." + sClassName + "." + sRankName + ".name") != null)
+ {
+ rankName = plugin.getConfig()
+ .getString(
+ "classes." + sClassName + "." + sRankName
+ + ".name");
+ }
+ if (plugin.getConfig().get("classes." + sClassName + "." + sRankName + ".color") != null)
+ {
+ rankColor = plugin.getConfig().getString(
+ "classes." + sClassName + "." + sRankName
+ + ".color");
+ }
+ if (plugin.getConfig().get("classes." + sClassName + "." + sRankName + ".price") != null)
+ {
+ rankCost = Double.valueOf(plugin.getConfig().getString(
+ "classes." + sClassName + "." + sRankName
+ + ".price"));
+ }
+ if (plugin.getConfig().get("classes." + sClassName + "." + sRankName + ".items") != null)
+ {
+ rankItems = FormatManager
+ .getItemStacksFromStringList(plugin.getConfig()
+ .getStringList(
+ "classes." + sClassName + "."
+ + sRankName + ".items"));
+ }
+ if (plugin.getConfig().get(
+ "classes." + sClassName + "." + sRankName + ".exp") != null)
+ {
+ rankExp = Integer.parseInt(plugin.getConfig().getString(
+ "classes." + sClassName + "." + sRankName + ".exp"));
+ }
+
+ if (newClass)
+ {
+ // create class
+ ClazzList.configClassAdd(sClassName, sRankName,rankName, rankColor, rankItems, rankCost, rankExp,null);
+ newClass = false;
+ } else
+ {
+ ClazzList.configRankAdd(sClassName, sRankName, rankName,rankColor, rankItems, rankCost, rankExp, null);
+ }
+ }
+ }
+
+// getConfig().getString("progress."+pPlayer.getName());
+ playerSectionRead() ;
+
+ plugin.saveConfig();
+ }
+
+ /**
+ *
+ */
+ public void playerSectionRead()
+ {
+ boolean isSection = (plugin.getConfig().getConfigurationSection("players") != null);
+
+ if (!isSection)
+ {
+ playersClazzList = null;
+ } else
+ {
+ Map playerList = plugin.getConfig().getConfigurationSection("players").getValues(false);
+
+ if (playerList != null)
+ {
+ System.out.println("PlayerClassRank List");
+ for (String playerName : playerList.keySet())
+ {
+ PlayerClazzList playerClazzList = new PlayerClazzList(playerName,"");
+
+ Map playerClass = plugin.getConfig().getConfigurationSection("players."+playerName).getValues(false);
+ for (String clazzName : playerClass.keySet())
+ {
+ String rankName = plugin.getConfig().getString("players."+playerName+"."+clazzName,"");
+ playerClazzList.addPlayerClassRank(clazzName, rankName);
+
+ }
+ playersClazzList.put(playerName, playerClazzList);
+ }
+ // Test output
+ for (PlayerClazzList playerClazz : playersClazzList.values())
+ {
+ for (String name : playerClazz.keySet())
+ {
+ String rankName = playerClazz.get(name);
+ System.out.println(playerClazz.getUuid()+":"+name+":"+rankName);
+ }
+ }
+ }
+
+ }
+
+ }
+
+ private void playerSectionWrite()
+ {
+ plugin.getConfig().set("players",playersClazzList);
+ plugin.saveConfig();
+ }
+
+ public void playerSectionWrite(Player player, String className, String rank)
+ {
+ plugin.getConfig().set("players." + player.getUniqueId().toString() + "." + className, rank);
+ plugin.db.i("Save to config added rank " + rank + " to player " + player + ", no world support");
+ plugin.saveConfig();
+ }
+
+ public void playerSectionRemove(Player player, String className)
+ {
+ if (className != null)
+ {
+ plugin.db.i("Remove config " + player.getUniqueId().toString() + " : "+className);
+ PlayerClazzList playerClazz = playersClazzList.get(player.getUniqueId().toString());
+ if(playerClazz.containsKey(className))
+ {
+ playerClazz.remove(className);
+ plugin.db.i("Save player section after remove " );
+ playerSectionWrite();
+ }
+ }
+
+ }
+
+ /**
+ * save the classrank map to the config
+ */
+ public void save_config()
+ {
+ plugin.db.i("saving config...");
+ for (Clazz cClass : ClazzList.getClasses())
+ {
+ plugin.db.i(" - " + cClass.name);
+ for (Rank rRank : cClass.ranks) {
+
+ rRank.debugPrint();
+
+ plugin.getConfig().set(
+ "classes." + cClass.name + "." + rRank.getPermName()
+ + ".name", String.valueOf(rRank.getDispName()));
+ plugin.getConfig().set(
+ "classes." + cClass.name + "." + rRank.getPermName()
+ + ".color",
+ String.valueOf("&"
+ + Integer.toHexString(rRank.getColor()
+ .ordinal())));
+ plugin.getConfig().set(
+ "classes." + cClass.name + "." + rRank.getPermName()
+ + ".price", String.valueOf(rRank.getCost()));
+
+ if (rRank.getExp() > -1)
+ plugin.getConfig().set(
+ "classes." + cClass.name + "."
+ + rRank.getPermName() + ".exp",
+ String.valueOf(rRank.getExp()));
+ if (rRank.getItems() != null)
+ plugin.getConfig().set(
+ "classes." + cClass.name + "."
+ + rRank.getPermName() + ".items",
+ rRank.getItems());
+ if (rRank.getCost() != -1337D)
+ plugin.getConfig().set(
+ "classes." + cClass.name + "."
+ + rRank.getPermName() + ".price",
+ String.valueOf(rRank.getCost()));
+ }
+ }
+ plugin.saveConfig();
+ }
+
+
+}
diff --git a/src/net/slipcor/classranks/managers/DebugManager.java b/src/net/slipcor/classranks/managers/DebugManager.java
index 0f79ba8..4d4b797 100644
--- a/src/net/slipcor/classranks/managers/DebugManager.java
+++ b/src/net/slipcor/classranks/managers/DebugManager.java
@@ -17,10 +17,11 @@
*/
public class DebugManager {
- public static boolean active;
+ public static boolean active = false;
public final ClassRanks plugin;
- public DebugManager(ClassRanks plugin) {
+ public DebugManager(ClassRanks plugin)
+ {
this.plugin = plugin;
}
diff --git a/src/net/slipcor/classranks/managers/FormatManager.java b/src/net/slipcor/classranks/managers/FormatManager.java
index e8abd5c..8849f6e 100644
--- a/src/net/slipcor/classranks/managers/FormatManager.java
+++ b/src/net/slipcor/classranks/managers/FormatManager.java
@@ -15,27 +15,32 @@
* @author slipcor
*/
-public class FormatManager {
- private ChatColor colPlayer = ChatColor.YELLOW; // Color: Playername
- private ChatColor colWorld = ChatColor.GOLD; // Color: Worldname
+public class FormatManager
+{
+ private static ChatColor colPlayer = ChatColor.YELLOW; // Color: Playername
+ private static ChatColor colWorld = ChatColor.GOLD; // Color: Worldname
/*
* Wrap a string in the desired color
*/
- String formatPlayer(String str) {
- String tStr = PlayerManager.search(str);
- if (!tStr.equals("")) {
+ public static String formatPlayer(String playerName)
+ {
+ String tStr = PlayerManager.searchName(playerName);
+ if (tStr.equals("") == false)
+ {
// if a valid playername: replace
- str = tStr;
+ playerName = tStr;
}
- return colPlayer + str + ChatColor.WHITE;
+ return colPlayer + playerName + ChatColor.WHITE;
}
/*
* Wrap a string in the desired color
*/
- String formatWorld(String str) {
- if (str.equalsIgnoreCase("all")) {
+ public static String formatWorld(String str)
+ {
+ if (str.equalsIgnoreCase("all"))
+ {
str = "all worlds";
}
return colWorld + str + ChatColor.WHITE;
@@ -44,7 +49,8 @@ String formatWorld(String str) {
/*
* read a string and format it with given color code (e.g. '&e')
*/
- String formatStringByColorCode(String str, String code) {
+ public static String formatStringByColorCode(String str, String code)
+ {
// remove the color prefix
code = code.replace("&", "");
ChatColor cc = formatColor(code);
@@ -83,22 +89,28 @@ public static String formatItemStacks(ItemStack[] itemStacks) {
return result;
}
- public static ItemStack[] getItemStacksFromStringList(List stringList) {
+ public static ItemStack[] getItemStacksFromStringList(List stringList)
+ {
String result = "";
- for (String item : stringList) {
- result += result.equals("")?item:","+item;
+ for (String item : stringList)
+ {
+ result += result.equals("") ? item:","+item;
}
return getItemStacksFromCommaString(result);
}
- public static ItemStack[] getItemStacksFromCommaString (String string) {
+ public static ItemStack[] getItemStacksFromCommaString (String string)
+ {
String[] arrStacks = string.split(",");
ItemStack[] result = new ItemStack[arrStacks.length];
int i = 0;
- for (String stack : arrStacks) {
- if (stack.contains(":")) {
+ for (String stack : arrStacks)
+ {
+ if (stack.contains(":"))
+ {
String[] vars = stack.split(":");
- if (vars.length == 2) {
+ if (vars.length == 2)
+ {
int iAmount = 1;
try {
iAmount = Integer.parseInt(vars[1]);
@@ -149,7 +161,8 @@ public static ItemStack[] getItemStacksFromCommaString (String string) {
/*
* store the config colors into our private values
*/
- public void setColors(String sColor, String sPlayerCode, String sWorldCode) {
+ public static void setColors(String sPlayerCode, String sWorldCode)
+ {
colPlayer = formatColor(sPlayerCode);
colWorld = formatColor(sWorldCode);
}
diff --git a/src/net/slipcor/classranks/managers/PlayerClassManager.java b/src/net/slipcor/classranks/managers/PlayerClassManager.java
new file mode 100644
index 0000000..5af0d33
--- /dev/null
+++ b/src/net/slipcor/classranks/managers/PlayerClassManager.java
@@ -0,0 +1,100 @@
+package net.slipcor.classranks.managers;
+
+import net.slipcor.classranks.core.*;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+
+import org.bukkit.Bukkit;
+
+/**
+ * hold PlayerClazzRank List.
+ * this list are load from config and realize a player tracking
+ *
+ * @author Windu
+ *
+ */
+public class PlayerClassManager
+{
+
+ private ArrayList playerClassList;
+
+ public ArrayList getPlayerClassList()
+ {
+ return playerClassList;
+ }
+
+ // public void setPlayerClassList(ArrayList
+ // playerClassList) {
+ // this.playerClassList = playerClassList;
+ // }
+
+ public PlayerClassManager()
+ {
+ super();
+ this.playerClassList = new ArrayList();
+ }
+
+ /*
+ * add player to list prevent double entrys
+ */
+ public void addPlayer(String playerName)
+ {
+
+ // player not found make player entry
+ if (!checkPlayerName(playerName))
+ {
+ playerClassList.add(new PlayerClazzList(playerName, null));
+ }
+
+ }
+
+ /*
+ * checks for playername in list
+ */
+ public boolean checkPlayerName(String playerName)
+ {
+
+ if (playerClassList.isEmpty())
+ {
+ return false;
+ }
+ boolean isfound = false;
+ for (Iterator item = playerClassList.iterator(); item
+ .hasNext();)
+ {
+ if (item.next().equalsIgnoreCaseName(playerName))
+ {
+ isfound = true;
+ }
+ }
+ return isfound;
+
+ }
+
+ public String getFirstPermNameByClassName(String className, String sPlayer)
+ {
+ // extended version: get rank
+ for (PlayerClazzList pClazzList : playerClassList)
+ {
+ if (pClazzList.getPlayerName().equalsIgnoreCase(sPlayer))
+ {
+ if (pClazzList.equalsIgnoreCaseClass(className))
+ {
+ return pClazzList.get(className);
+ }
+ }
+ }
+// for (Clazz c : clazzes)
+// {
+// if (c.name.equals(cString))
+// {
+// return c.ranks
+// .get(ClazzList.loadClassProcess(
+// Bukkit.getPlayer(sPlayer), c)).getPermName();
+// }
+// }
+ return null;
+ }
+
+}
diff --git a/src/net/slipcor/classranks/managers/PlayerManager.java b/src/net/slipcor/classranks/managers/PlayerManager.java
index 6788441..b1e9bf9 100644
--- a/src/net/slipcor/classranks/managers/PlayerManager.java
+++ b/src/net/slipcor/classranks/managers/PlayerManager.java
@@ -3,11 +3,16 @@
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
+import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.logging.Level;
import net.slipcor.classranks.ClassRanks;
+import net.slipcor.classranks.core.Clazz;
+import net.slipcor.classranks.core.Item;
+import net.slipcor.classranks.core.ItemList;
+
import org.bukkit.Bukkit;
import org.bukkit.configuration.InvalidConfigurationException;
import org.bukkit.configuration.file.YamlConfiguration;
@@ -16,6 +21,8 @@
/*
* Player manager class
+ * - handles the cooldown , cooldown stored in yml
+ * - handles Inventory of player and Items
*
* v0.2.0 - mayor rewrite; no SQL; multiPermissions
*
@@ -25,131 +32,178 @@
* v0.1.5.1 - cleanup
* v0.1.5.0 - more fixes, update to CB #1337
*
- * @author slipcor
+ * @author slipcor / Krglok
*/
-public class PlayerManager {
+public class PlayerManager
+{
private final ClassRanks plugin;
- private static DebugManager db;
- public static int coolDown;
- public PlayerManager(ClassRanks plugin) {
+ public PlayerManager(ClassRanks plugin)
+ {
this.plugin = plugin;
- db = new DebugManager(plugin);
+ }
+
+
+ public static Player searchPlayerName(String name)
+ {
+ for (Player player : Bukkit.getServer().getOnlinePlayers())
+ {
+ if (player.getName().equalsIgnoreCase(name))
+ {
+ return player; // gotcha!
+ }
+ }
+ System.out.println("[ClassRank] player not online "+name);
+ // plugin.db.i("player not online: " + playerName);
+ // not found online, hope that it was right anyways
+ return null;
}
/*
* receive a string and search for online usernames containing it
*/
- public static String search(String player) {
- Player[] p = Bukkit.getServer().getOnlinePlayers();
- for (int i=0;i players = Bukkit.getServer().getOnlinePlayers();
+ for (Player p : players)
+ {
+ if (p.getName().toLowerCase().contains(playerName.toLowerCase()))
+ {
+ return p.getName(); // gotcha!
+ }
+ }
+// db.i("player not online: " + player);
// not found online, hope that it was right anyways
- return player;
+ return "";
}
-
- boolean ifHasTakeItems(Player iPlayer, ItemStack[] isItems) {
- ItemStack[] isItemsBackup = null;
-
- ItemStack[] isPlayerItems = iPlayer.getInventory().getContents();
- ItemStack[] isPlayerItemsBackup = new ItemStack[isPlayerItems.length];
-
- HashMap iiItemsLeftover;
- isItemsBackup = new ItemStack[isItems.length];
-
- for (int i=0;i= items[i].getAmount())
+ {
+ isContain = true;
+ plugin.db.i("Found : "+item.ItemRef() + " : " + item.value());
+ //getData().getItemType().name();
+ }
+ }
+ }
+ if (isContain == false)
+ {
+ plugin.msg(player,"Not found : "+items[i].getData().getItemType().name() + " : " + items[i].getAmount());
+ plugin.db.i("Not found : "+items[i].getData().getItemType().name() + " : " + items[i].getAmount());
+ return false;
+ }
}
+
}
- // isPlayerItems == Player Inventory
- // isPlayerItemsBackup == Backup
+ return true;
+ }
- iiItemsLeftover = iPlayer.getInventory().removeItem(isItemsBackup);
-
- if(!iiItemsLeftover.isEmpty()){
- // player does NOT have the stuff
+ public boolean takeItems(Player player, ItemStack[] items)
+ {
- db.i("player does not have the items");
- iPlayer.getInventory().setContents(isPlayerItemsBackup);
- return false;
+ for (int i=0;i cdx = new HashMap();
cdx.put("slipcor", 0);
- config.addDefault("cooldown", cdx);
+ configCool.addDefault("cooldown", cdx);
}
- Map cds = (Map) config.getConfigurationSection("cooldown").getValues(true);
+ Map cds = (Map) configCool.getConfigurationSection("cooldown").getValues(true);
int now = Math.round((System.currentTimeMillis() % (60*60*24*1000)) /1000);
- if (cds.containsKey(comP.getName())) {
- db.i("player cooldown found!");
- // Subtract the seconds waited from the needed seconds
- int cd = coolDown - (now - (Integer) cds.get(comP.getName()));
- if ((cd <= coolDown) && (cd > 0)) {
- db.i("cooldown still is: "+cd);
+// if (cds.containsKey(player.getName()))
+ if (cds.containsKey(player.getUniqueId().toString()))
+ {
+ int cd = plugin.config.getCoolDown() - (now - (Integer) cds.get(player.getName()));
+ if ((cd <= plugin.config.getCoolDown()) && (cd > 0))
+ {
return cd; // we still have to wait, return how many seconds
}
- cds.remove(comP.getName()); // delete the value
- db.i("value deleted");
+ cds.remove(player.getUniqueId().toString()); // delete the value
}
- cds.put(comP.getName(), now);
- db.i("value set");
+ cds.put(player.getUniqueId().toString(), now);
- config.set("cooldown", cds);
- try {
- config.save(fConfig);
- } catch (IOException e) {
- plugin.log("IO Exception!", Level.SEVERE);
+ configCool.set("cooldown", cds);
+ try
+ {
+ configCool.save(fConfig);
+ }
+ catch (IOException e)
+ {
+ ClassRanks.log("IO Exception!", Level.SEVERE);
e.printStackTrace();
}
return 0;
}
-
+
}
diff --git a/src/net/slipcor/classranks/register/payment/Methods.java b/src/net/slipcor/classranks/register/payment/Methods.java
index 2d32bde..de2d330 100644
--- a/src/net/slipcor/classranks/register/payment/Methods.java
+++ b/src/net/slipcor/classranks/register/payment/Methods.java
@@ -42,14 +42,6 @@ public class Methods {
* Implement all methods along with their respective name & class.
*/
private static void _init() {
- addMethod("iConomy", new net.slipcor.classranks.register.payment.methods.iCo6());
- addMethod("iConomy", new net.slipcor.classranks.register.payment.methods.iCo5());/*
- addMethod("iConomy", new praxis.classranks.register.payment.methods.iCo4());
- addMethod("BOSEconomy", new praxis.classranks.register.payment.methods.BOSE6());*/
- addMethod("BOSEconomy", new net.slipcor.classranks.register.payment.methods.BOSE7());
- addMethod("Essentials", new net.slipcor.classranks.register.payment.methods.EE17());
- addMethod("Currency", new net.slipcor.classranks.register.payment.methods.MCUR());
- Dependencies.add("MultiCurrency");
}
/**
diff --git a/src/net/slipcor/classranks/register/payment/methods/BOSE7.java b/src/net/slipcor/classranks/register/payment/methods/BOSE7.java
deleted file mode 100644
index b077305..0000000
--- a/src/net/slipcor/classranks/register/payment/methods/BOSE7.java
+++ /dev/null
@@ -1,206 +0,0 @@
-package net.slipcor.classranks.register.payment.methods;
-
-import cosine.boseconomy.BOSEconomy;
-import net.slipcor.classranks.register.payment.Method;
-
-import org.bukkit.plugin.Plugin;
-
-
-/**
- * BOSEconomy 7 Implementation of Method
- *
- * @author Acrobot
- * @author Nijikokun (@nijikokun)
- * @copyright (c) 2011
- * @license AOL license
- */
-public class BOSE7 implements Method {
- private BOSEconomy BOSEconomy;
-
- public BOSEconomy getPlugin() {
- return this.BOSEconomy;
- }
-
- public String getName() {
- return "BOSEconomy";
- }
-
- public String getVersion() {
- return "0.7.0";
- }
-
- public int fractionalDigits() {
- return this.BOSEconomy.getFractionalDigits();
- }
-
- public String format(double amount) {
- String currency = this.BOSEconomy.getMoneyNamePlural();
-
- if(amount == 1)
- currency = this.BOSEconomy.getMoneyName();
-
- return amount + " " + currency;
- }
-
- public boolean hasBanks() {
- return true;
- }
-
- public boolean hasBank(String bank) {
- return this.BOSEconomy.bankExists(bank);
- }
-
- public boolean hasAccount(String name) {
- return this.BOSEconomy.playerRegistered(name, false);
- }
-
- public boolean hasBankAccount(String bank, String name) {
- return this.BOSEconomy.isBankOwner(bank, name) || this.BOSEconomy.isBankMember(bank, name);
- }
-
- public MethodAccount getAccount(String name) {
- if(!hasAccount(name))
- return null;
- return new BOSEAccount(name, this.BOSEconomy);
- }
-
- public MethodBankAccount getBankAccount(String bank, String name) {
- if(!hasBankAccount(bank, name))
- return null;
-
- return new BOSEBankAccount(bank, BOSEconomy);
- }
-
- public boolean isCompatible(Plugin plugin) {
- return plugin.getDescription().getName().equalsIgnoreCase("boseconomy")
- && plugin instanceof BOSEconomy
- && !plugin.getDescription().getVersion().equals("0.6.2");
- }
-
- public void setPlugin(Plugin plugin) {
- BOSEconomy = (BOSEconomy)plugin;
- }
-
- public class BOSEAccount implements MethodAccount {
- private String name;
- private BOSEconomy BOSEconomy;
-
- public BOSEAccount(String name, BOSEconomy bOSEconomy) {
- this.name = name;
- this.BOSEconomy = bOSEconomy;
- }
-
- public double balance() {
- return this.BOSEconomy.getPlayerMoneyDouble(this.name);
- }
-
- public boolean set(double amount) {
- return this.BOSEconomy.setPlayerMoney(this.name, amount, false);
- }
-
- public boolean add(double amount) {
- return this.BOSEconomy.addPlayerMoney(this.name, amount, false);
- }
-
- public boolean subtract(double amount) {
- double balance = this.balance();
- return this.BOSEconomy.setPlayerMoney(this.name, (balance - amount), false);
- }
-
- public boolean multiply(double amount) {
- double balance = this.balance();
- return this.BOSEconomy.setPlayerMoney(this.name, (balance * amount), false);
- }
-
- public boolean divide(double amount) {
- double balance = this.balance();
- return this.BOSEconomy.setPlayerMoney(this.name, (balance / amount), false);
- }
-
- public boolean hasEnough(double amount) {
- return (this.balance() >= amount);
- }
-
- public boolean hasOver(double amount) {
- return (this.balance() > amount);
- }
-
- public boolean hasUnder(double amount) {
- return (this.balance() < amount);
- }
-
- public boolean isNegative() {
- return (this.balance() < 0);
- }
-
- public boolean remove() {
- return false;
- }
- }
-
- public class BOSEBankAccount implements MethodBankAccount {
- private String bank;
- private BOSEconomy BOSEconomy;
-
- public BOSEBankAccount(String bank, BOSEconomy bOSEconomy) {
- this.bank = bank;
- this.BOSEconomy = bOSEconomy;
- }
-
- public String getBankName() {
- return this.bank;
- }
-
- public int getBankId() {
- return -1;
- }
-
- public double balance() {
- return this.BOSEconomy.getBankMoneyDouble(bank);
- }
-
- public boolean set(double amount) {
- return this.BOSEconomy.setBankMoney(bank, amount, true);
- }
-
- public boolean add(double amount) {
- double balance = this.balance();
- return this.BOSEconomy.setBankMoney(bank, (balance + amount), false);
- }
-
- public boolean subtract(double amount) {
- double balance = this.balance();
- return this.BOSEconomy.setBankMoney(bank, (balance - amount), false);
- }
-
- public boolean multiply(double amount) {
- double balance = this.balance();
- return this.BOSEconomy.setBankMoney(bank, (balance * amount), false);
- }
-
- public boolean divide(double amount) {
- double balance = this.balance();
- return this.BOSEconomy.setBankMoney(bank, (balance / amount), false);
- }
-
- public boolean hasEnough(double amount) {
- return (this.balance() >= amount);
- }
-
- public boolean hasOver(double amount) {
- return (this.balance() > amount);
- }
-
- public boolean hasUnder(double amount) {
- return (this.balance() < amount);
- }
-
- public boolean isNegative() {
- return (this.balance() < 0);
- }
-
- public boolean remove() {
- return this.BOSEconomy.removeBank(bank);
- }
- }
-}
\ No newline at end of file
diff --git a/src/net/slipcor/classranks/register/payment/methods/EE17.java b/src/net/slipcor/classranks/register/payment/methods/EE17.java
deleted file mode 100644
index 61e1996..0000000
--- a/src/net/slipcor/classranks/register/payment/methods/EE17.java
+++ /dev/null
@@ -1,219 +0,0 @@
-package net.slipcor.classranks.register.payment.methods;
-
-import com.earth2me.essentials.Essentials;
-import com.earth2me.essentials.api.Economy;
-import com.earth2me.essentials.api.NoLoanPermittedException;
-import com.earth2me.essentials.api.UserDoesNotExistException;
-
-
-import net.slipcor.classranks.register.payment.Method;
-
-import org.bukkit.plugin.Plugin;
-
-
-/**
- * Essentials 17 Implementation of Method
- *
- * @author Nijikokun (@nijikokun)
- * @author Snowleo
- * @author Acrobot
- * @author KHobbits
- * @copyright (c) 2011
- * @license AOL license
- */
-public class EE17 implements Method {
- private Essentials Essentials;
-
- public Essentials getPlugin() {
- return this.Essentials;
- }
-
- public String getName() {
- return "Essentials";
- }
-
- public String getVersion() {
- return "2.2";
- }
-
- public int fractionalDigits() {
- return -1;
- }
-
- public String format(double amount) {
- return Economy.format(amount);
- }
-
- public boolean hasBanks() {
- return false;
- }
-
- public boolean hasBank(String bank) {
- return false;
- }
-
- public boolean hasAccount(String name) {
- return Economy.playerExists(name);
- }
-
- public boolean hasBankAccount(String bank, String name) {
- return false;
- }
-
- public MethodAccount getAccount(String name) {
- if(!hasAccount(name))
- return null;
-
- return new EEcoAccount(name);
- }
-
- public MethodBankAccount getBankAccount(String bank, String name) {
- return null;
- }
-
- public boolean isCompatible(Plugin plugin) {
- try { Class.forName("com.earth2me.essentials.api.Economy"); }
- catch(Exception e) { return false; }
-
- return plugin.getDescription().getName().equalsIgnoreCase("essentials")
- && plugin instanceof Essentials;
- }
-
- public void setPlugin(Plugin plugin) {
- Essentials = (Essentials)plugin;
- }
-
- public class EEcoAccount implements MethodAccount {
- private String name;
-
- public EEcoAccount(String name) {
- this.name = name;
- }
-
- public double balance() {
- Double balance = 0.0;
-
- try {
- balance = Economy.getMoney(this.name);
- } catch (UserDoesNotExistException ex) {
- System.out.println("[REGISTER] Failed to grab balance in Essentials Economy: " + ex.getMessage());
- }
-
- return balance;
- }
-
- public boolean set(double amount) {
- try {
- Economy.setMoney(name, amount);
- } catch (UserDoesNotExistException ex) {
- System.out.println("[REGISTER] User does not exist in Essentials Economy: " + ex.getMessage());
- return false;
- } catch (NoLoanPermittedException ex) {
- System.out.println("[REGISTER] No loan permitted in Essentials Economy: " + ex.getMessage());
- return false;
- }
-
- return true;
- }
-
- public boolean add(double amount) {
- try {
- Economy.add(name, amount);
- } catch (UserDoesNotExistException ex) {
- System.out.println("[REGISTER] User does not exist in Essentials Economy: " + ex.getMessage());
- return false;
- } catch (NoLoanPermittedException ex) {
- System.out.println("[REGISTER] No loan permitted in Essentials Economy: " + ex.getMessage());
- return false;
- }
-
- return true;
- }
-
- public boolean subtract(double amount) {
- try {
- Economy.subtract(name, amount);
- } catch (UserDoesNotExistException ex) {
- System.out.println("[REGISTER] User does not exist in Essentials Economy: " + ex.getMessage());
- return false;
- } catch (NoLoanPermittedException ex) {
- System.out.println("[REGISTER] No loan permitted in Essentials Economy: " + ex.getMessage());
- return false;
- }
-
- return true;
- }
-
- public boolean multiply(double amount) {
- try {
- Economy.multiply(name, amount);
- } catch (UserDoesNotExistException ex) {
- System.out.println("[REGISTER] User does not exist in Essentials Economy: " + ex.getMessage());
- return false;
- } catch (NoLoanPermittedException ex) {
- System.out.println("[REGISTER] No loan permitted in Essentials Economy: " + ex.getMessage());
- return false;
- }
-
- return true;
- }
-
- public boolean divide(double amount) {
- try {
- Economy.divide(name, amount);
- } catch (UserDoesNotExistException ex) {
- System.out.println("[REGISTER] User does not exist in Essentials Economy: " + ex.getMessage());
- return false;
- } catch (NoLoanPermittedException ex) {
- System.out.println("[REGISTER] No loan permitted in Essentials Economy: " + ex.getMessage());
- return false;
- }
-
- return true;
- }
-
- public boolean hasEnough(double amount) {
- try {
- return Economy.hasEnough(name, amount);
- } catch (UserDoesNotExistException ex) {
- System.out.println("[REGISTER] User does not exist in Essentials Economy: " + ex.getMessage());
- }
-
- return false;
- }
-
- public boolean hasOver(double amount) {
- try {
- return Economy.hasMore(name, amount);
- } catch (UserDoesNotExistException ex) {
- System.out.println("[REGISTER] User does not exist in Essentials Economy: " + ex.getMessage());
- }
-
- return false;
- }
-
- public boolean hasUnder(double amount) {
- try {
- return Economy.hasLess(name, amount);
- } catch (UserDoesNotExistException ex) {
- System.out.println("[REGISTER] User does not exist in Essentials Economy: " + ex.getMessage());
- }
-
- return false;
- }
-
- public boolean isNegative() {
- try {
- return Economy.isNegative(name);
- } catch (UserDoesNotExistException ex) {
- System.out.println("[REGISTER] User does not exist in Essentials Economy: " + ex.getMessage());
- }
-
- return false;
- }
-
- public boolean remove() {
- return false;
- }
- }
-}
\ No newline at end of file
diff --git a/src/net/slipcor/classranks/register/payment/methods/MCUR.java b/src/net/slipcor/classranks/register/payment/methods/MCUR.java
deleted file mode 100644
index 0051041..0000000
--- a/src/net/slipcor/classranks/register/payment/methods/MCUR.java
+++ /dev/null
@@ -1,126 +0,0 @@
-package net.slipcor.classranks.register.payment.methods;
-
-import me.ashtheking.currency.Currency;
-import me.ashtheking.currency.CurrencyList;
-import net.slipcor.classranks.register.payment.Method;
-
-import org.bukkit.plugin.Plugin;
-
-
-/**
- * MultiCurrency Method implementation.
- *
- * @author Acrobot
- * @copyright (c) 2011
- * @license AOL license
- */
-public class MCUR implements Method {
- private Currency currencyList;
-
- public Object getPlugin() {
- return this.currencyList;
- }
-
- public String getName() {
- return "MultiCurrency";
- }
-
- public String getVersion() {
- return "0.09";
- }
-
- public int fractionalDigits() {
- return -1;
- }
-
- public String format(double amount) {
- return amount + " Currency";
- }
-
- public boolean hasBanks() {
- return false;
- }
-
- public boolean hasBank(String bank) {
- return false;
- }
-
- public boolean hasAccount(String name) {
- return true;
- }
-
- public boolean hasBankAccount(String bank, String name) {
- return false;
- }
-
- public MethodAccount getAccount(String name) {
- return new MCurrencyAccount(name);
- }
-
- public MethodBankAccount getBankAccount(String bank, String name) {
- return null;
- }
-
- public boolean isCompatible(Plugin plugin) {
- return (plugin.getDescription().getName().equalsIgnoreCase("Currency")
- || plugin.getDescription().getName().equalsIgnoreCase("MultiCurrency"))
- && plugin instanceof Currency;
- }
-
- public void setPlugin(Plugin plugin) {
- currencyList = (Currency) plugin;
- }
-
- public class MCurrencyAccount implements MethodAccount{
- private String name;
-
- public MCurrencyAccount(String name) {
- this.name = name;
- }
-
- public double balance() {
- return CurrencyList.getValue((String) CurrencyList.maxCurrency(name)[0], name);
- }
-
- public boolean set(double amount) {
- CurrencyList.setValue((String) CurrencyList.maxCurrency(name)[0], name, amount);
- return true;
- }
-
- public boolean add(double amount) {
- return CurrencyList.add(name, amount);
- }
-
- public boolean subtract(double amount) {
- return CurrencyList.subtract(name, amount);
- }
-
- public boolean multiply(double amount) {
- return CurrencyList.multiply(name, amount);
- }
-
- public boolean divide(double amount) {
- return CurrencyList.divide(name, amount);
- }
-
- public boolean hasEnough(double amount) {
- return CurrencyList.hasEnough(name, amount);
- }
-
- public boolean hasOver(double amount) {
- return CurrencyList.hasOver(name, amount);
- }
-
- public boolean hasUnder(double amount) {
- return CurrencyList.hasUnder(name, amount);
- }
-
- public boolean isNegative() {
- return CurrencyList.isNegative(name);
- }
-
- public boolean remove() {
- return CurrencyList.remove(name);
- }
- }
-}
\ No newline at end of file
diff --git a/src/net/slipcor/classranks/register/payment/methods/iCo5.java b/src/net/slipcor/classranks/register/payment/methods/iCo5.java
deleted file mode 100644
index 6e39ed1..0000000
--- a/src/net/slipcor/classranks/register/payment/methods/iCo5.java
+++ /dev/null
@@ -1,226 +0,0 @@
-package net.slipcor.classranks.register.payment.methods;
-
-import com.iConomy.iConomy;
-import com.iConomy.system.Account;
-import com.iConomy.system.BankAccount;
-import com.iConomy.system.Holdings;
-import com.iConomy.util.Constants;
-
-
-import net.slipcor.classranks.register.payment.Method;
-
-import org.bukkit.plugin.Plugin;
-
-
-/**
- * iConomy 5 Implementation of Method
- *
- * @author Nijikokun (@nijikokun)
- * @copyright (c) 2011
- * @license AOL license
- */
-public class iCo5 implements Method {
- private iConomy iConomy;
-
- public iConomy getPlugin() {
- return this.iConomy;
- }
-
- public String getName() {
- return "iConomy";
- }
-
- public String getVersion() {
- return "5";
- }
-
- public int fractionalDigits() {
- return 2;
- }
-
- public String format(double amount) {
- return com.iConomy.iConomy.format(amount);
- }
-
- public boolean hasBanks() {
- return Constants.Banking;
- }
-
- public boolean hasBank(String bank) {
- return (hasBanks()) && com.iConomy.iConomy.Banks.exists(bank);
- }
-
- public boolean hasAccount(String name) {
- return com.iConomy.iConomy.hasAccount(name);
- }
-
- public boolean hasBankAccount(String bank, String name) {
- return (hasBank(bank)) && com.iConomy.iConomy.getBank(bank).hasAccount(name);
- }
-
- public MethodAccount getAccount(String name) {
- return new iCoAccount(com.iConomy.iConomy.getAccount(name));
- }
-
- public MethodBankAccount getBankAccount(String bank, String name) {
- return new iCoBankAccount(com.iConomy.iConomy.getBank(bank).getAccount(name));
- }
-
- public boolean isCompatible(Plugin plugin) {
- return plugin.getDescription().getName().equalsIgnoreCase("iconomy")
- && plugin.getClass().getName().equals("com.iConomy.iConomy")
- && plugin instanceof iConomy;
- }
-
- public void setPlugin(Plugin plugin) {
- iConomy = (iConomy)plugin;
- }
-
- public class iCoAccount implements MethodAccount {
- private Account account;
- private Holdings holdings;
-
- public iCoAccount(Account account) {
- this.account = account;
- this.holdings = account.getHoldings();
- }
-
- public Account getiCoAccount() {
- return account;
- }
-
- public double balance() {
- return this.holdings.balance();
- }
-
- public boolean set(double amount) {
- if(this.holdings == null) return false;
- this.holdings.set(amount);
- return true;
- }
-
- public boolean add(double amount) {
- if(this.holdings == null) return false;
- this.holdings.add(amount);
- return true;
- }
-
- public boolean subtract(double amount) {
- if(this.holdings == null) return false;
- this.holdings.subtract(amount);
- return true;
- }
-
- public boolean multiply(double amount) {
- if(this.holdings == null) return false;
- this.holdings.multiply(amount);
- return true;
- }
-
- public boolean divide(double amount) {
- if(this.holdings == null) return false;
- this.holdings.divide(amount);
- return true;
- }
-
- public boolean hasEnough(double amount) {
- return this.holdings.hasEnough(amount);
- }
-
- public boolean hasOver(double amount) {
- return this.holdings.hasOver(amount);
- }
-
- public boolean hasUnder(double amount) {
- return this.holdings.hasUnder(amount);
- }
-
- public boolean isNegative() {
- return this.holdings.isNegative();
- }
-
- public boolean remove() {
- if(this.account == null) return false;
- this.account.remove();
- return true;
- }
- }
-
- public class iCoBankAccount implements MethodBankAccount {
- private BankAccount account;
- private Holdings holdings;
-
- public iCoBankAccount(BankAccount account) {
- this.account = account;
- this.holdings = account.getHoldings();
- }
-
- public BankAccount getiCoBankAccount() {
- return account;
- }
-
- public String getBankName() {
- return this.account.getBankName();
- }
-
- public int getBankId() {
- return this.account.getBankId();
- }
-
- public double balance() {
- return this.holdings.balance();
- }
-
- public boolean set(double amount) {
- if(this.holdings == null) return false;
- this.holdings.set(amount);
- return true;
- }
-
- public boolean add(double amount) {
- if(this.holdings == null) return false;
- this.holdings.add(amount);
- return true;
- }
-
- public boolean subtract(double amount) {
- if(this.holdings == null) return false;
- this.holdings.subtract(amount);
- return true;
- }
-
- public boolean multiply(double amount) {
- if(this.holdings == null) return false;
- this.holdings.multiply(amount);
- return true;
- }
-
- public boolean divide(double amount) {
- if(this.holdings == null) return false;
- this.holdings.divide(amount);
- return true;
- }
-
- public boolean hasEnough(double amount) {
- return this.holdings.hasEnough(amount);
- }
-
- public boolean hasOver(double amount) {
- return this.holdings.hasOver(amount);
- }
-
- public boolean hasUnder(double amount) {
- return this.holdings.hasUnder(amount);
- }
-
- public boolean isNegative() {
- return this.holdings.isNegative();
- }
-
- public boolean remove() {
- if(this.account == null) return false;
- this.account.remove();
- return true;
- }
- }
-}
\ No newline at end of file
diff --git a/src/net/slipcor/classranks/register/payment/methods/iCo6.java b/src/net/slipcor/classranks/register/payment/methods/iCo6.java
deleted file mode 100644
index cf18bc9..0000000
--- a/src/net/slipcor/classranks/register/payment/methods/iCo6.java
+++ /dev/null
@@ -1,147 +0,0 @@
-package net.slipcor.classranks.register.payment.methods;
-
-import com.iCo6.iConomy;
-import com.iCo6.system.Account;
-import com.iCo6.system.Accounts;
-import com.iCo6.system.Holdings;
-
-
-import net.slipcor.classranks.register.payment.Method;
-
-import org.bukkit.plugin.Plugin;
-
-
-/**
- * iConomy 6 Implementation of Method
- *
- * @author Nijikokun (@nijikokun)
- * @copyright (c) 2011
- * @license AOL license
- */
-public class iCo6 implements Method {
- private iConomy iConomy;
-
- public iConomy getPlugin() {
- return this.iConomy;
- }
-
- public String getName() {
- return "iConomy";
- }
-
- public String getVersion() {
- return "6";
- }
-
- public int fractionalDigits() {
- return 2;
- }
-
- public String format(double amount) {
- return com.iCo6.iConomy.format(amount);
- }
-
- public boolean hasBanks() {
- return false;
- }
-
- public boolean hasBank(String bank) {
- return false;
- }
-
- public boolean hasAccount(String name) {
- return (new Accounts()).exists(name);
- }
-
- public boolean hasBankAccount(String bank, String name) {
- return false;
- }
-
- public MethodAccount getAccount(String name) {
- return new iCoAccount((new Accounts()).get(name));
- }
-
- public MethodBankAccount getBankAccount(String bank, String name) {
- return null;
- }
-
- public boolean isCompatible(Plugin plugin) {
- return plugin.getDescription().getName().equalsIgnoreCase("iconomy")
- && plugin.getClass().getName().equals("com.iCo6.iConomy")
- && plugin instanceof iConomy;
- }
-
- public void setPlugin(Plugin plugin) {
- iConomy = (iConomy)plugin;
- }
-
- public class iCoAccount implements MethodAccount {
- private Account account;
- private Holdings holdings;
-
- public iCoAccount(Account account) {
- this.account = account;
- this.holdings = account.getHoldings();
- }
-
- public Account getiCoAccount() {
- return account;
- }
-
- public double balance() {
- return this.holdings.getBalance();
- }
-
- public boolean set(double amount) {
- if(this.holdings == null) return false;
- this.holdings.setBalance(amount);
- return true;
- }
-
- public boolean add(double amount) {
- if(this.holdings == null) return false;
- this.holdings.add(amount);
- return true;
- }
-
- public boolean subtract(double amount) {
- if(this.holdings == null) return false;
- this.holdings.subtract(amount);
- return true;
- }
-
- public boolean multiply(double amount) {
- if(this.holdings == null) return false;
- this.holdings.multiply(amount);
- return true;
- }
-
- public boolean divide(double amount) {
- if(this.holdings == null) return false;
- this.holdings.divide(amount);
- return true;
- }
-
- public boolean hasEnough(double amount) {
- return this.holdings.hasEnough(amount);
- }
-
- public boolean hasOver(double amount) {
- return this.holdings.hasOver(amount);
- }
-
- public boolean hasUnder(double amount) {
- return this.holdings.hasUnder(amount);
- }
-
- public boolean isNegative() {
- return this.holdings.isNegative();
- }
-
- public boolean remove() {
- if(this.account == null) return false;
- this.account.remove();
- return true;
- }
- }
-}
diff --git a/src/plugin.yml b/src/plugin.yml
index cee8d57..7fa3fb6 100644
--- a/src/plugin.yml
+++ b/src/plugin.yml
@@ -1,64 +1,78 @@
-name: ClassRanks
-main: net.slipcor.classranks.ClassRanks
-version: 0.4.4.1
-author: slipcor
-website: http://dev.bukkit.org/server-mods/classranks/
-soft-depends: [bPermissions,iConomy,BOSEconomy,MultiCurrency,Essentials,PermissionsEx,Vault]
-commands:
- class:
- description: Lets users choose a class / change classes
- usage: |
- /class [classname] | Choose the class [classname]
- /class [add] {username} {classname} {world} | Add user to a class
- /class [remove] {username} {world} | Remove user from a class
- /class [rankup/rankdown] [username] {world} | Rank user up/down
- /class [rankup/rankdown] | Rank yourself up/down
- /class get [username] {world} | Get the active rank of a user
- rankdown:
- description: Rank down yourself or others
- usage: |
- /rankdown [username] | Rank down yourself or username
- rankup:
- description: Rank up yourself or others
- usage: |
- /rankup [username] | Rank up yourself or username
- classadmin:
- description: Administrate the classes
- usage: |
- /classadmin add class [classname] [permname] [displayname] [color]
- /classadmin add rank [classname] [permname] [displayname] [color]
- /classadmin change class [classname] [newname]
- /classadmin change rank [classname] [rankname] [displayname] [color]
- /classadmin remove class [classname]
- /classadmin remove rank [classname] [rankname]
-permissions:
- classranks.*:
- description: Gives access to all commands
- children:
- classranks.rankdown: true
- classranks.self.rank: true
- classranks.self.addremove: true
- classranks.admin.*:
- description: Gives access to all admin commands
- children:
- classranks.admin.rank: true
- classranks.admin.addremove: true
- classranks.admin.admin: true
- classranks.rankdown:
- description: Allows you to rank down
- default: op
- classranks.self.rank:
- description: Allows you to rank yourself
- default: true
- classranks.self.addremove:
- description: Allows you to add/remove your class
- default: true
- classranks.admin.rank:
- description: Allows you to rank other people
- default: op
- classranks.admin.addremove:
- description: Allows you to add/remove other peoples classes
- default: op
- classranks.admin.admin:
- description: Allows you to administrate the classes (db)
- default: op
+name: ClassRanks
+main: net.slipcor.classranks.ClassRanks
+version: 0.7.1
+author: slipcor
+website: http://dev.bukkit.org/server-mods/classranks/
+soft-depends: [bPermissions,iConomy,BOSEconomy,MultiCurrency,Essentials,PermissionsEx,Vault]
+commands:
+ classranks:
+ description: Lets users choose a class / change classes
+ usage: |
+ /class ,player command for choose the class
+ /rankup ,player rankup his class
+ /rankdown ,player rankdown his class
+ /classadmin , admin or op command for configuration
+ class:
+ description: Lets users choose a class / change classes
+ usage: |
+ /class [classname] | Choose the class [classname] for yourself
+ /class [add] {username} {classname} {world} | Add user to a class
+ /class [remove] {username} {world} | Remove user from a class
+ /class [rankup] {username} {world} | Rank user up
+ /class [rankdown] {username} {world} | Rank user down
+ /class [get] {username} {world} | Show rank of user
+ /class [list] {classname} | list of class/ranks
+ /class [config] | list the configuration
+ /class [groups] {username} | list the groups of user
+ rankdown:
+ description: Rank down yourself or others
+ usage: |
+ /rankdown [username] | Rank down yourself or username
+ rankup:
+ description: Rank up yourself or others
+ usage: |
+ /rankup [username] | Rank up yourself or username
+ classadmin:
+ description: Administrate the classes
+
+ usage: |
+ /classadmin add class [classname] [permname] [displayname] [color] [item|0] [cost] [exp]
+ /classadmin add rank [classname] [permname] [displayname] [color] [item|0] [cost] [exp]
+ /classadmin change class [classname] [newname]
+ /classadmin change rank [classname] [rankname] [displayname] [color]
+ /classadmin remove class [classname]
+ /classadmin remove rank [classname] [rankname]
+ /classadmin list {classname} {rankname}
+ /classadmin config
+ /classadmin debug [TRUE/FALSE]
+permissions:
+ classranks.*:
+ description: Gives access to all commands
+ children:
+ classranks.rankdown: true
+ classranks.self.rank: true
+ classranks.self.addremove: true
+ classranks.admin.*:
+ description: Gives access to all admin commands
+ children:
+ classranks.admin.rank: true
+ classranks.admin.addremove: true
+ classranks.admin.admin: true
+ classranks.rankdown:
+ description: Allows you to rank down
+ default: op
+ classranks.self.rank:
+ description: Allows you to rank yourself
+ default: true
+ classranks.self.addremove:
+ description: Allows you to add/remove your class
+ default: true
+ classranks.admin.rank:
+ description: Allows you to rank other people
+ default: op
+ classranks.admin.addremove:
+ description: Allows you to add/remove other peoples classes
+ default: op
+ classranks.admin.admin:
+ description: Allows you to administrate the classes (db)
+ default: op