Merge remote-tracking branch 'origin/magicbox1.5' into mob-AI-debug

# Conflicts:
#	src/engine/ai/MobileFSM.java

src/engine/ai/MobileFSMManager.java

@@ -8,6 +8,7 @@
 
 
 package engine.ai;
+import engine.gameManager.SessionManager;
 import engine.gameManager.ZoneManager;
 import engine.objects.Mob;
 import engine.objects.Zone;
@@ -88,7 +89,7 @@ public class MobileFSMManager {
 					for (Mob mob : zone.zoneMobSet) {
 
 						try {
-							if (mob != null)
+							if (mob != null && SessionManager.getActivePlayerCharacterCount() > 0)
 								MobileFSM.DetermineAction(mob);
 						} catch (Exception e) {
 							Logger.error("Mob: " + mob.getName() + " UUID: " + mob.getObjectUUID() + " ERROR: " + e);

src/engine/db/archive/BaneRecord.java

@@ -10,6 +10,7 @@
 package engine.db.archive;
 
 import engine.Enum;
+import engine.gameManager.DbManager;
 import engine.objects.Bane;
 import engine.objects.City;
 import engine.workthreads.WarehousePushThread;
@@ -134,9 +135,9 @@ public class BaneRecord extends DataRecord {
 
 		DateTime outDateTime = null;
 
-		try (Connection connection = DataWarehouse.connectionPool.getConnection();
-				PreparedStatement statement = buildDateTimeQueryStatement(connection, city);
-				ResultSet rs = statement.executeQuery()) {
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement statement = buildDateTimeQueryStatement(connection, city);
+			 ResultSet rs = statement.executeQuery()) {
 
 			while (rs.next()) {
 
@@ -145,7 +146,7 @@ public class BaneRecord extends DataRecord {
 			}
 
 		} catch (SQLException e) {
-			Logger.error( e.toString());
+			Logger.error(e.toString());
 		}
 
 		return outDateTime;
@@ -166,13 +167,13 @@ public class BaneRecord extends DataRecord {
 		if (bane == null)
 			return;
 
-		try (Connection connection = DataWarehouse.connectionPool.getConnection();
-				PreparedStatement statement = buildUpdateLiveDateStatement(connection, bane, dateTime)) {
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement statement = buildUpdateLiveDateStatement(connection, bane, dateTime)) {
 
 			statement.execute();
 
 		} catch (SQLException e) {
-			Logger.error( e.toString());
+			Logger.error(e.toString());
 		}
 	}
 
@@ -203,8 +204,8 @@ public class BaneRecord extends DataRecord {
 
 	public static void updateResolution(Bane bane, RecordEventType eventType) {
 
-		try (Connection connection = DataWarehouse.connectionPool.getConnection();
-				PreparedStatement statement = buildUpdateResolutionStatement(connection, bane, eventType)) {
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement statement = buildUpdateResolutionStatement(connection, bane, eventType)) {
 
 			statement.execute();
 
@@ -223,9 +224,9 @@ public class BaneRecord extends DataRecord {
 		dividerString = "--------------------------------" + newLine;
 		queryString = "CALL `baneHistory`()";
 
-		try (Connection connection = DataWarehouse.connectionPool.getConnection();
-				PreparedStatement statement = connection.prepareCall(queryString);
-				ResultSet rs = statement.executeQuery()) {
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement statement = connection.prepareCall(queryString);
+			 ResultSet rs = statement.executeQuery()) {
 
 			while (rs.next()) {
 
@@ -253,9 +254,9 @@ public class BaneRecord extends DataRecord {
 
 		WarehousePushThread.baneDelta = 0;
 
-		try (Connection localConnection = DataWarehouse.connectionPool.getConnection();
-				PreparedStatement statement = localConnection.prepareStatement(queryString, ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE); // Make this an updatable result set as we'll reset the dirty flag as we go along
-				ResultSet rs = statement.executeQuery()) {
+		try (Connection localConnection = DbManager.getConnection();
+			 PreparedStatement statement = localConnection.prepareStatement(queryString, ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE); // Make this an updatable result set as we'll reset the dirty flag as we go along
+			 ResultSet rs = statement.executeQuery()) {
 
 			while (rs.next()) {
 
@@ -338,13 +339,13 @@ public class BaneRecord extends DataRecord {
 
 	public void write() {
 
-		try (Connection connection = DataWarehouse.connectionPool.getConnection();
-				PreparedStatement statement = buildBaneInsertStatement(connection)) {
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement statement = buildBaneInsertStatement(connection)) {
 
 			statement.execute();
 
 		} catch (SQLException e) {
-			Logger.error( e.toString());
+			Logger.error(e.toString());
 		}
 
 	}

src/engine/db/archive/CharacterRecord.java

@@ -10,6 +10,7 @@
 package engine.db.archive;
 
 import engine.Enum;
+import engine.gameManager.DbManager;
 import engine.objects.Guild;
 import engine.objects.PlayerCharacter;
 import engine.workthreads.WarehousePushThread;
@@ -109,13 +110,13 @@ public class CharacterRecord extends DataRecord {
 
     public static void advanceKillCounter(PlayerCharacter player) {
 
-        try (Connection connection = DataWarehouse.connectionPool.getConnection();
+        try (Connection connection = DbManager.getConnection();
              PreparedStatement statement = buildKillCounterStatement(connection, player)) {
 
             statement.execute();
 
         } catch (SQLException e) {
-            Logger.error( e.toString());
+            Logger.error(e.toString());
         }
 
     }
@@ -136,13 +137,13 @@ public class CharacterRecord extends DataRecord {
 
     public static void advanceDeathCounter(PlayerCharacter player) {
 
-        try (Connection connection = DataWarehouse.connectionPool.getConnection();
+        try (Connection connection = DbManager.getConnection();
              PreparedStatement statement = buildDeathCounterStatement(connection, player)) {
 
             statement.execute();
 
         } catch (SQLException e) {
-            Logger.error( e.toString());
+            Logger.error(e.toString());
         }
 
     }
@@ -163,13 +164,13 @@ public class CharacterRecord extends DataRecord {
 
     public static void updatePromotionClass(PlayerCharacter player) {
 
-        try (Connection connection = DataWarehouse.connectionPool.getConnection();
+        try (Connection connection = DbManager.getConnection();
              PreparedStatement statement = buildUpdatePromotionStatement(connection, player)) {
 
             statement.execute();
 
         } catch (SQLException e) {
-            Logger.error( e.toString());
+            Logger.error(e.toString());
         }
 
     }
@@ -197,7 +198,7 @@ public class CharacterRecord extends DataRecord {
 
         WarehousePushThread.charDelta = 0;
 
-        try (Connection localConnection = DataWarehouse.connectionPool.getConnection();
+        try (Connection localConnection = DbManager.getConnection();
              PreparedStatement statement = localConnection.prepareStatement(queryString, ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE); // Make this an updatable result set as we'll reset the dirty flag as we go along
              ResultSet rs = statement.executeQuery()) {
 
@@ -263,13 +264,13 @@ public class CharacterRecord extends DataRecord {
 
     public void write() {
 
-        try (Connection connection = DataWarehouse.connectionPool.getConnection();
+        try (Connection connection = DbManager.getConnection();
              PreparedStatement statement = buildCharacterInsertStatement(connection, this.player)) {
 
             statement.execute();
 
         } catch (SQLException e) {
-            Logger.error( "Error writing character record " + e.toString());
+            Logger.error("Error writing character record " + e.toString());
 
         }
     }

src/engine/db/archive/CityRecord.java

@@ -10,6 +10,7 @@
 package engine.db.archive;
 
 import engine.Enum;
+import engine.gameManager.DbManager;
 import engine.objects.City;
 import engine.workthreads.WarehousePushThread;
 
@@ -126,8 +127,8 @@ public class CityRecord extends DataRecord {
 
 	public void write() {
 
-		try (Connection connection = DataWarehouse.connectionPool.getConnection();
-				PreparedStatement statement = this.buildCityInsertStatement(connection)) {
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement statement = this.buildCityInsertStatement(connection)) {
 
 			statement.execute();
 

src/engine/db/archive/DataWarehouse.java

@@ -12,6 +12,7 @@ package engine.db.archive;
 import com.zaxxer.hikari.HikariConfig;
 import com.zaxxer.hikari.HikariDataSource;
 import engine.gameManager.ConfigManager;
+import engine.gameManager.DbManager;
 import engine.util.Hasher;
 import org.pmw.tinylog.Logger;
 
@@ -27,15 +28,10 @@ public class DataWarehouse implements Runnable {
 
     public static final Hasher hasher = new Hasher("Cthulhu Owns Joo");
     private static final LinkedBlockingQueue<DataRecord> recordQueue = new LinkedBlockingQueue<>();
-    public static HikariDataSource connectionPool = null;
     public static HikariDataSource remoteConnectionPool = null;
 
     public DataWarehouse() {
 
-        Logger.info("Configuring local Database Connection Pool...");
-
-        configureConnectionPool();
-
         // If WarehousePush is disabled
         // then early exit
 
@@ -46,7 +42,6 @@ public class DataWarehouse implements Runnable {
 
         Logger.info( "Configuring remote Database Connection Pool...");
         configureRemoteConnectionPool();
-
     }
 
     public static void bootStrap() {
@@ -72,11 +67,7 @@ public class DataWarehouse implements Runnable {
         String queryString;
         String hashString;
 
-        try {
-            connection = DataWarehouse.connectionPool.getConnection();
-        } catch (SQLException e) {
-            e.printStackTrace();
-        }
+        connection = DbManager.getConnection();
 
         if (connection == null) {
             Logger.error("Null connection when writing zone hash.");
@@ -140,11 +131,7 @@ public class DataWarehouse implements Runnable {
         String queryString;
         ResultSet resultSet;
 
-        try {
-            connection = DataWarehouse.connectionPool.getConnection();
-        } catch (SQLException e) {
-            e.printStackTrace();
-        }
+        connection = DbManager.getConnection();
 
         if (connection == null) {
             Logger.error("Null connection during char record lookup");
@@ -282,27 +269,6 @@ public class DataWarehouse implements Runnable {
         }
     }
 
-    private static void configureConnectionPool() {
-
-        HikariConfig config = new HikariConfig();
-
-        config.setMaximumPoolSize(10);
-
-        config.setJdbcUrl("jdbc:mysql://" +  ConfigManager.MB_DATABASE_ADDRESS.getValue() +
-                ":" +  ConfigManager.MB_DATABASE_PORT.getValue() + "/" +
-                ConfigManager.MB_DATABASE_NAME.getValue());
-        config.setUsername(ConfigManager.MB_DATABASE_USER.getValue());
-        config.setPassword( ConfigManager.MB_DATABASE_PASS.getValue());
-        config.addDataSourceProperty("characterEncoding", "utf8");
-        config.addDataSourceProperty("cachePrepStmts", "true");
-        config.addDataSourceProperty("prepStmtCacheSize", "250");
-        config.addDataSourceProperty("prepStmtCacheSqlLimit", "2048");
-
-        connectionPool = new HikariDataSource(config); // setup the connection pool
-
-        Logger.info("Local warehouse database connection configured");
-    }
-
     private static void configureRemoteConnectionPool() {
 
         HikariConfig config = new HikariConfig();

src/engine/db/archive/GuildRecord.java

@@ -11,6 +11,7 @@ package engine.db.archive;
 
 import engine.Enum;
 import engine.Enum.RecordEventType;
+import engine.gameManager.DbManager;
 import engine.objects.Guild;
 import engine.workthreads.WarehousePushThread;
 
@@ -164,16 +165,16 @@ public class GuildRecord extends DataRecord {
 
 	public void write() {
 
-		try (Connection connection = DataWarehouse.connectionPool.getConnection();
-				PreparedStatement statement = this.buildGuildInsertStatement(connection)) {
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement statement = this.buildGuildInsertStatement(connection)) {
 
-			statement.execute();
+            statement.execute();
 
-		} catch (SQLException e) {
-			e.printStackTrace();
-		}
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
 
-	}
+    }
 
 	private PreparedStatement buildGuildInsertStatement(Connection connection) throws SQLException {
 

src/engine/db/archive/MineRecord.java

@@ -10,6 +10,7 @@
 package engine.db.archive;
 
 import engine.Enum;
+import engine.gameManager.DbManager;
 import engine.objects.AbstractCharacter;
 import engine.objects.Mine;
 import engine.objects.PlayerCharacter;
@@ -131,7 +132,7 @@ public class MineRecord extends DataRecord {
 
     public void write() {
 
-        try (Connection connection = DataWarehouse.connectionPool.getConnection();
+        try (Connection connection = DbManager.getConnection();
              PreparedStatement statement = this.buildMineInsertStatement(connection)) {
 
             statement.execute();

src/engine/db/archive/PvpRecord.java

@@ -9,6 +9,7 @@
 
 package engine.db.archive;
 
+import engine.gameManager.DbManager;
 import engine.gameManager.ZoneManager;
 import engine.math.Vector3fImmutable;
 import engine.objects.Guild;
@@ -90,19 +91,19 @@ public class PvpRecord extends DataRecord {
 
 		LinkedList<Integer> outList = new LinkedList<>();
 
-		try (Connection connection = DataWarehouse.connectionPool.getConnection();
-				PreparedStatement statement = buildHistoryStatement(connection, charUUID, historyType);
-				ResultSet rs = statement.executeQuery()) {
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement statement = buildHistoryStatement(connection, charUUID, historyType);
+			 ResultSet rs = statement.executeQuery()) {
 
 			while (rs.next()) {
 
 				switch (historyType) {
-				case KILLS:
-					outList.add((int) DataWarehouse.hasher.decrypt(rs.getString("victim_id"))[0]);
-					break;
-				case DEATHS:
-					outList.add((int) DataWarehouse.hasher.decrypt(rs.getString("char_id"))[0]);
-					break;
+					case KILLS:
+						outList.add((int) DataWarehouse.hasher.decrypt(rs.getString("victim_id"))[0]);
+						break;
+					case DEATHS:
+						outList.add((int) DataWarehouse.hasher.decrypt(rs.getString("char_id"))[0]);
+						break;
 				}
 			}
 		} catch (SQLException e) {
@@ -132,9 +133,9 @@ public class PvpRecord extends DataRecord {
 		outString = "[LUA_PVP() DATA WAREHOUSE]" + newLine;
 		dividerString = "--------------------------------" + newLine;
 
-		try (Connection connection = DataWarehouse.connectionPool.getConnection();
-				PreparedStatement statement = buildLuaHistoryQueryStatement(connection, charUUID);
-				ResultSet rs = statement.executeQuery()) {
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement statement = buildLuaHistoryQueryStatement(connection, charUUID);
+			 ResultSet rs = statement.executeQuery()) {
 
 			while (rs.next()) {
 
@@ -293,13 +294,13 @@ public class PvpRecord extends DataRecord {
 
 	public void write() {
 
-		try (Connection connection = DataWarehouse.connectionPool.getConnection();
-				PreparedStatement statement = buildPvPInsertStatement(connection)) {
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement statement = buildPvPInsertStatement(connection)) {
 
 			statement.execute();
 
 		} catch (SQLException e) {
-			Logger.error( e.toString());
+			Logger.error(e.toString());
 		}
 
 		// Warehouse record for this pvp event written if code path reaches here.

src/engine/db/archive/RealmRecord.java

@@ -10,6 +10,7 @@
 package engine.db.archive;
 
 import engine.Enum;
+import engine.gameManager.DbManager;
 import engine.objects.Realm;
 import engine.workthreads.WarehousePushThread;
 
@@ -128,7 +129,7 @@ public class RealmRecord extends DataRecord {
 
     public void write() {
 
-        try (Connection connection = DataWarehouse.connectionPool.getConnection();
+        try (Connection connection = DbManager.getConnection();
              PreparedStatement statement = this.buildRealmInsertStatement(connection)) {
 
             statement.execute();

src/engine/db/handlers/dbAccountHandler.java

@@ -17,206 +17,257 @@ import engine.objects.Account;
 import engine.objects.PlayerCharacter;
 import org.pmw.tinylog.Logger;
 
+import java.sql.Connection;
+import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.ArrayList;
 
 public class dbAccountHandler extends dbHandlerBase {
 
-	public dbAccountHandler() {
-		this.localClass = Account.class;
-		this.localObjectType = Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
-	}
+    public dbAccountHandler() {
+        this.localClass = Account.class;
+        this.localObjectType = Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
+    }
 
-	public Account GET_ACCOUNT(int id) {
-		if (id == 0)
-			return null;
-		Account account = (Account) DbManager.getFromCache(GameObjectType.Account, id);
-		if (account != null)
-			return account;
+    public Account GET_ACCOUNT(int accountID) {
 
-		prepareCallable("SELECT * FROM `obj_account` WHERE `UID`=?");
-		setLong(1, (long) id);
+        Account account;
 
-		Account ac = null;
-		ac = (Account) getObjectSingle(id);
+        if (accountID == 0)
+            return null;
 
-		if (ac != null)
-			ac.runAfterLoad();
+        account = (Account) DbManager.getFromCache(GameObjectType.Account, accountID);
 
-		return ac;
-	}
+        if (account != null)
+            return account;
 
-	public void WRITE_ADMIN_LOG(String adminName, String logEntry) {
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `obj_account` WHERE `UID`=?")) {
 
-		prepareCallable("INSERT INTO dyn_admin_log(`dateTime`, `charName`, `eventString`)"
-				+ " VALUES (?, ?, ?)");
-		setTimeStamp(1, System.currentTimeMillis());
-		setString(2, adminName);
-		setString(3, logEntry);
-		executeUpdate();
+            preparedStatement.setLong(1, accountID);
 
-	}
+            ResultSet rs = preparedStatement.executeQuery();
+            account = (Account) getObjectFromRs(rs);
 
-	public void SET_TRASH(String machineID) {
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
 
-		prepareCallable("INSERT INTO dyn_trash(`machineID`, `count`)"
-				+ " VALUES (?, 1) ON DUPLICATE KEY UPDATE `count` = `count` + 1;");
+        if (account != null)
+            account.runAfterLoad();
 
-		setTimeStamp(4, System.currentTimeMillis());
-		setString(1, machineID);
-		executeUpdate();
+        return account;
+    }
 
-	}
+    public void WRITE_ADMIN_LOG(String adminName, String logEntry) {
 
-	public ArrayList<String> GET_TRASH_LIST() {
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("INSERT INTO dyn_admin_log(`dateTime`, `charName`, `eventString`)"
+                     + " VALUES (?, ?, ?)")) {
 
-		ArrayList<String> machineList = new ArrayList<>();
+            preparedStatement.setTimestamp(1, new java.sql.Timestamp(System.currentTimeMillis()));
+            preparedStatement.setString(2, adminName);
+            preparedStatement.setString(3, logEntry);
 
-		prepareCallable("select `machineID` from `dyn_trash`");
+            preparedStatement.execute();
 
-		try {
-			ResultSet rs = executeQuery();
-			while (rs.next()) {
-				machineList.add(rs.getString(1));
-			}
-		} catch (SQLException e) {
-			Logger.error( e);
-		} finally {
-			closeCallable();
-		}
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+    }
 
-		return machineList;
-	}
+    public void SET_TRASH(String machineID) {
 
-	public boolean DELETE_VAULT_FOR_ACCOUNT(final int accountID) {
-		prepareCallable("DELETE FROM `object` WHERE `parent`=? && `type`='item'");
-		setLong(1, (long) accountID);
-		return (executeUpdate() > 0);
-	}
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("INSERT INTO dyn_trash(`machineID`, `count`)"
+                     + " VALUES (?, 1) ON DUPLICATE KEY UPDATE `count` = `count` + 1;")) {
 
-	public ArrayList<PlayerCharacter> GET_ALL_CHARS_FOR_MACHINE(String machineID) {
+            preparedStatement.setString(1, machineID);
+            preparedStatement.execute();
 
-		ArrayList<PlayerCharacter> trashList = new ArrayList<>();
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+    }
 
-		prepareCallable("select DISTINCT UID from object \n" +
-				"where parent IN (select AccountID from dyn_login_history " +
-		        " WHERE`machineID`=?)");
-		setString(1, machineID);
+    public ArrayList<String> GET_TRASH_LIST() {
 
-		try {
-			ResultSet rs = executeQuery();
-			while (rs.next()) {
+        ArrayList<String> machineList = new ArrayList<>();
 
-				PlayerCharacter trashPlayer;
-				int playerID;
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("select `machineID` from `dyn_trash`")) {
 
-				playerID = rs.getInt(1);
-				trashPlayer = PlayerCharacter.getPlayerCharacter(playerID);
+            ResultSet rs = preparedStatement.executeQuery();
 
-				if (trashPlayer == null)
-					continue;;
+            while (rs.next())
+                machineList.add(rs.getString(1));
 
-				if (trashPlayer.isDeleted() == false)
-					trashList.add(trashPlayer);
-			}
-		} catch (SQLException e) {
-			Logger.error( e);
-		} finally {
-			closeCallable();
-		}
-		return  trashList;
-	}
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return machineList;
+    }
 
-	public void CLEAR_TRASH_TABLE() {
-		prepareCallable("DELETE FROM dyn_trash");
-		executeUpdate();
-	}
+    public void DELETE_VAULT_FOR_ACCOUNT(final int accountID) {
 
-	public void CREATE_SINGLE(String accountName, String password) {
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("DELETE FROM `object` WHERE `parent`=? && `type`='item'")) {
 
-		prepareCallable("CALL singleAccountCreate(?,?)");
-		setString(1, accountName);
-		setString(2, password);
-		executeUpdate();
-	}
+            preparedStatement.setLong(1, accountID);
+            preparedStatement.execute();
 
-	public Account GET_ACCOUNT(String uname) {
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+    }
 
-		if (Account.AccountsMap.get(uname) != null)
-			return this.GET_ACCOUNT(Account.AccountsMap.get(uname));
+    public ArrayList<PlayerCharacter> GET_ALL_CHARS_FOR_MACHINE(String machineID) {
 
-		prepareCallable("SELECT * FROM `obj_account` WHERE `acct_uname`=?");
-		setString(1, uname);
-		ArrayList<Account> temp = getObjectList();
+        ArrayList<PlayerCharacter> trashList = new ArrayList<>();
 
-		if (temp.isEmpty())
-			return null;
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("select DISTINCT UID from object \n" +
+                     "where parent IN (select AccountID from dyn_login_history " +
+                     " WHERE`machineID`=?)")) {
 
-		if (temp.get(0) != null){
-			temp.get(0).runAfterLoad();
+            preparedStatement.setString(1, machineID);
+            ResultSet rs = preparedStatement.executeQuery();
 
-			if (ConfigManager.serverType.equals(Enum.ServerType.LOGINSERVER))
-				Account.AccountsMap.put(uname, temp.get(0).getObjectUUID());
+            while (rs.next()) {
 
-		}
-		return temp.get(0);
-	}
+                PlayerCharacter trashPlayer;
+                int playerID;
 
-	public void SET_ACCOUNT_LOGIN(final Account acc, String playerName, final String ip, final String machineID) {
+                playerID = rs.getInt(1);
+                trashPlayer = PlayerCharacter.getPlayerCharacter(playerID);
 
-		if (acc.getObjectUUID() == 0 || ip == null || ip.length() == 0)
-			return;
+                if (trashPlayer == null)
+                    continue;
 
-		prepareCallable("INSERT INTO dyn_login_history(`AccountID`, `accountName`, `characterName`, `ip`, `machineID`, `timeStamp`)"
-				+ " VALUES (?, ?, ?, ?, ?, ?)");
+                if (trashPlayer.isDeleted() == false)
+                    trashList.add(trashPlayer);
+            }
 
-		setInt(1, acc.getObjectUUID());
-		setString(2, acc.getUname());
-		setString(3, playerName);
-		setString(4, ip);
-		setString(5, machineID);
-		setTimeStamp(6, System.currentTimeMillis());
-		executeUpdate();
-	}
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return trashList;
+    }
 
-	public String SET_PROPERTY(final Account a, String name, Object new_value) {
-		prepareCallable("CALL account_SETPROP(?,?,?)");
-		setLong(1, (long) a.getObjectUUID());
-		setString(2, name);
-		setString(3, String.valueOf(new_value));
-		return getResult();
-	}
+    public void CLEAR_TRASH_TABLE() {
 
-	public String SET_PROPERTY(final Account a, String name, Object new_value, Object old_value) {
-		prepareCallable("CALL account_GETSETPROP(?,?,?,?)");
-		setLong(1, (long) a.getObjectUUID());
-		setString(2, name);
-		setString(3, String.valueOf(new_value));
-		setString(4, String.valueOf(old_value));
-		return getResult();
-	}
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("DELETE FROM dyn_trash")) {
 
+            preparedStatement.execute();
 
-	public void updateDatabase(final Account acc) {
-		prepareCallable("UPDATE `obj_account` SET `acct_passwd`=?, "
-				+ " `acct_lastCharUID`=?, `acct_salt`=?, `discordAccount`=?, " +
-				" status = ? WHERE `UID`=?");
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+    }
 
-		setString(1, acc.getPasswd());
-		setInt(2, acc.getLastCharIDUsed());
-		setString(3, acc.getSalt());
-		setString(4, acc.discordAccount);
-		setString(5, acc.status.name());
-		setInt(6, acc.getObjectUUID());
-		executeUpdate();
-	}
+    public void CREATE_SINGLE(String accountName, String password) {
 
-	public void INVALIDATE_LOGIN_CACHE(long accountUID, String objectType) {
-		prepareCallable("INSERT IGNORE INTO login_cachelist (`UID`, `type`) VALUES(?,?);");
-		setLong(1, accountUID);
-		setString(2, objectType);
-		executeUpdate();
-	}
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("CALL singleAccountCreate(?,?)")) {
+
+            preparedStatement.setString(1, accountName);
+            preparedStatement.setString(2, password);
+
+            preparedStatement.execute();
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+    }
+
+    public Account GET_ACCOUNT(String uname) {
+
+        Account account = null;
+
+        if (Account.AccountsMap.get(uname) != null)
+            return this.GET_ACCOUNT(Account.AccountsMap.get(uname));
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `obj_account` WHERE `acct_uname`=?")) {
+
+            preparedStatement.setString(1, uname);
+
+            ResultSet rs = preparedStatement.executeQuery();
+            account = (Account) getObjectFromRs(rs);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+
+        if (account != null) {
+            account.runAfterLoad();
+
+            if (ConfigManager.serverType.equals(Enum.ServerType.LOGINSERVER))
+                Account.AccountsMap.put(uname, account.getObjectUUID());
+
+        }
+        return account;
+    }
+
+    public void SET_ACCOUNT_LOGIN(final Account acc, String playerName, final String ip, final String machineID) {
+
+        if (acc.getObjectUUID() == 0 || ip == null || ip.length() == 0)
+            return;
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("INSERT INTO dyn_login_history(`AccountID`, `accountName`, `characterName`, `ip`, `machineID`, `timeStamp`)"
+                     + " VALUES (?, ?, ?, ?, ?, ?)")) {
+
+            preparedStatement.setInt(1, acc.getObjectUUID());
+            preparedStatement.setString(2, acc.getUname());
+            preparedStatement.setString(3, playerName);
+            preparedStatement.setString(4, ip);
+            preparedStatement.setString(5, machineID);
+            preparedStatement.setTimestamp(6, new java.sql.Timestamp(System.currentTimeMillis()));
+
+            preparedStatement.execute();
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+    }
+
+    public void updateDatabase(final Account acc) {
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_account` SET `acct_passwd`=?, "
+                     + " `acct_lastCharUID`=?, `acct_salt`=?, `discordAccount`=?, " +
+                     " status = ? WHERE `UID`=?")) {
+
+            preparedStatement.setString(1, acc.getPasswd());
+            preparedStatement.setInt(2, acc.getLastCharIDUsed());
+            preparedStatement.setString(3, acc.getSalt());
+            preparedStatement.setString(4, acc.discordAccount);
+            preparedStatement.setString(5, acc.status.name());
+            preparedStatement.setInt(6, acc.getObjectUUID());
+
+            preparedStatement.execute();
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+    }
+
+    public void INVALIDATE_LOGIN_CACHE(long accountUID, String objectType) {
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("INSERT IGNORE INTO login_cachelist (`UID`, `type`) VALUES(?,?);")) {
+
+            preparedStatement.setLong(1, accountUID);
+            preparedStatement.setString(2, objectType);
+
+            preparedStatement.execute();
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+    }
 
 }

src/engine/db/handlers/dbBaneHandler.java

@@ -9,6 +9,7 @@
 
 package engine.db.handlers;
 
+import engine.gameManager.DbManager;
 import engine.objects.Bane;
 import engine.objects.Building;
 import engine.objects.City;
@@ -16,10 +17,10 @@ import engine.objects.PlayerCharacter;
 import org.joda.time.DateTime;
 import org.pmw.tinylog.Logger;
 
+import java.sql.Connection;
+import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.logging.Level;
 
 public class dbBaneHandler extends dbHandlerBase {
 
@@ -29,78 +30,63 @@ public class dbBaneHandler extends dbHandlerBase {
 
     public boolean CREATE_BANE(City city, PlayerCharacter owner, Building stone) {
 
-        prepareCallable("INSERT INTO `dyn_banes` (`cityUUID`, `ownerUUID`, `stoneUUID`, `placementDate`) VALUES(?,?,?,?)");
-        setLong(1, (long) city.getObjectUUID());
-        setLong(2, (long) owner.getObjectUUID());
-        setLong(3, (long) stone.getObjectUUID());
-        setTimeStamp(4, System.currentTimeMillis());
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("INSERT INTO `dyn_banes` (`cityUUID`, `ownerUUID`, `stoneUUID`, `placementDate`) VALUES(?,?,?,?)")) {
 
-        return (executeUpdate() > 0);
+            preparedStatement.setLong(1, city.getObjectUUID());
+            preparedStatement.setLong(2, owner.getObjectUUID());
+            preparedStatement.setLong(3, stone.getObjectUUID());
+            preparedStatement.setTimestamp(4, new java.sql.Timestamp(System.currentTimeMillis()));
 
+            preparedStatement.execute();
+
+        } catch (SQLException e) {
+            Logger.error(e);
+            return false;
+        }
+
+        return true;
     }
 
     public Bane LOAD_BANE(int cityUUID) {
 
-        Bane newBane = null;
+        Bane bane = null;
 
-        try {
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * from dyn_banes WHERE `dyn_banes`.`cityUUID` = ?")) {
 
-            prepareCallable("SELECT * from dyn_banes WHERE `dyn_banes`.`cityUUID` = ?");
-
-            setLong(1, (long) cityUUID);
-            ResultSet rs = executeQuery();
+            preparedStatement.setLong(1, cityUUID);
+            ResultSet rs = preparedStatement.executeQuery();
 
             if (rs.next()) {
-                newBane = new Bane(rs);
-                Bane.addBane(newBane);
+                bane = new Bane(rs);
+                Bane.addBane(bane);
             }
 
-        } catch (SQLException ex) {
-            java.util.logging.Logger.getLogger(dbBaneHandler.class.getName()).log(Level.SEVERE, null, ex);
-        } finally {
-            closeCallable();
-        }
-        return newBane;
-
-    }
-
-    public ConcurrentHashMap<Integer, Bane> LOAD_ALL_BANES() {
-
-        ConcurrentHashMap<Integer, Bane> baneList;
-        Bane thisBane;
-
-        baneList = new ConcurrentHashMap<>();
-
-        int recordsRead = 0;
-
-        prepareCallable("SELECT * FROM dyn_banes");
-
-        try {
-            ResultSet rs = executeQuery();
-
-            while (rs.next()) {
-
-                recordsRead++;
-                thisBane = new Bane(rs);
-                baneList.put(thisBane.getCityUUID(), thisBane);
-
-            }
-
-            Logger.info("read: " + recordsRead + " cached: " + baneList.size());
-
         } catch (SQLException e) {
-            Logger.error( e.toString());
-        } finally {
-            closeCallable();
+            Logger.error(e);
         }
-        return baneList;
+
+        return bane;
     }
 
+
     public boolean SET_BANE_TIME(DateTime toSet, int cityUUID) {
-        prepareCallable("UPDATE `dyn_banes` SET `liveDate`=? WHERE `cityUUID`=?");
-        setTimeStamp(1, toSet.getMillis());
-        setLong(2, cityUUID);
-        return (executeUpdate() > 0);
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `dyn_banes` SET `liveDate`=? WHERE `cityUUID`=?")) {
+
+            preparedStatement.setTimestamp(1, new java.sql.Timestamp(toSet.getMillis()));
+            preparedStatement.setLong(2, cityUUID);
+
+            preparedStatement.execute();
+
+        } catch (SQLException e) {
+            Logger.error(e);
+            return false;
+        }
+
+        return true;
     }
 
     public boolean REMOVE_BANE(Bane bane) {
@@ -108,8 +94,17 @@ public class dbBaneHandler extends dbHandlerBase {
         if (bane == null)
             return false;
 
-        prepareCallable("DELETE FROM `dyn_banes` WHERE `cityUUID` = ?");
-        setLong(1, (long) bane.getCity().getObjectUUID());
-        return (executeUpdate() > 0);
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("DELETE FROM `dyn_banes` WHERE `cityUUID` = ?")) {
+
+            preparedStatement.setLong(1, bane.getCity().getObjectUUID());
+            preparedStatement.execute();
+
+        } catch (SQLException e) {
+            Logger.error(e);
+            return false;
+        }
+
+        return true;
     }
 }

src/engine/db/handlers/dbBaseClassHandler.java

@@ -13,38 +13,79 @@ import engine.Enum;
 import engine.Enum.GameObjectType;
 import engine.gameManager.DbManager;
 import engine.objects.BaseClass;
+import org.pmw.tinylog.Logger;
 
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
 import java.util.ArrayList;
 
 public class dbBaseClassHandler extends dbHandlerBase {
 
-	public dbBaseClassHandler() {
-		this.localClass = BaseClass.class;
-		this.localObjectType = Enum.GameObjectType.BaseClass;
-	}
+    public dbBaseClassHandler() {
+        this.localClass = BaseClass.class;
+        this.localObjectType = Enum.GameObjectType.BaseClass;
+    }
 
-	public BaseClass GET_BASE_CLASS(final int id) {
+    public BaseClass GET_BASE_CLASS(final int id) {
 
-		if (id == 0)
-			return null;
-		BaseClass baseClass = (BaseClass) DbManager.getFromCache(GameObjectType.BaseClass, id);
-		if (baseClass != null)
-			return baseClass;
+        if (id == 0)
+            return null;
 
+        BaseClass baseClass = (BaseClass) DbManager.getFromCache(GameObjectType.BaseClass, id);
 
-		prepareCallable("SELECT * FROM `static_rune_baseclass` WHERE `ID` = ?;");
-		setInt(1, id);
-		return (BaseClass) getObjectSingle(id);
-	}
+        if (baseClass != null)
+            return baseClass;
 
-	public ArrayList<BaseClass> GET_BASECLASS_FOR_RACE(final int id) {
-		prepareCallable("SELECT b.* FROM `static_rune_baseclass` b, `static_rune_racebaseclass` r WHERE b.`ID` = r.`BaseClassID` && r.`RaceID` = ?");
-		setInt(1, id);
-		return getObjectList();
-	}
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `obj_account` WHERE `UID`=?")) {
 
-	public ArrayList<BaseClass> GET_ALL_BASE_CLASSES(){
-		prepareCallable("SELECT * FROM `static_rune_baseclass`;");
-		return  getObjectList();
-	}
+            preparedStatement.setLong(1, id);
+
+            ResultSet rs = preparedStatement.executeQuery();
+            baseClass = (BaseClass) getObjectFromRs(rs);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+
+        return baseClass;
+    }
+
+    public ArrayList<BaseClass> GET_BASECLASS_FOR_RACE(final int id) {
+
+        ArrayList<BaseClass> baseClasses = new ArrayList<>();
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT b.* FROM `static_rune_baseclass` b, `static_rune_racebaseclass` r WHERE b.`ID` = r.`BaseClassID` && r.`RaceID` = ?")) {
+
+            preparedStatement.setInt(1, id);
+
+            ResultSet rs = preparedStatement.executeQuery();
+            baseClasses = getObjectsFromRs(rs, 20);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+
+        return baseClasses;
+    }
+
+    public ArrayList<BaseClass> GET_ALL_BASE_CLASSES() {
+
+        ArrayList<BaseClass> baseClasses = new ArrayList<>();
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `static_rune_baseclass`;")) {
+
+            ResultSet rs = preparedStatement.executeQuery();
+            baseClasses = getObjectsFromRs(rs, 20);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+
+        return baseClasses;
+    }
 }

src/engine/db/handlers/dbBlueprintHandler.java

@@ -1,8 +1,11 @@
 package engine.db.handlers;
 
+import engine.gameManager.DbManager;
 import engine.objects.Blueprint;
 import org.pmw.tinylog.Logger;
 
+import java.sql.Connection;
+import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.HashMap;
@@ -22,10 +25,10 @@ public class dbBlueprintHandler extends dbHandlerBase {
         int doorNum;
         int recordsRead = 0;
 
-        prepareCallable("SELECT * FROM static_building_doors ORDER BY doorMeshUUID ASC");
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM static_building_doors ORDER BY doorMeshUUID ASC")) {
 
-        try {
-            ResultSet rs = executeQuery();
+            ResultSet rs = preparedStatement.executeQuery();
 
             while (rs.next()) {
 
@@ -35,13 +38,11 @@ public class dbBlueprintHandler extends dbHandlerBase {
                 doorInfo.put(doorUUID, doorNum);
             }
 
-            Logger.info( "read: " + recordsRead + " cached: " + doorInfo.size());
-
         } catch (SQLException e) {
-            Logger.error("LoadAllDoorNumbers: " + e.getErrorCode() + ' ' + e.getMessage(), e);
-        } finally {
-            closeCallable();
+            Logger.error(e);
         }
+
+        Logger.info("read: " + recordsRead + " cached: " + doorInfo.size());
         return doorInfo;
     }
 
@@ -53,10 +54,10 @@ public class dbBlueprintHandler extends dbHandlerBase {
         blueprints = new HashMap<>();
         int recordsRead = 0;
 
-        prepareCallable("SELECT * FROM static_building_blueprint");
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM static_building_blueprint")) {
 
-        try {
-            ResultSet rs = executeQuery();
+            ResultSet rs = preparedStatement.executeQuery();
 
             while (rs.next()) {
 
@@ -74,13 +75,11 @@ public class dbBlueprintHandler extends dbHandlerBase {
 
             }
 
-            Logger.info( "read: " + recordsRead + " cached: " + blueprints.size());
-
         } catch (SQLException e) {
-            Logger.error("LoadAllBlueprints: " + e.getErrorCode() + ' ' + e.getMessage(), e);
-        } finally {
-            closeCallable();
+            Logger.error(e);
         }
+
+        Logger.info("read: " + recordsRead + " cached: " + blueprints.size());
         return blueprints;
     }
 }

src/engine/db/handlers/dbBoonHandler.java

@@ -9,9 +9,12 @@
 
 package engine.db.handlers;
 
+import engine.gameManager.DbManager;
 import engine.objects.Boon;
 import org.pmw.tinylog.Logger;
 
+import java.sql.Connection;
+import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.ArrayList;
@@ -20,32 +23,29 @@ public class dbBoonHandler extends dbHandlerBase {
 
 	public dbBoonHandler() {
 	}
-	
 
-	public ArrayList<Boon>  GET_BOON_AMOUNTS_FOR_ITEMBASEUUID(int itemBaseUUID){
-        
-        ArrayList<Boon>boons = new ArrayList<>();
-        Boon thisBoon;
-        prepareCallable("SELECT * FROM `static_item_boons`  WHERE `itemBaseID` = ?");
-        setInt(1, itemBaseUUID);
 
-	try {
-		ResultSet rs = executeQuery();
-                    
-		while (rs.next()) {
-                        
-                     
-                      thisBoon = new Boon(rs);
-                      boons.add(thisBoon);
+	public ArrayList<Boon> GET_BOON_AMOUNTS_FOR_ITEMBASE(int itemBaseUUID) {
+
+		ArrayList<Boon> boons = new ArrayList<>();
+		Boon thisBoon;
+
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `static_item_boons`  WHERE `itemBaseID` = ?")) {
+
+			preparedStatement.setInt(1, itemBaseUUID);
+
+			ResultSet rs = preparedStatement.executeQuery();
+
+			while (rs.next()) {
+				thisBoon = new Boon(rs);
+				boons.add(thisBoon);
+			}
+
+		} catch (SQLException e) {
+			Logger.error(e);
 		}
-                    
-  
-                            
-	} catch (SQLException e) {
-		Logger.error("GetBoonAmountsForItembaseUUID: " + e.getErrorCode() + ' ' + e.getMessage(), e);
-	} finally {
-		closeCallable();
+
+		return boons;
 	}
-	return boons;
-}
 }

src/engine/db/handlers/dbBuildingLocationHandler.java

@@ -9,28 +9,41 @@
 
 package engine.db.handlers;
 
+import engine.gameManager.DbManager;
 import engine.objects.BuildingLocation;
+import org.pmw.tinylog.Logger;
 
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
 import java.util.ArrayList;
 
 public class dbBuildingLocationHandler extends dbHandlerBase {
 
-	public dbBuildingLocationHandler() {
-		this.localClass = BuildingLocation.class;
+    public dbBuildingLocationHandler() {
+        this.localClass = BuildingLocation.class;
         this.localObjectType = engine.Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
-	}
+    }
 
-	public ArrayList<BuildingLocation> LOAD_BUILDING_LOCATIONS() {
-		prepareCallable("select * from static_building_location " +
-				"where type = 6 or type = 8 " +
-				"GROUP BY buildingID, slot " +
-				"ORDER BY buildingID, slot ASC;");
-		return getObjectList();
-	}
+    public ArrayList<BuildingLocation> LOAD_BUILDING_LOCATIONS() {
 
-	public ArrayList<BuildingLocation> LOAD_ALL_BUILDING_LOCATIONS() {
-		prepareCallable("SELECT * FROM `static_building_location`;");
-		return getObjectList();
-	}
+        ArrayList<BuildingLocation> buildingLocations = new ArrayList<>();
 
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("select * from static_building_location " +
+                     "where type = 6 or type = 8 " +
+                     "GROUP BY buildingID, slot " +
+                     "ORDER BY buildingID, slot ASC;")) {
+
+            ResultSet rs = preparedStatement.executeQuery();
+            buildingLocations = getObjectsFromRs(rs, 20);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+            return buildingLocations;
+        }
+
+        return buildingLocations;
+    }
 }

src/engine/db/handlers/dbCSSessionHandler.java

@@ -17,6 +17,8 @@ import engine.util.StringUtils;
 import org.pmw.tinylog.Logger;
 
 import java.net.InetAddress;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 
@@ -28,73 +30,85 @@ public class dbCSSessionHandler extends dbHandlerBase {
 	}
 
 	public boolean ADD_CSSESSION(String secKey, Account acc, InetAddress inet, String machineID) {
-        prepareCallable("INSERT INTO `dyn_session` (`secretKey`, `accountID`, `discordAccount`, `sessionIP`, machineID) VALUES (?,?,?,INET_ATON(?),?)");
-        setString(1, secKey);
-		setLong(2, acc.getObjectUUID());
-		setString(3, acc.discordAccount);
-        setString(4, StringUtils.InetAddressToClientString(inet));
-        setString(5, machineID);
-        return (executeUpdate() != 0);
-    }
-	// This method returns population metrics from the database
 
-	public String GET_POPULATION_STRING() {
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("INSERT INTO `dyn_session` (`secretKey`, `accountID`, `discordAccount`, `sessionIP`, machineID) VALUES (?,?,?,INET_ATON(?),?)")) {
 
-		String outString = null;
+			preparedStatement.setString(1, secKey);
+			preparedStatement.setLong(2, acc.getObjectUUID());
+			preparedStatement.setString(3, acc.discordAccount);
+			preparedStatement.setString(4, StringUtils.InetAddressToClientString(inet));
+			preparedStatement.setString(5, machineID);
 
-		// Set up call to stored procedure
-		prepareCallable("CALL GET_POPULATION_STRING()");
+			return (preparedStatement.executeUpdate() > 0);
 
-		try {
-
-			// Evaluate database ordinal and return enum
-			outString = getString("popstring");
-
-		} catch (Exception e) {
-			Logger.error( "Failure in stored procedure:" + e.getMessage());
-		} finally {
-			closeCallable();
+		} catch (SQLException e) {
+			Logger.error(e);
 		}
-		return outString;
+		return false;
 	}
 
 	public boolean DELETE_UNUSED_CSSESSION(String secKey) {
-		prepareCallable("DELETE FROM `dyn_session` WHERE `secretKey`=? && `characterID` IS NULL");
-		setString(1, secKey);
-		return (executeUpdate() != 0);
+
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("DELETE FROM `dyn_session` WHERE `secretKey`=? && `characterID` IS NULL")) {
+
+			preparedStatement.setString(1, secKey);
+			return (preparedStatement.executeUpdate() > 0);
+
+		} catch (SQLException e) {
+			Logger.error(e);
+		}
+		return false;
 	}
 
 	public boolean DELETE_CSSESSION(String secKey) {
-		prepareCallable("DELETE FROM `dyn_session` WHERE `secretKey`=?");
-		setString(1, secKey);
-		return (executeUpdate() != 0);
+
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("DELETE FROM `dyn_session` WHERE `secretKey`=?")) {
+
+			preparedStatement.setString(1, secKey);
+			return (preparedStatement.executeUpdate() > 0);
+
+		} catch (SQLException e) {
+			Logger.error(e);
+		}
+		return false;
 	}
 
 	public boolean UPDATE_CSSESSION(String secKey, int charID) {
-		prepareCallable("UPDATE `dyn_session` SET `characterID`=? WHERE `secretKey`=?");
-		setInt(1, charID);
-		setString(2, secKey);
-		return (executeUpdate() != 0);
+
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `dyn_session` SET `characterID`=? WHERE `secretKey`=?")) {
+
+			preparedStatement.setInt(1, charID);
+			preparedStatement.setString(2, secKey);
+
+			return (preparedStatement.executeUpdate() > 0);
+
+		} catch (SQLException e) {
+			Logger.error(e);
+		}
+		return false;
 	}
 
 	public CSSession GET_CSSESSION(String secKey) {
+
 		CSSession css = null;
-		prepareCallable("SELECT `accountID`, `characterID`, `machineID` FROM `dyn_session` WHERE `secretKey`=?");
-		setString(1, secKey);
-		try {
 
-			ResultSet rs = executeQuery();
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("SELECT `accountID`, `characterID`, `machineID` FROM `dyn_session` WHERE `secretKey`=?")) {
+
+			preparedStatement.setString(1, secKey);
+			ResultSet rs = preparedStatement.executeQuery();
+
+			if (rs.next())
+				css = new CSSession(secKey, DbManager.AccountQueries.GET_ACCOUNT(rs.getInt("accountID")), PlayerCharacter.getPlayerCharacter(rs.getInt("characterID")), rs.getString("machineID"));
 
-			if (rs.next()) {
-				css = new CSSession(secKey, DbManager.AccountQueries.GET_ACCOUNT(rs.getInt("accountID")), PlayerCharacter.getPlayerCharacter(rs
-						.getInt("characterID")), getString("machineID"));
-			}
-			rs.close();
 		} catch (SQLException e) {
-			Logger.error("Error with seckey: " + secKey);
-		} finally {
-			closeCallable();
+			Logger.error(e);
 		}
+
 		return css;
 	}
 }

src/engine/db/handlers/dbCharacterPowerHandler.java

@@ -16,98 +16,154 @@ import engine.objects.PlayerCharacter;
 import engine.server.MBServerStatics;
 import org.pmw.tinylog.Logger;
 
-import java.sql.ResultSet;
-import java.sql.SQLException;
+import java.sql.*;
 import java.util.concurrent.ConcurrentHashMap;
 
 public class dbCharacterPowerHandler extends dbHandlerBase {
 
-	public dbCharacterPowerHandler() {
-		this.localClass = CharacterPower.class;
-		this.localObjectType = Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
-	}
+    public dbCharacterPowerHandler() {
+        this.localClass = CharacterPower.class;
+        this.localObjectType = Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
+    }
 
-	public CharacterPower ADD_CHARACTER_POWER(CharacterPower toAdd) {
-		if (CharacterPower.getOwner(toAdd) == null || toAdd.getPower() == null) {
-			Logger.error("dbCharacterSkillHandler.ADD_Power", toAdd.getObjectUUID() + " missing owner or powersBase");
-			return null;
-		}
+    public CharacterPower ADD_CHARACTER_POWER(CharacterPower toAdd) {
 
-		prepareCallable("INSERT INTO `dyn_character_power` (`CharacterID`, `powersBaseToken`, `trains`) VALUES (?, ?, ?);");
-		setLong(1, (long)CharacterPower.getOwner(toAdd).getObjectUUID());
-		setInt(2, toAdd.getPower().getToken());
-		setInt(3, toAdd.getTrains());
-		int powerID = insertGetUUID();
-		return GET_CHARACTER_POWER(powerID);
+        CharacterPower characterPower = null;
 
-	}
+        if (CharacterPower.getOwner(toAdd) == null || toAdd.getPower() == null) {
+            Logger.error("dbCharacterSkillHandler.ADD_Power", toAdd.getObjectUUID() + " missing owner or powersBase");
+            return null;
+        }
 
-	public int DELETE_CHARACTER_POWER(final int objectUUID) {
-		prepareCallable("DELETE FROM `dyn_character_power` WHERE `UID` = ?");
-		setLong(1, (long)objectUUID);
-		return executeUpdate();
-	}
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("INSERT INTO `dyn_character_power` (`CharacterID`, `powersBaseToken`, `trains`) VALUES (?, ?, ?);", Statement.RETURN_GENERATED_KEYS)) {
 
-	public CharacterPower GET_CHARACTER_POWER(int objectUUID) {
+            preparedStatement.setLong(1, CharacterPower.getOwner(toAdd).getObjectUUID());
+            preparedStatement.setInt(2, toAdd.getPower().getToken());
+            preparedStatement.setInt(3, toAdd.getTrains());
 
-		CharacterPower cp = (CharacterPower) DbManager.getFromCache(Enum.GameObjectType.CharacterPower, objectUUID);
-		if (cp != null)
-			return cp;
-		prepareCallable("SELECT * FROM `dyn_character_power` WHERE `UID` = ?");
-		setLong(1, (long)objectUUID);
-		return (CharacterPower) getObjectSingle(objectUUID);
-	}
+            preparedStatement.executeUpdate();
+            ResultSet rs = preparedStatement.getGeneratedKeys();
 
-	public ConcurrentHashMap<Integer, CharacterPower> GET_POWERS_FOR_CHARACTER(PlayerCharacter pc) {
-		ConcurrentHashMap<Integer, CharacterPower> powers = new ConcurrentHashMap<>(MBServerStatics.CHM_INIT_CAP, MBServerStatics.CHM_LOAD, MBServerStatics.CHM_THREAD_LOW);
-		int objectUUID = pc.getObjectUUID();
-		prepareCallable("SELECT * FROM `dyn_character_power` WHERE CharacterID = ?");
-		setLong(1, (long)objectUUID);
-		ResultSet rs = executeQuery();
-		try {
-			while (rs.next()) {
-				CharacterPower cp = new CharacterPower(rs, pc);
-				if (cp.getPower() != null)
-					powers.put(cp.getPower().getToken(), cp);
-			}
-			rs.close();
-		} catch (SQLException e) {
-			Logger.error("CharacterPower.getCharacterPowerForCharacter", "Exception:" + e.getMessage());
-		} finally {
-			closeCallable();
-		}
-		return powers;
-	}
+            if (rs.next())
+                characterPower = GET_CHARACTER_POWER(rs.getInt(1));
 
-	public void UPDATE_TRAINS(final CharacterPower pow) {
-		//skip update if nothing changed
-		if (!pow.isTrained())
-			return;
+        } catch (SQLException e) {
+            Logger.error(e);
+            return null;
+        }
+        return characterPower;
+    }
 
-		prepareCallable("UPDATE `dyn_character_power` SET `trains`=? WHERE `UID`=?");
-		setShort(1, (short)pow.getTrains());
-		setInt(2, pow.getObjectUUID());
-		executeUpdate();
-		pow.setTrained(false);
-	}
+    public int DELETE_CHARACTER_POWER(final int objectUUID) {
 
-	public void updateDatabase(final CharacterPower pow) {
-		if (pow.getPower() == null) {
-			Logger.error( "Failed to find powersBase for Power " + pow.getObjectUUID());
-			return;
-		}
-		if (CharacterPower.getOwner(pow) == null) {
-			Logger.error( "Failed to find owner for Power " + pow.getObjectUUID());
-			return;
-		}
+        int rowCount = 0;
 
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("DELETE FROM `dyn_character_power` WHERE `UID` = ?")) {
 
-		prepareCallable("UPDATE `dyn_character_power` SET `PowersBaseToken`=?, `CharacterID`=?, `trains`=? WHERE `UID`=?");
-		setInt(1, pow.getPower().getToken());
-		setInt(2, CharacterPower.getOwner(pow).getObjectUUID());
-		setShort(3, (short)pow.getTrains());
-		setInt(4, pow.getObjectUUID());
-		executeUpdate();
-		pow.setTrained(false);
-	}
+            preparedStatement.setLong(1, objectUUID);
+            rowCount = preparedStatement.executeUpdate();
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+
+        return rowCount;
+    }
+
+    public CharacterPower GET_CHARACTER_POWER(int objectUUID) {
+
+        CharacterPower characterPower = (CharacterPower) DbManager.getFromCache(Enum.GameObjectType.CharacterPower, objectUUID);
+
+        if (characterPower != null)
+            return characterPower;
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `dyn_character_power` WHERE `UID` = ?")) {
+
+            preparedStatement.setLong(1, objectUUID);
+            ResultSet rs = preparedStatement.executeQuery();
+            characterPower = (CharacterPower) getObjectFromRs(rs);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+
+        return characterPower;
+    }
+
+    public ConcurrentHashMap<Integer, CharacterPower> GET_POWERS_FOR_CHARACTER(PlayerCharacter pc) {
+
+        ConcurrentHashMap<Integer, CharacterPower> powers = new ConcurrentHashMap<>(MBServerStatics.CHM_INIT_CAP, MBServerStatics.CHM_LOAD, MBServerStatics.CHM_THREAD_LOW);
+        int objectUUID = pc.getObjectUUID();
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `dyn_character_power` WHERE CharacterID = ?")) {
+
+            preparedStatement.setLong(1, objectUUID);
+            ResultSet rs = preparedStatement.executeQuery();
+
+            while (rs.next()) {
+                CharacterPower cp = new CharacterPower(rs, pc);
+                if (cp.getPower() != null)
+                    powers.put(cp.getPower().getToken(), cp);
+            }
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+
+        return powers;
+    }
+
+    public void UPDATE_TRAINS(final CharacterPower characterPower) {
+
+        //skip update if nothing changed
+
+        if (!characterPower.isTrained())
+            return;
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `dyn_character_power` SET `trains`=? WHERE `UID`=?")) {
+
+            preparedStatement.setShort(1, (short) characterPower.getTrains());
+            preparedStatement.setInt(2, characterPower.getObjectUUID());
+
+            preparedStatement.execute();
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+
+        characterPower.setTrained(false);
+    }
+
+    public void updateDatabase(final CharacterPower pow) {
+
+        if (pow.getPower() == null) {
+            Logger.error("Failed to find powersBase for Power " + pow.getObjectUUID());
+            return;
+        }
+
+        if (CharacterPower.getOwner(pow) == null) {
+            Logger.error("Failed to find owner for Power " + pow.getObjectUUID());
+            return;
+        }
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `dyn_character_power` SET `PowersBaseToken`=?, `CharacterID`=?, `trains`=? WHERE `UID`=?")) {
+
+            preparedStatement.setInt(1, pow.getPower().getToken());
+            preparedStatement.setInt(2, CharacterPower.getOwner(pow).getObjectUUID());
+            preparedStatement.setShort(3, (short) pow.getTrains());
+            preparedStatement.setInt(4, pow.getObjectUUID());
+            preparedStatement.execute();
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+
+        pow.setTrained(false);
+    }
 }

src/engine/db/handlers/dbCharacterRuneHandler.java

@@ -12,52 +12,110 @@ package engine.db.handlers;
 import engine.Enum;
 import engine.gameManager.DbManager;
 import engine.objects.CharacterRune;
+import org.pmw.tinylog.Logger;
 
+import java.sql.*;
 import java.util.ArrayList;
 
 public class dbCharacterRuneHandler extends dbHandlerBase {
 
-	public dbCharacterRuneHandler() {
-		this.localClass = CharacterRune.class;
-		this.localObjectType = Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
-	}
+    public dbCharacterRuneHandler() {
+        this.localClass = CharacterRune.class;
+        this.localObjectType = Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
+    }
 
-	public CharacterRune ADD_CHARACTER_RUNE(final CharacterRune toAdd) {
-		prepareCallable("INSERT INTO `dyn_character_rune` (`CharacterID`, `RuneBaseID`) VALUES (?, ?);");
-		setLong(1, (long)toAdd.getPlayerID());
-		setInt(2, toAdd.getRuneBaseID());
-		int runeID = insertGetUUID();
-		return GET_CHARACTER_RUNE(runeID);
-	}
+    public CharacterRune ADD_CHARACTER_RUNE(final CharacterRune toAdd) {
 
-	public CharacterRune GET_CHARACTER_RUNE(int runeID) {
+        CharacterRune characterRune = null;
 
-		CharacterRune charRune = (CharacterRune) DbManager.getFromCache(Enum.GameObjectType.CharacterRune, runeID);
-		if (charRune != null)
-			return charRune;
-		prepareCallable("SELECT * FROM `dyn_character_rune` WHERE `UID`=?");
-		setInt(1, runeID);
-		return (CharacterRune) getObjectSingle(runeID);
-	}
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("INSERT INTO `dyn_character_rune` (`CharacterID`, `RuneBaseID`) VALUES (?, ?);", Statement.RETURN_GENERATED_KEYS)) {
 
+            preparedStatement.setLong(1, toAdd.getPlayerID());
+            preparedStatement.setInt(2, toAdd.getRuneBaseID());
 
-	public boolean DELETE_CHARACTER_RUNE(final CharacterRune cr) {
-		prepareCallable("DELETE FROM `dyn_character_rune` WHERE `UID`=?;");
-		setLong(1, (long)cr.getObjectUUID());
-		return (executeUpdate() != 0);
-	}
+            preparedStatement.executeUpdate();
+            ResultSet rs = preparedStatement.getGeneratedKeys();
 
-	public ArrayList<CharacterRune> GET_RUNES_FOR_CHARACTER(final int characterId) {
-		prepareCallable("SELECT * FROM `dyn_character_rune` WHERE `CharacterID` = ?");
-		setInt(1, characterId);
-		return getObjectList();
-	}
+            if (rs.next())
+                characterRune = GET_CHARACTER_RUNE(rs.getInt(1));
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+
+        return characterRune;
+    }
+
+    public CharacterRune GET_CHARACTER_RUNE(int runeID) {
+
+        CharacterRune characterRune = (CharacterRune) DbManager.getFromCache(Enum.GameObjectType.CharacterRune, runeID);
+
+        if (characterRune != null)
+            return characterRune;
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `dyn_character_rune` WHERE `UID`=?")) {
+
+            preparedStatement.setInt(1, runeID);
+            ResultSet rs = preparedStatement.executeQuery();
+
+            characterRune = (CharacterRune) getObjectFromRs(rs);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+
+        return characterRune;
+    }
+
+    public boolean DELETE_CHARACTER_RUNE(final CharacterRune characterRune) {
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("DELETE FROM `dyn_character_rune` WHERE `UID`=?;")) {
+
+            preparedStatement.setLong(1, characterRune.getObjectUUID());
+
+            return (preparedStatement.executeUpdate() > 0);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return false;
+    }
+
+    public ArrayList<CharacterRune> GET_RUNES_FOR_CHARACTER(final int characterId) {
+
+        ArrayList<CharacterRune> characterRunes = new ArrayList<>();
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `dyn_character_rune` WHERE `CharacterID` = ?")) {
+
+            preparedStatement.setInt(1, characterId);
+
+            ResultSet rs = preparedStatement.executeQuery();
+            characterRunes = getObjectsFromRs(rs, 10);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return characterRunes;
+    }
+
+    public void updateDatabase(final CharacterRune characterRune) {
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `dyn_character_rune` SET `CharacterID`=?, `RuneBaseID`=? WHERE `UID` = ?")) {
+
+            preparedStatement.setInt(1, characterRune.getPlayerID());
+            preparedStatement.setInt(2, characterRune.getRuneBaseID());
+            preparedStatement.setLong(3, characterRune.getObjectUUID());
+
+            preparedStatement.execute();
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+    }
 
-	public void updateDatabase(final CharacterRune cr) {
-		prepareCallable("UPDATE `dyn_character_rune` SET `CharacterID`=?, `RuneBaseID`=? WHERE `UID` = ?");
-		setInt(1, cr.getPlayerID());
-		setInt(2, cr.getRuneBaseID());
-		setLong(3, (long) cr.getObjectUUID());
-		executeUpdate();
-	}
 }

src/engine/db/handlers/dbCharacterSkillHandler.java

@@ -17,8 +17,7 @@ import engine.objects.PlayerCharacter;
 import engine.server.MBServerStatics;
 import org.pmw.tinylog.Logger;
 
-import java.sql.ResultSet;
-import java.sql.SQLException;
+import java.sql.*;
 import java.util.concurrent.ConcurrentHashMap;
 
 public class dbCharacterSkillHandler extends dbHandlerBase {
@@ -29,88 +28,146 @@ public class dbCharacterSkillHandler extends dbHandlerBase {
 	}
 
 	public CharacterSkill ADD_SKILL(CharacterSkill toAdd) {
+
+		CharacterSkill characterSkill = null;
+
 		if (CharacterSkill.GetOwner(toAdd) == null || toAdd.getSkillsBase() == null) {
 			Logger.error("dbCharacterSkillHandler.ADD_SKILL", toAdd.getObjectUUID() + " missing owner or skillsBase");
 			return null;
 		}
 
-		prepareCallable("INSERT INTO `dyn_character_skill` (`CharacterID`, `skillsBaseID`, `trains`) VALUES (?, ?, ?);");
-		setLong(1, (long)CharacterSkill.GetOwner(toAdd).getObjectUUID());
-		setInt(2, toAdd.getSkillsBase().getObjectUUID());
-		setInt(3, toAdd.getNumTrains());
-		int skillID = insertGetUUID();
-		return GET_SKILL(skillID);
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("INSERT INTO `dyn_character_skill` (`CharacterID`, `skillsBaseID`, `trains`) VALUES (?, ?, ?);", Statement.RETURN_GENERATED_KEYS)) {
+
+			preparedStatement.setLong(1, CharacterSkill.GetOwner(toAdd).getObjectUUID());
+			preparedStatement.setInt(2, toAdd.getSkillsBase().getObjectUUID());
+			preparedStatement.setInt(3, toAdd.getNumTrains());
+
+			preparedStatement.executeUpdate();
+			ResultSet rs = preparedStatement.getGeneratedKeys();
+
+			if (rs.next())
+				characterSkill = GET_SKILL(rs.getInt(1));
+
+		} catch (SQLException e) {
+			Logger.error(e);
+		}
+		return characterSkill;
 	}
 
 	public boolean DELETE_SKILL(final int objectUUID) {
-		prepareCallable("DELETE FROM `dyn_character_skill` WHERE `UID` = ?");
-		setLong(1, (long)objectUUID);
-		return (executeUpdate() != 0);
+
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("DELETE FROM `dyn_character_skill` WHERE `UID` = ?")) {
+
+			preparedStatement.setLong(1, objectUUID);
+
+			return (preparedStatement.executeUpdate() > 0);
+
+		} catch (SQLException e) {
+			Logger.error(e);
+		}
+		return false;
 	}
 
 	public CharacterSkill GET_SKILL(final int objectUUID) {
-		CharacterSkill skill = (CharacterSkill) DbManager.getFromCache(Enum.GameObjectType.CharacterSkill, objectUUID);
-		if (skill != null)
-			return skill;
-		prepareCallable("SELECT * FROM `dyn_character_skill` WHERE `UID` = ?");
-		setInt(1, objectUUID);
-		return (CharacterSkill) getObjectSingle(objectUUID);
+
+		CharacterSkill characterSkill = (CharacterSkill) DbManager.getFromCache(Enum.GameObjectType.CharacterSkill, objectUUID);
+
+		if (characterSkill != null)
+			return characterSkill;
+
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `dyn_character_skill` WHERE `UID` = ?")) {
+
+			preparedStatement.setInt(1, objectUUID);
+			ResultSet rs = preparedStatement.executeQuery();
+
+			characterSkill = (CharacterSkill) getObjectFromRs(rs);
+
+		} catch (SQLException e) {
+			Logger.error(e);
+		}
+		return characterSkill;
 	}
 
 	public ConcurrentHashMap<String, CharacterSkill> GET_SKILLS_FOR_CHARACTER(final AbstractCharacter ac) {
-		ConcurrentHashMap<String, CharacterSkill> skills = new ConcurrentHashMap<>(MBServerStatics.CHM_INIT_CAP, MBServerStatics.CHM_LOAD, MBServerStatics.CHM_THREAD_LOW);
+
+		ConcurrentHashMap<String, CharacterSkill> characterSkills = new ConcurrentHashMap<>(MBServerStatics.CHM_INIT_CAP, MBServerStatics.CHM_LOAD, MBServerStatics.CHM_THREAD_LOW);
+
 		if (ac == null || (!(ac.getObjectType().equals(Enum.GameObjectType.PlayerCharacter))))
-			return skills;
-		PlayerCharacter pc = (PlayerCharacter) ac;
-		int objectUUID = pc.getObjectUUID();
+			return characterSkills;
+
+		PlayerCharacter playerCharacter = (PlayerCharacter) ac;
+		int characterId = playerCharacter.getObjectUUID();
+
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `dyn_character_skill` WHERE `CharacterID` = ?")) {
+
+			preparedStatement.setInt(1, characterId);
+
+			ResultSet rs = preparedStatement.executeQuery();
 
-		prepareCallable("SELECT * FROM `dyn_character_skill` WHERE `CharacterID` = ?");
-		setInt(1, objectUUID);
-		try {
-			ResultSet rs = executeQuery();
 			while (rs.next()) {
-				CharacterSkill cs = new CharacterSkill(rs, pc);
+				CharacterSkill cs = new CharacterSkill(rs, playerCharacter);
 				if (cs.getSkillsBase() != null)
-					skills.put(cs.getSkillsBase().getName(), cs);
+					characterSkills.put(cs.getSkillsBase().getName(), cs);
 			}
-			rs.close();
+
 		} catch (SQLException e) {
-			Logger.error("CharacterSkill.getCharacterSkillForCharacter", e);
-		} finally {
-			closeCallable();
+			Logger.error(e);
 		}
-		return skills;
+
+		return characterSkills;
 	}
 
 
-	public void UPDATE_TRAINS(final CharacterSkill cs) {
-		if (!cs.isTrained())
+	public void UPDATE_TRAINS(final CharacterSkill characterSkill) {
+
+		if (!characterSkill.isTrained())
 			return;
 
-		prepareCallable("UPDATE `dyn_character_skill` SET `trains`=? WHERE `UID` = ?");
-		setShort(1, (short)cs.getNumTrains());
-		setLong(2, (long)cs.getObjectUUID());
-		if (executeUpdate() != 0)
-			cs.syncTrains();
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `dyn_character_skill` SET `trains`=? WHERE `UID` = ?")) {
+
+			preparedStatement.setShort(1, (short) characterSkill.getNumTrains());
+			preparedStatement.setLong(2, characterSkill.getObjectUUID());
+
+			if (preparedStatement.executeUpdate() != 0)
+				characterSkill.syncTrains();
+
+		} catch (SQLException e) {
+			Logger.error(e);
+		}
 	}
 
-	public void updateDatabase(final CharacterSkill cs) {
-		if (cs.getSkillsBase() == null) {
-			Logger.error("Failed to find skillsBase for Skill " + cs.getObjectUUID());
-			return;
-		}
-		if (CharacterSkill.GetOwner(cs) == null) {
-			Logger.error("Failed to find owner for Skill " + cs.getObjectUUID());
+	public void updateDatabase(final CharacterSkill characterSkill) {
+
+		if (characterSkill.getSkillsBase() == null) {
+			Logger.error("Failed to find skillsBase for Skill " + characterSkill.getObjectUUID());
 			return;
 		}
 
-		prepareCallable("UPDATE `dyn_character_skill` SET `skillsBaseID`=?, `CharacterID`=?, `trains`=? WHERE `UID`=?");
-		setInt(1, cs.getSkillsBase().getObjectUUID());
-		setInt(2, CharacterSkill.GetOwner(cs).getObjectUUID());
-		setShort(3, (short)cs.getNumTrains());
-		setLong(4, (long)cs.getObjectUUID());
-		if (executeUpdate() != 0)
-			cs.syncTrains();
+		if (CharacterSkill.GetOwner(characterSkill) == null) {
+			Logger.error("Failed to find owner for Skill " + characterSkill.getObjectUUID());
+			return;
+		}
+
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `dyn_character_skill` SET `skillsBaseID`=?, `CharacterID`=?, `trains`=? WHERE `UID`=?")) {
+
+			preparedStatement.setInt(1, characterSkill.getSkillsBase().getObjectUUID());
+			preparedStatement.setInt(2, CharacterSkill.GetOwner(characterSkill).getObjectUUID());
+			preparedStatement.setShort(3, (short) characterSkill.getNumTrains());
+			preparedStatement.setLong(4, characterSkill.getObjectUUID());
+
+			if (preparedStatement.executeUpdate() != 0)
+				characterSkill.syncTrains();
+
+		} catch (SQLException e) {
+			Logger.error(e);
+		}
+
 	}
 
 }

src/engine/db/handlers/dbCityHandler.java

@@ -17,180 +17,229 @@ import engine.objects.City;
 import engine.objects.Zone;
 import org.pmw.tinylog.Logger;
 
-import java.net.UnknownHostException;
-import java.sql.ResultSet;
-import java.sql.SQLException;
+import java.sql.*;
 import java.time.LocalDateTime;
 import java.util.ArrayList;
 
 public class dbCityHandler extends dbHandlerBase {
 
-	public dbCityHandler() {
-		this.localClass = City.class;
-		this.localObjectType = Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
-	}
+    public dbCityHandler() {
+        this.localClass = City.class;
+        this.localObjectType = Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
+    }
 
-	public ArrayList<AbstractGameObject> CREATE_CITY(int ownerID, int parentZoneID, int realmID, float xCoord, float yCoord, float zCoord, float rotation, float W, String name, LocalDateTime established) {
-		prepareCallable("CALL `city_CREATE`(?, ?, ?, ?, ?, ?, ?, ?, ?,?,?)");
-		LocalDateTime upgradeTime = LocalDateTime.now().plusHours(2);
-		setLong(1, (long) ownerID); //objectUUID of owning player
-		setLong(2, (long) parentZoneID); //objectUUID of parent (continent) zone
-		setLong(3, (long) realmID); //objectUUID of realm city belongs in
-		setFloat(4, xCoord); //xOffset from parentZone center
-		setFloat(5, yCoord); //yOffset from parentZone center
-		setFloat(6, zCoord); //zOffset from parentZone center
-		setString(7, name); //city name
-		setLocalDateTime(8, established);
-		setFloat(9, rotation);
-		setFloat(10, W);
-		setLocalDateTime(11, upgradeTime);
-		ArrayList<AbstractGameObject> list = new ArrayList<>();
+    public static void addObject(ArrayList<AbstractGameObject> list, ResultSet rs) throws SQLException {
+        String type = rs.getString("type");
+        switch (type) {
+            case "zone":
+                Zone zone = new Zone(rs);
+                DbManager.addToCache(zone);
+                list.add(zone);
+                break;
+            case "building":
+                Building building = new Building(rs);
+                DbManager.addToCache(building);
+                list.add(building);
+                break;
+            case "city":
+                City city = new City(rs);
+                DbManager.addToCache(city);
+                list.add(city);
+                break;
+        }
+    }
 
-		try {
-			boolean work = execute();
-			if (work) {
-				ResultSet rs = this.cs.get().getResultSet();
-				while (rs.next()) {
-					addObject(list, rs);
-				}
-				rs.close();
-			} else {
-				Logger.info("City Placement Failed: " + this.cs.get().toString());
-				return list; //city creation failure
-			}
-			while (this.cs.get().getMoreResults()) {
-				ResultSet rs = this.cs.get().getResultSet();
-				while (rs.next()) {
-					addObject(list, rs);
-				}
-				rs.close();
-			}
-		} catch (SQLException e) {
-			Logger.info("City Placement Failed, SQLException: " + this.cs.get().toString() + e.toString());
-			return list; //city creation failure
-		} catch (UnknownHostException e) {
-			Logger.info("City Placement Failed, UnknownHostException: " + this.cs.get().toString());
-			return list; //city creation failure
-		} finally {
-			closeCallable();
-		}
-		return list;
-	}
+    public ArrayList<AbstractGameObject> CREATE_CITY(int ownerID, int parentZoneID, int realmID, float xCoord, float yCoord, float zCoord, float rotation, float W, String name, LocalDateTime established) {
 
-	public static void addObject(ArrayList<AbstractGameObject> list, ResultSet rs) throws SQLException, UnknownHostException {
-		String type = rs.getString("type");
-		switch (type) {
-		case "zone":
-			Zone zone = new Zone(rs);
-			DbManager.addToCache(zone);
-			list.add(zone);
-			break;
-		case "building":
-			Building building = new Building(rs);
-			DbManager.addToCache(building);
-			list.add(building);
-			break;
-		case "city":
-			City city = new City(rs);
-			DbManager.addToCache(city);
-			list.add(city);
-			break;
-		}
-	}
+        LocalDateTime upgradeTime = LocalDateTime.now().plusHours(2);
+        ArrayList<AbstractGameObject> objectList = new ArrayList<>();
 
-	public ArrayList<City> GET_CITIES_BY_ZONE(final int objectUUID) {
-		prepareCallable("SELECT `obj_city`.*, `object`.`parent` FROM `obj_city` INNER JOIN `object` ON `object`.`UID` = `obj_city`.`UID` WHERE `object`.`parent`=?;");
-		setLong(1, (long) objectUUID);
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("CALL `city_CREATE`(?, ?, ?, ?, ?, ?, ?, ?, ?,?,?)")) {
 
-        return getObjectList();
-	}
+            preparedStatement.setLong(1, ownerID); //objectUUID of owning player
+            preparedStatement.setLong(2, parentZoneID); //objectUUID of parent (continent) zone
+            preparedStatement.setLong(3, realmID); //objectUUID of realm city belongs in
+            preparedStatement.setFloat(4, xCoord); //xOffset from parentZone center
+            preparedStatement.setFloat(5, yCoord); //yOffset from parentZone center
+            preparedStatement.setFloat(6, zCoord); //zOffset from parentZone center
+            preparedStatement.setString(7, name); //city name
+            preparedStatement.setTimestamp(8, Timestamp.valueOf(established));
+            preparedStatement.setFloat(9, rotation);
+            preparedStatement.setFloat(10, W);
+            preparedStatement.setTimestamp(11, Timestamp.valueOf(upgradeTime));
 
-	public City GET_CITY(final int cityId) {
-		City city = (City) DbManager.getFromCache(Enum.GameObjectType.City, cityId);
-		if (city != null)
-			return city;
-		prepareCallable("SELECT `obj_city`.*, `object`.`parent` FROM `obj_city` INNER JOIN `object` ON `object`.`UID` = `obj_city`.`UID` WHERE `object`.`UID`=?;");
-		setLong(1, (long) cityId);
-		city = (City) getObjectSingle(cityId);
-		return city;
-	}
+            boolean work = preparedStatement.execute();
 
-	public String SET_PROPERTY(final City c, String name, Object new_value) {
-		prepareCallable("CALL city_SETPROP(?,?,?)");
-		setLong(1, (long) c.getObjectUUID());
-		setString(2, name);
-		setString(3, String.valueOf(new_value));
-		return getResult();
-	}
+            if (work) {
 
-	public String SET_PROPERTY(final City c, String name, Object new_value, Object old_value) {
-		prepareCallable("CALL city_GETSETPROP(?,?,?,?)");
-		setLong(1, (long) c.getObjectUUID());
-		setString(2, name);
-		setString(3, String.valueOf(new_value));
-		setString(4, String.valueOf(old_value));
-		return getResult();
-	}
+                ResultSet rs = preparedStatement.getResultSet();
 
-	public boolean updateforceRename(City city, boolean value) {
+                while (rs.next())
+                    addObject(objectList, rs);
+                rs.close();
+            } else {
+                Logger.info("City Placement Failed: " + preparedStatement);
+                return objectList; //city creation failure
+            }
+            while (preparedStatement.getMoreResults()) {
+                ResultSet rs = preparedStatement.getResultSet();
+                while (rs.next()) {
+                    addObject(objectList, rs);
+                }
+                rs.close();
+            }
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
 
-		prepareCallable("UPDATE `obj_city` SET `forceRename`=?"
-				+ " WHERE `UID` = ?");
-		setByte(1, (value == true) ? (byte) 1 : (byte) 0);
-		setInt(2, city.getObjectUUID());
-		return (executeUpdate() > 0);
-	}
+        return objectList;
+    }
 
-	public boolean updateOpenCity(City city, boolean value) {
+    public ArrayList<City> GET_CITIES_BY_ZONE(final int objectUUID) {
 
-		prepareCallable("UPDATE `obj_city` SET `open`=?"
-				+ " WHERE `UID` = ?");
-		setByte(1, (value == true) ? (byte) 1 : (byte) 0);
-		setInt(2, city.getObjectUUID());
-		return (executeUpdate() > 0);
-	}
+        ArrayList<City> cityList = new ArrayList<>();
 
-	public boolean updateTOL(City city, int tolID) {
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT `obj_city`.*, `object`.`parent` FROM `obj_city` INNER JOIN `object` ON `object`.`UID` = `obj_city`.`UID` WHERE `object`.`parent`=?;")) {
 
-		prepareCallable("UPDATE `obj_city` SET `treeOfLifeUUID`=?"
-				+ " WHERE `UID` = ?");
-		setInt(1,tolID);
-		setInt(2, city.getObjectUUID());
-		return (executeUpdate() > 0);
-	}
+            preparedStatement.setLong(1, objectUUID);
 
-	public boolean renameCity(City city, String name) {
+            ResultSet rs = preparedStatement.executeQuery();
+            cityList = getObjectsFromRs(rs, 100);
 
-		prepareCallable("UPDATE `obj_city` SET `name`=?"
-				+ " WHERE `UID` = ?");
-		setString(1, name);
-		setInt(2, city.getObjectUUID());
-		return (executeUpdate() > 0);
-	}
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
 
-	public boolean updateSiegesWithstood(City city, int value) {
+        return cityList;
+    }
 
-		prepareCallable("UPDATE `obj_city` SET `siegesWithstood`=?"
-				+ " WHERE `UID` = ?");
-		setInt(1, value);
-		setInt(2, city.getObjectUUID());
-		return (executeUpdate() > 0);
-	}
+    public City GET_CITY(final int cityId) {
 
-	public boolean updateRealmTaxDate(City city, LocalDateTime localDateTime) {
+        City city = (City) DbManager.getFromCache(Enum.GameObjectType.City, cityId);
 
-		prepareCallable("UPDATE `obj_city` SET `realmTaxDate` =?"
-				+ " WHERE `UID` = ?");
-		setLocalDateTime(1, localDateTime);
-		setInt(2,city.getObjectUUID());
-		return (executeUpdate() > 0);
-	}
+        if (city != null)
+            return city;
 
-	public boolean DELETE_CITY(final City city) {
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT `obj_city`.*, `object`.`parent` FROM `obj_city` INNER JOIN `object` ON `object`.`UID` = `obj_city`.`UID` WHERE `object`.`UID`=?;")) {
 
-		prepareCallable("DELETE FROM `object` WHERE `UID` = ? AND `type` = 'city'");
-		setInt(1, city.getObjectUUID());
-		return (executeUpdate() != 0);
-	}
+            preparedStatement.setLong(1, cityId);
+
+            ResultSet rs = preparedStatement.executeQuery();
+            city = (City) getObjectFromRs(rs);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+
+        return city;
+    }
+
+    public boolean updateforceRename(City city, boolean value) {
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_city` SET `forceRename`=?"
+                     + " WHERE `UID` = ?")) {
+
+            preparedStatement.setByte(1, (value == true) ? (byte) 1 : (byte) 0);
+            preparedStatement.setInt(2, city.getObjectUUID());
+
+            return (preparedStatement.executeUpdate() > 0);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+            return false;
+        }
+    }
+
+    public boolean updateOpenCity(City city, boolean value) {
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_city` SET `open`=?"
+                     + " WHERE `UID` = ?")) {
+
+            preparedStatement.setByte(1, (value == true) ? (byte) 1 : (byte) 0);
+            preparedStatement.setInt(2, city.getObjectUUID());
+
+            return (preparedStatement.executeUpdate() > 0);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+            return false;
+        }
+    }
+
+    public boolean updateTOL(City city, int tolID) {
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_city` SET `treeOfLifeUUID`=?"
+                     + " WHERE `UID` = ?")) {
+
+            preparedStatement.setInt(1, tolID);
+            preparedStatement.setInt(2, city.getObjectUUID());
+
+            return (preparedStatement.executeUpdate() > 0);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+            return false;
+        }
+
+    }
+
+    public boolean renameCity(City city, String name) {
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_city` SET `name`=?"
+                     + " WHERE `UID` = ?")) {
+
+            preparedStatement.setString(1, name);
+            preparedStatement.setInt(2, city.getObjectUUID());
+
+            return (preparedStatement.executeUpdate() > 0);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+            return false;
+        }
+
+    }
+
+    public boolean updateSiegesWithstood(City city, int value) {
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_city` SET `name`=?"
+                     + " WHERE `UID` = ?")) {
+
+            preparedStatement.setInt(1, value);
+            preparedStatement.setInt(2, city.getObjectUUID());
+
+            return (preparedStatement.executeUpdate() > 0);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+            return false;
+        }
+
+    }
+
+    public boolean updateRealmTaxDate(City city, LocalDateTime localDateTime) {
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_city` SET `realmTaxDate` =?"
+                     + " WHERE `UID` = ?")) {
+
+            preparedStatement.setTimestamp(1, Timestamp.valueOf(localDateTime));
+            preparedStatement.setInt(2, city.getObjectUUID());
+
+            return (preparedStatement.executeUpdate() > 0);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+            return false;
+        }
+    }
 
 }

src/engine/db/handlers/dbContractHandler.java

@@ -16,9 +16,10 @@ import engine.objects.ItemBase;
 import engine.objects.MobEquipment;
 import org.pmw.tinylog.Logger;
 
+import java.sql.Connection;
+import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
-import java.util.ArrayList;
 
 public class dbContractHandler extends dbHandlerBase {
 
@@ -28,48 +29,37 @@ public class dbContractHandler extends dbHandlerBase {
 	}
 
 	public Contract GET_CONTRACT(final int objectUUID) {
+
 		Contract contract = (Contract) DbManager.getFromCache(Enum.GameObjectType.Contract, objectUUID);
+
 		if (contract != null)
 			return contract;
+
 		if (objectUUID == 0)
 			return null;
-		prepareCallable("SELECT * FROM `static_npc_contract` WHERE `ID` = ?");
-		setInt(1, objectUUID);
-		return (Contract) getObjectSingle(objectUUID);
-	}
 
-	public ArrayList<Contract> GET_CONTRACT_BY_RACE(final int objectUUID) {
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `static_npc_contract` WHERE `ID` = ?")) {
 
-		ArrayList<Contract> contracts = new ArrayList<>();
+			preparedStatement.setInt(1, objectUUID);
 
-		prepareCallable("SELECT * FROM static_npc_contract WHERE `mobbaseID` =?;");
-		setLong(1, objectUUID);
-
-		try {
-			ResultSet rs = executeQuery();
-
-			//shrines cached in rs for easy cache on creation.
-			while (rs.next()) {
-				Contract contract = new Contract(rs);
-				if (contract != null)
-					contracts.add(contract);
-			}
+			ResultSet rs = preparedStatement.executeQuery();
+			contract = (Contract) getObjectFromRs(rs);
 
 		} catch (SQLException e) {
-			Logger.error( e.getErrorCode() + ' ' + e.getMessage(), e);
-		} finally {
-			closeCallable();
+			Logger.error(e);
 		}
-		return contracts;
+		return contract;
 	}
 
-	public void GET_GENERIC_INVENTORY(final Contract contract) {
+	public void LOAD_CONTRACT_INVENTORY(final Contract contract) {
 
-		prepareCallable("SELECT * FROM `static_npc_inventoryset` WHERE `inventorySet` = ?;");
-		setInt(1, contract.inventorySet);
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `static_npc_inventoryset` WHERE `inventorySet` = ?;")) {
 
-		try {
-			ResultSet rs = executeQuery();
+			preparedStatement.setInt(1, contract.inventorySet);
+
+			ResultSet rs = preparedStatement.executeQuery();
 
 			while (rs.next()) {
 
@@ -102,56 +92,77 @@ public class dbContractHandler extends dbHandlerBase {
 				}
 			}
 		} catch (SQLException e) {
-			Logger.error("SQL Error number: " + e.getErrorCode() + ' ' + e.getMessage());
-		} finally {
-			closeCallable();
+			Logger.error(e);
 		}
 	}
 
-	public void GET_SELL_LISTS(final Contract con) {
-		prepareCallable("SELECT * FROM `static_npc_contract_selltype` WHERE `contractID` = ?;");
-		setInt(1, con.getObjectUUID());
-		try {
-			ResultSet rs = executeQuery();
-			ArrayList<Integer> item = con.getBuyItemType();
-			ArrayList<Integer> skill = con.getBuySkillToken();
-			ArrayList<Integer> unknown = con.getBuyUnknownToken();
+	public void LOAD_SELL_LIST_FOR_CONTRACT(final Contract contract) {
+
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `static_npc_contract_selltype` WHERE `contractID` = ?;")) {
+
+			preparedStatement.setInt(1, contract.getObjectUUID());
+
+			ResultSet rs = preparedStatement.executeQuery();
+
 			while (rs.next()) {
+
 				int type = rs.getInt("type");
 				int value = rs.getInt("value");
-				if (type == 1) {
-					item.add(value);
-				} else if (type == 2) {
-					skill.add(value);
-				} else if (type == 3) {
-					unknown.add(value);
+
+				switch (type) {
+					case 1:
+						contract.getBuyItemType().add(value);
+						break;
+					case 2:
+						contract.getBuySkillToken().add(value);
+						break;
+					case 3:
+						contract.getBuyUnknownToken().add(value);
+						break;
 				}
 			}
 		} catch (SQLException e) {
-			Logger.error("SQL Error number: " + e.getErrorCode() + ' ' + e.getMessage());
-		} finally {
-			closeCallable();
+			Logger.error(e);
 		}
 	}
 
 	public boolean updateAllowedBuildings(final Contract con, final long slotbitvalue) {
-		prepareCallable("UPDATE `static_npc_contract` SET `allowedBuildingTypeID`=? WHERE `contractID`=?");
-		setLong(1, slotbitvalue);
-		setInt(2, con.getContractID());
-		return (executeUpdate() > 0);
+
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `static_npc_contract` SET `allowedBuildingTypeID`=? WHERE `contractID`=?")) {
+
+			preparedStatement.setLong(1, slotbitvalue);
+			preparedStatement.setInt(2, con.getContractID());
+
+			return (preparedStatement.executeUpdate() > 0);
+
+		} catch (SQLException e) {
+			Logger.error(e);
+		}
+		return false;
 	}
 
 	public boolean updateDatabase(final Contract con) {
-		prepareCallable("UPDATE `static_npc_contract` SET `contractID`=?, `name`=?, "
-				+ "`mobbaseID`=?, `classID`=?, vendorDialog=?, iconID=?, allowedBuildingTypeID=? WHERE `ID`=?");
-		setInt(1, con.getContractID());
-		setString(2, con.getName());
-		setInt(3, con.getMobbaseID());
-		setInt(4, con.getClassID());
-		setInt(5, (con.getVendorDialog() != null) ? con.getVendorDialog().getObjectUUID() : 0);
-		setInt(6, con.getIconID());
-		setInt(8, con.getObjectUUID());
-		setLong(7, con.getAllowedBuildings().toLong());
-		return (executeUpdate() > 0);
+
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `static_npc_contract` SET `contractID`=?, `name`=?, "
+					 + "`mobbaseID`=?, `classID`=?, vendorDialog=?, iconID=?, allowedBuildingTypeID=? WHERE `ID`=?")) {
+
+			preparedStatement.setInt(1, con.getContractID());
+			preparedStatement.setString(2, con.getName());
+			preparedStatement.setInt(3, con.getMobbaseID());
+			preparedStatement.setInt(4, con.getClassID());
+			preparedStatement.setInt(5, (con.getVendorDialog() != null) ? con.getVendorDialog().getObjectUUID() : 0);
+			preparedStatement.setInt(6, con.getIconID());
+			preparedStatement.setInt(8, con.getObjectUUID());
+			preparedStatement.setLong(7, con.getAllowedBuildings().toLong());
+
+			return (preparedStatement.executeUpdate() > 0);
+
+		} catch (SQLException e) {
+			Logger.error(e);
+		}
+		return false;
 	}
 }

src/engine/db/handlers/dbEffectsBaseHandler.java

@@ -9,173 +9,295 @@
 
 package engine.db.handlers;
 
+import engine.Enum;
+import engine.gameManager.DbManager;
+import engine.gameManager.PowersManager;
+import engine.powers.EffectsBase;
+import engine.powers.effectmodifiers.*;
+import org.pmw.tinylog.Logger;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.HashSet;
+
 public class dbEffectsBaseHandler extends dbHandlerBase {
 
-	public dbEffectsBaseHandler() {
+    public dbEffectsBaseHandler() {
 
 	}
 
+	public static ArrayList<EffectsBase> getAllEffectsBase() {
 
+		ArrayList<EffectsBase> effectList = new ArrayList<>();
 
-	public boolean CreateEffectBase(int token, String IDString,String name,int flags){
-		prepareCallable("INSERT INTO `wpak_static_power_effectbase` (`token`,`IDString`,`name`,`flags`) VALUES (?,?,?,?)");
-		setInt(1,token);
-		setString(2,IDString);
-		setString(3,name);
-		setInt(4,flags);
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement prepareStatement = connection.prepareStatement("SELECT * FROM static_power_effectbase ORDER BY `IDString` DESC")) {
 
-		return (executeUpdate() > 0);
-	}
-	
-	public boolean CreateEffectBaseRAW(String IDString,String type,String detail){
-		prepareCallable("INSERT INTO `wpak_effect_effectbase_raw` (`token`,`IDString`,`name`,`flags`) VALUES (?,?,?,?)");
-		setString(1,IDString);
-		setString(2,type);
-		setString(3,detail);
+			ResultSet rs = prepareStatement.executeQuery();
 
-		return (executeUpdate() > 0);
+			while (rs.next()) {
+				EffectsBase effectBase = new EffectsBase(rs);
+				effectList.add(effectBase);
+			}
+		} catch (SQLException e) {
+			Logger.error(e.toString());
+		}
+
+		return effectList;
 	}
 
-	public boolean CreateEffectSource(String IDString,String source){
-		prepareCallable("INSERT INTO `wpak_static_power_sourcetype` (`IDString`,`source`) VALUES (?,?)");
+	public static void cacheAllEffectModifiers() {
 
-		setString(1,IDString);
-		setString(2,source);
+		String IDString;
+		AbstractEffectModifier abstractEffectModifier = null;
 
-		return (executeUpdate() > 0);
-	}
-	
-	public boolean CreateEffectSourceRAW(String IDString,String type,String detail){
-		prepareCallable("INSERT INTO `wpak_effect_source_raw` (`effectID`,`type`, `text`) VALUES (?,?,?)");
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement prepareStatement = connection.prepareStatement("SELECT * FROM static_power_effectmod")) {
 
-		setString(1,IDString);
-		setString(2,type);
-		setString(3,detail);
+			ResultSet rs = prepareStatement.executeQuery();
 
-		return (executeUpdate() > 0);
-	}
+			while (rs.next()) {
 
-	public boolean CreateEffectCondition(String IDString,String powerOrEffect,String type,float amount,float ramp,byte useAddFormula,String damageType1,String damageType2,String damageType3){
-		prepareCallable("INSERT INTO `wpak_static_power_failcondition` (`IDString`,`powerOrEffect`,`type`,`amount`,`ramp`,`useAddFormula`,`damageType1`,`damageType2`,`damageType3`) VALUES (?,?,?,?,?,?,?,?,?)");
-		setString(1,IDString);
-		setString(2,powerOrEffect);
-		setString(3,type);
-		setFloat(4,amount);
-		setFloat(5,ramp);
-		setByte(6,useAddFormula);
-		setString(7,damageType1);
-		setString(8,damageType2);
-		setString(9,damageType3);
+				IDString = rs.getString("IDString");
+				EffectsBase effectBase = PowersManager.getEffectByIDString(IDString);
+				Enum.ModType modifier = Enum.ModType.GetModType(rs.getString("modType"));
 
-		return (executeUpdate() > 0);
-	}
-	
-	public boolean CreateEffectConditionRAW(String IDString,String type,String detail){
-		prepareCallable("INSERT INTO `wpak_effect_condition_raw` (`effectID`,`type`, `text`) VALUES (?,?,?)");
-		setString(1,IDString);
-		setString(2,type);
-		setString(3,detail);
-		return (executeUpdate() > 0);
-	}
+				//combine item prefix and suffix effect modifiers
 
-	public boolean CreateEffectMod(String IDString,String modType,float minMod,float maxMod,float percentMod,float ramp,byte useRampAdd,String type,String string1,String string2){
-		prepareCallable("INSERT INTO `wpak_static_power_effectmod` (`IDString`,`modType`,`minMod`,`maxMod`,`percentMod`,`ramp`,`useRampAdd`,`type`,`string1`,`string2`) VALUES (?,?,?,?,?,?,?,?,?,?)");
-		setString(1, IDString);
-		setString(2, modType);
-		setFloat(3, minMod);
-		setFloat(4, maxMod);
-		setFloat(5, percentMod);
-		setFloat(6, ramp);
-		setByte(7, useRampAdd);
-		setString(8, type);
-		setString(9, string1);
-		setString(10, string2);
+				abstractEffectModifier = getCombinedModifiers(abstractEffectModifier, rs, effectBase, modifier);
 
-		return (executeUpdate() > 0);
-	}
-	
-	public boolean CreateEffectModRAW(String IDString,String type,String detail){
-		prepareCallable("INSERT INTO `wpak_effect_mod_raw` (`effectID`,`type`, `text`) VALUES (?,?,?)");
-		setString(1,IDString);
-		setString(2,type);
-		setString(3,detail);
+				if (abstractEffectModifier != null) {
 
-		return (executeUpdate() > 0);
-	}
-	
+					if (EffectsBase.modifiersMap.containsKey(effectBase.getIDString()) == false)
+						EffectsBase.modifiersMap.put(effectBase.getIDString(), new HashSet<>());
 
-	public boolean CreatePowerPowerAction(String IDString,String type,String effectID,String effectID2,String deferredPowerID,float levelCap,float levelCapRamp,String damageType,int numIterations,String effectSourceToRemove,String trackFilter,int maxTrack,int mobID,int mobLevel,int simpleDamage,String transferFromType,String transferToType,float transferAmount,float transferRamp,float transferEfficiency,float transferEfficiencyRamp,int flags){
-		prepareCallable("INSERT INTO `wpak_static_power_poweraction` (`IDString`,`type`,`effectID`,`effectID2`,`deferredPowerID`,`levelCap`,`levelCapRamp`,`damageType`,`numIterations`,`effectSourceToRemove`,`trackFilter`,`maxTrack`,`mobID`,`mobLevel`,`simpleDamage`,`transferFromType`,`transferToType`,`transferAmount`,`transferRamp`,`transferEfficiency`,`transferEfficiencyRamp`,`flags`) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)");
+					EffectsBase.modifiersMap.get(effectBase.getIDString()).add(abstractEffectModifier);
 
-		setString(1,IDString);
-		setString(2,type);
-		setString(3,effectID);
-		setString(4,effectID2);
-		setString(5,deferredPowerID);
-		setFloat(6,levelCap);
-		setFloat(7,levelCapRamp);
-		setString(8,damageType);
-		setInt(9,numIterations);
-		setString(10,effectSourceToRemove);
-		setString(11,trackFilter);
-		setInt(12,maxTrack);
-		setInt(13,mobID);
-		setInt(14,mobLevel);
-		setInt(15,simpleDamage);
-		setString(16,transferFromType);
-		setString(17,transferToType);
-		setFloat(18,transferAmount);
-		setFloat(19,transferRamp);
-		setFloat(20,transferEfficiency);
-		setFloat(21,transferEfficiencyRamp);
-		setInt(22,flags);
+				}
 
-		return (executeUpdate() > 0);
-	}
-	
-	public boolean CreatePowerPowerActionRAW(String IDString,String type,String detail){
-		prepareCallable("INSERT INTO `wpak_effect_poweraction_raw` (`effectID`,`type`, `text`) VALUES (?,?,?)");
+			}
 
-		setString(1,IDString);
-		setString(2,type);
-		setString(3,detail);
-
-		return (executeUpdate() > 0);
-	}
-
-	public boolean ClearAllEffectBase(){
-		prepareCallable("DELETE from `wpak_static_power_effectbase`");
-		executeUpdate();
-
-		prepareCallable(" DELETE from `wpak_static_power_sourcetype` ");
-		executeUpdate();
-
-		prepareCallable(" DELETE from `wpak_static_power_failcondition` WHERE `powerOrEffect` = ?");
-		setString(1,"Effect");
-		executeUpdate();
-
-		prepareCallable(" DELETE from `wpak_static_power_effectmod` ");
-		executeUpdate();
-
-		return true;
+		} catch (Exception e) {
+			Logger.error(e);
+		}
 
 	}
 
-	public boolean ResetIncrement(){
-		prepareCallable("ALTER TABLE `wpak_static_power_effectbase` AUTO_INCREMENT = 1");
-		executeUpdate();
+	private static AbstractEffectModifier getCombinedModifiers(AbstractEffectModifier abstractEffectModifier, ResultSet rs, EffectsBase effectBase, Enum.ModType modifier) throws SQLException {
+		switch (modifier) {
+			case AdjustAboveDmgCap:
+				abstractEffectModifier = new AdjustAboveDmgCapEffectModifier(rs);
+				break;
+			case Ambidexterity:
+				abstractEffectModifier = new AmbidexterityEffectModifier(rs);
+				break;
+			case AnimOverride:
+				break;
+			case ArmorPiercing:
+				abstractEffectModifier = new ArmorPiercingEffectModifier(rs);
+				break;
+			case AttackDelay:
+				abstractEffectModifier = new AttackDelayEffectModifier(rs);
+				break;
+			case Attr:
+				abstractEffectModifier = new AttributeEffectModifier(rs);
+				break;
+			case BlackMantle:
+				abstractEffectModifier = new BlackMantleEffectModifier(rs);
+				break;
+			case BladeTrails:
+				abstractEffectModifier = new BladeTrailsEffectModifier(rs);
+				break;
+			case Block:
+				abstractEffectModifier = new BlockEffectModifier(rs);
+				break;
+			case BlockedPowerType:
+				abstractEffectModifier = new BlockedPowerTypeEffectModifier(rs);
+				break;
+			case CannotAttack:
+				abstractEffectModifier = new CannotAttackEffectModifier(rs);
+				break;
+			case CannotCast:
+				abstractEffectModifier = new CannotCastEffectModifier(rs);
+				break;
+			case CannotMove:
+				abstractEffectModifier = new CannotMoveEffectModifier(rs);
+				break;
+			case CannotTrack:
+				abstractEffectModifier = new CannotTrackEffectModifier(rs);
+				break;
+			case Charmed:
+				abstractEffectModifier = new CharmedEffectModifier(rs);
+				break;
+			case ConstrainedAmbidexterity:
+				abstractEffectModifier = new ConstrainedAmbidexterityEffectModifier(rs);
+				break;
+			case DamageCap:
+				abstractEffectModifier = new DamageCapEffectModifier(rs);
+				break;
+			case DamageShield:
+				abstractEffectModifier = new DamageShieldEffectModifier(rs);
+				break;
+			case DCV:
+				abstractEffectModifier = new DCVEffectModifier(rs);
+				break;
+			case Dodge:
+				abstractEffectModifier = new DodgeEffectModifier(rs);
+				break;
+			case DR:
+				abstractEffectModifier = new DREffectModifier(rs);
+				break;
+			case Durability:
+				abstractEffectModifier = new DurabilityEffectModifier(rs);
+				break;
+			case ExclusiveDamageCap:
+				abstractEffectModifier = new ExclusiveDamageCapEffectModifier(rs);
+				break;
+			case Fade:
+				abstractEffectModifier = new FadeEffectModifier(rs);
+				break;
+			case Fly:
+				abstractEffectModifier = new FlyEffectModifier(rs);
+				break;
+			case Health:
+				abstractEffectModifier = new HealthEffectModifier(rs);
+				break;
+			case HealthFull:
+				abstractEffectModifier = new HealthFullEffectModifier(rs);
+				break;
+			case HealthRecoverRate:
+				abstractEffectModifier = new HealthRecoverRateEffectModifier(rs);
+				break;
+			case IgnoreDamageCap:
+				abstractEffectModifier = new IgnoreDamageCapEffectModifier(rs);
+				break;
+			case IgnorePassiveDefense:
+				abstractEffectModifier = new IgnorePassiveDefenseEffectModifier(rs);
+				break;
+			case ImmuneTo:
+				abstractEffectModifier = new ImmuneToEffectModifier(rs);
+				break;
+			case ImmuneToAttack:
+				abstractEffectModifier = new ImmuneToAttackEffectModifier(rs);
+				break;
+			case ImmuneToPowers:
+				abstractEffectModifier = new ImmuneToPowersEffectModifier(rs);
+				break;
+			case Invisible:
+				abstractEffectModifier = new InvisibleEffectModifier(rs);
+				break;
+			case ItemName:
+				abstractEffectModifier = new ItemNameEffectModifier(rs);
+				if (((ItemNameEffectModifier) abstractEffectModifier).name.isEmpty())
+					break;
+				if (effectBase != null)
+					effectBase.setName((((ItemNameEffectModifier) abstractEffectModifier).name));
+				break;
+			case Mana:
+				abstractEffectModifier = new ManaEffectModifier(rs);
+				break;
+			case ManaFull:
+				abstractEffectModifier = new ManaFullEffectModifier(rs);
+				break;
+			case ManaRecoverRate:
+				abstractEffectModifier = new ManaRecoverRateEffectModifier(rs);
+				break;
+			case MaxDamage:
+				abstractEffectModifier = new MaxDamageEffectModifier(rs);
+				break;
+			case MeleeDamageModifier:
+				abstractEffectModifier = new MeleeDamageEffectModifier(rs);
+				break;
+			case MinDamage:
+				abstractEffectModifier = new MinDamageEffectModifier(rs);
+				break;
+			case NoMod:
+				abstractEffectModifier = new NoModEffectModifier(rs);
+				break;
+			case OCV:
+				abstractEffectModifier = new OCVEffectModifier(rs);
+				break;
+			case Parry:
+				abstractEffectModifier = new ParryEffectModifier(rs);
+				break;
+			case PassiveDefense:
+				abstractEffectModifier = new PassiveDefenseEffectModifier(rs);
+				break;
+			case PowerCost:
+				abstractEffectModifier = new PowerCostEffectModifier(rs);
+				break;
+			case PowerCostHealth:
+				abstractEffectModifier = new PowerCostHealthEffectModifier(rs);
+				break;
+			case PowerDamageModifier:
+				abstractEffectModifier = new PowerDamageEffectModifier(rs);
+				break;
+			case ProtectionFrom:
+				abstractEffectModifier = new ProtectionFromEffectModifier(rs);
+				break;
+			case Resistance:
+				abstractEffectModifier = new ResistanceEffectModifier(rs);
+				break;
+			case ScaleHeight:
+				abstractEffectModifier = new ScaleHeightEffectModifier(rs);
+				break;
+			case ScaleWidth:
+				abstractEffectModifier = new ScaleWidthEffectModifier(rs);
+				break;
+			case ScanRange:
+				abstractEffectModifier = new ScanRangeEffectModifier(rs);
+				break;
+			case SeeInvisible:
+				abstractEffectModifier = new SeeInvisibleEffectModifier(rs);
+				break;
+			case Silenced:
+				abstractEffectModifier = new SilencedEffectModifier(rs);
+				break;
+			case Skill:
+				abstractEffectModifier = new SkillEffectModifier(rs);
+				break;
+			case Slay:
+				abstractEffectModifier = new SlayEffectModifier(rs);
+				break;
+			case Speed:
+				abstractEffectModifier = new SpeedEffectModifier(rs);
+				break;
+			case SpireBlock:
+				abstractEffectModifier = new SpireBlockEffectModifier(rs);
+				break;
+			case Stamina:
+				abstractEffectModifier = new StaminaEffectModifier(rs);
+				break;
+			case StaminaFull:
+				abstractEffectModifier = new StaminaFullEffectModifier(rs);
+				break;
+			case StaminaRecoverRate:
+				abstractEffectModifier = new StaminaRecoverRateEffectModifier(rs);
+				break;
+			case Stunned:
+				abstractEffectModifier = new StunnedEffectModifier(rs);
+				break;
+			case Value:
+				abstractEffectModifier = new ValueEffectModifier(rs);
+				if (effectBase != null) {
+					ValueEffectModifier valueEffect = (ValueEffectModifier) abstractEffectModifier;
+					effectBase.setValue(valueEffect.minMod);
+				}
+				break;
+			case WeaponProc:
+				abstractEffectModifier = new WeaponProcEffectModifier(rs);
+				break;
+			case WeaponRange:
+				abstractEffectModifier = new WeaponRangeEffectModifier(rs);
+				break;
+			case WeaponSpeed:
+				abstractEffectModifier = new WeaponSpeedEffectModifier(rs);
+				break;
 
-		prepareCallable("ALTER TABLE `wpak_static_power_sourcetype` AUTO_INCREMENT = 1");
-		executeUpdate();
-
-		prepareCallable("ALTER TABLE `wpak_static_power_failcondition` AUTO_INCREMENT = 1");
-		executeUpdate();
-
-		prepareCallable("ALTER TABLE `wpak_static_power_effectmod` AUTO_INCREMENT = 1");
-		executeUpdate();
-
-
-		return true;
+		}
+		return abstractEffectModifier;
 	}
-
 }

src/engine/db/handlers/dbEffectsResourceCostHandler.java

@@ -9,22 +9,39 @@
 
 package engine.db.handlers;
 
+import engine.gameManager.DbManager;
 import engine.objects.EffectsResourceCosts;
+import org.pmw.tinylog.Logger;
 
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
 import java.util.ArrayList;
 
 public class dbEffectsResourceCostHandler extends dbHandlerBase {
 
-	public dbEffectsResourceCostHandler() {
-		this.localClass = EffectsResourceCosts.class;
+    public dbEffectsResourceCostHandler() {
+        this.localClass = EffectsResourceCosts.class;
         this.localObjectType = engine.Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
-	}
+    }
 
-	
-	
-	public ArrayList<EffectsResourceCosts> GET_ALL_EFFECT_RESOURCES(String idString) {
-		prepareCallable("SELECT * FROM `static_power_effectcost`  WHERE `IDString` = ?");
-		setString(1, idString);
-		return getObjectList();
-	}
+    public ArrayList<EffectsResourceCosts> GET_ALL_EFFECT_RESOURCES(String idString) {
+
+        ArrayList<EffectsResourceCosts> effectsResourceCosts = new ArrayList<>();
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `static_power_effectcost`  WHERE `IDString` = ?")) {
+
+            preparedStatement.setString(1, idString);
+
+            ResultSet rs = preparedStatement.executeQuery();
+            effectsResourceCosts = getObjectsFromRs(rs, 1000);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+
+        return effectsResourceCosts;
+    }
 }

src/engine/db/handlers/dbEnchantmentHandler.java

@@ -9,43 +9,67 @@
 
 package engine.db.handlers;
 
+import engine.gameManager.DbManager;
 import engine.server.MBServerStatics;
 import org.pmw.tinylog.Logger;
 
+import java.sql.Connection;
+import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.concurrent.ConcurrentHashMap;
 
 public class dbEnchantmentHandler extends dbHandlerBase {
 
-	public ConcurrentHashMap<String, Integer> GET_ENCHANTMENTS_FOR_ITEM(final int id) {
-		ConcurrentHashMap<String, Integer> enchants = new ConcurrentHashMap<>(MBServerStatics.CHM_INIT_CAP, MBServerStatics.CHM_LOAD, MBServerStatics.CHM_THREAD_LOW);
-		prepareCallable("SELECT * FROM `dyn_item_enchantment` WHERE `ItemID`=?;");
-		setLong(1, (long)id);
-		try {
-			ResultSet resultSet = executeQuery();
-			while (resultSet.next())
-				enchants.put(resultSet.getString("powerAction"), resultSet.getInt("rank"));
-		} catch (SQLException e) {
-			Logger.error("SQL Error number: " + e.getErrorCode());
-		} finally {
-			closeCallable();
-		}
-		return enchants;
-	}
+    public ConcurrentHashMap<String, Integer> GET_ENCHANTMENTS_FOR_ITEM(final int id) {
 
-	public boolean CREATE_ENCHANTMENT_FOR_ITEM(long itemID, String powerAction, int rank) {
-		prepareCallable("INSERT INTO `dyn_item_enchantment` (`itemID`, `powerAction`, `rank`) VALUES (?, ?, ?);");
-		setLong(1, itemID);
-		setString(2, powerAction);
-		setInt(3, rank);
-		return (executeUpdate() != 0);
-	}
+        ConcurrentHashMap<String, Integer> enchants = new ConcurrentHashMap<>(MBServerStatics.CHM_INIT_CAP, MBServerStatics.CHM_LOAD, MBServerStatics.CHM_THREAD_LOW);
 
-	public boolean CLEAR_ENCHANTMENTS(long itemID) {
-		prepareCallable("DELETE FROM `dyn_item_enchantment` WHERE `itemID`=?;");
-		setLong(1, itemID);
-		return (executeUpdate() != 0);
-	}
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `dyn_item_enchantment` WHERE `ItemID`=?;")) {
 
+            preparedStatement.setLong(1, id);
+
+            ResultSet rs = preparedStatement.executeQuery();
+
+            while (rs.next())
+                enchants.put(rs.getString("powerAction"), rs.getInt("rank"));
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+
+        return enchants;
+    }
+
+    public boolean CREATE_ENCHANTMENT_FOR_ITEM(long itemID, String powerAction, int rank) {
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("INSERT INTO `dyn_item_enchantment` (`itemID`, `powerAction`, `rank`) VALUES (?, ?, ?);")) {
+
+            preparedStatement.setLong(1, itemID);
+            preparedStatement.setString(2, powerAction);
+            preparedStatement.setInt(3, rank);
+
+            return (preparedStatement.executeUpdate() > 0);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return false;
+    }
+
+    public boolean CLEAR_ENCHANTMENTS(long itemID) {
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("DELETE FROM `dyn_item_enchantment` WHERE `itemID`=?;")) {
+
+            preparedStatement.setLong(1, itemID);
+            return (preparedStatement.executeUpdate() > 0);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return false;
+    }
 }

src/engine/db/handlers/dbHandlerBase.java

@@ -15,456 +15,63 @@ import engine.gameManager.ConfigManager;
 import engine.gameManager.DbManager;
 import engine.objects.AbstractGameObject;
 import engine.objects.AbstractWorldObject;
-import engine.server.MBServerStatics;
 import org.pmw.tinylog.Logger;
 
-import java.sql.*;
-import java.time.LocalDateTime;
+import java.sql.ResultSet;
 import java.util.ArrayList;
-import java.util.HashSet;
 
 public abstract class dbHandlerBase {
 
-	/*
-	 * CallableStatements handled below this line!
-	 */
-	protected Class<? extends AbstractGameObject> localClass = null;
-	protected GameObjectType localObjectType;
-	protected final ThreadLocal<CallableStatement> cs = new ThreadLocal<>();
+    protected Class<? extends AbstractGameObject> localClass = null;
+    protected GameObjectType localObjectType;
 
-	protected final void prepareCallable(final String sql) {
-		try {
-			this.cs.set((CallableStatement) DbManager.getConn().prepareCall(sql, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY));
-		} catch (SQLException e) {
-			Logger.error("DbManager.getConn", e);
-			Logger.error("SQL Error number: " + e.getErrorCode());
-		}
-	}
+    protected <T extends AbstractGameObject> AbstractGameObject getObjectFromRs(ResultSet rs) {
 
-	protected final void setDate(int parameterIndex, Date value) {
-		try {
-			this.cs.get().setDate(parameterIndex, value);
-		} catch (SQLException e) {
-			Logger.error("SQL Error number: " + e.getErrorCode());
-		}
-	}
+        AbstractGameObject abstractGameObject = null;
 
-	protected final void setInt(int parameterIndex, int value) {
-		try {
-			this.cs.get().setInt(parameterIndex, value);
-		} catch (SQLException e) {
-			Logger.error("SQL Error number: " + e.getErrorCode());
-		}
-	}
+        try {
+            if (rs.next()) {
+                abstractGameObject = localClass.getConstructor(ResultSet.class).newInstance(rs);
 
-	protected final void setLong(int parameterIndex, long value) {
-		try {
-			this.cs.get().setLong(parameterIndex, value);
-		} catch (SQLException e) {
-			Logger.error("SQL Error number: " + e.getErrorCode());
-		}
-	}
+                DbManager.addToCache(abstractGameObject);
+            }
+        } catch (Exception e) {
+            Logger.error(e);
+        }
 
-	protected final void setFloat(int parameterIndex, float value) {
-		try {
-			this.cs.get().setFloat(parameterIndex, value);
-		} catch (SQLException e) {
-			Logger.error("SQL Error number: " + e.getErrorCode());
-		}
-	}
+        // Only call runAfterLoad() for objects instanced on the world server
 
-	protected final void setShort(int parameterIndex, short value) {
-		try {
-			this.cs.get().setShort(parameterIndex, value);
-		} catch (SQLException e) {
-			Logger.error("SQL Error number: " + e.getErrorCode());
-		}
-	}
+        if ((abstractGameObject != null && abstractGameObject instanceof AbstractWorldObject) &&
+                (ConfigManager.serverType.equals(Enum.ServerType.WORLDSERVER) ||
+                        (abstractGameObject.getObjectType() == GameObjectType.Guild)))
+            ((AbstractWorldObject) abstractGameObject).runAfterLoad();
 
-	protected final void setString(int parameterIndex, String value) {
-		try {
-			this.cs.get().setString(parameterIndex, value);
-		} catch (SQLException e) {
-			Logger.error("SQL Error number: " + e.getErrorCode());
-		}
-	}
+        return abstractGameObject;
+    }
 
-	protected final void setBytes(int parameterIndex, byte[] value) {
-		try {
-			this.cs.get().setBytes(parameterIndex, value);
-		} catch (SQLException e) {
-			Logger.error("SQL Error number: " + e.getErrorCode());
-		}
-	}
+    protected <T extends AbstractGameObject> ArrayList<T> getObjectsFromRs(ResultSet rs, int listSize) {
 
-	protected final void setByte(int parameterIndex, byte value) {
-		try {
-			this.cs.get().setByte(parameterIndex, value);
-		} catch (SQLException e) {
-			Logger.error("SQL Error number: " + e.getErrorCode());
-		}
-	}
+        ArrayList<T> objectList = new ArrayList<>(listSize);
 
-	protected final void setBoolean(int parameterIndex, boolean value) {
-		try {
-			this.cs.get().setBoolean(parameterIndex, value);
-		} catch (SQLException e) {
-			Logger.error("SQL Error number: " + e.getErrorCode());
-		}
-	}
+        try {
+            while (rs.next()) {
 
-	protected final void setNULL(int parameterIndex, int type) {
-		try {
-			this.cs.get().setNull(parameterIndex, type);
-		} catch (SQLException e) {
-			Logger.error("SQL Error number: " + e.getErrorCode());
-		}
-	}
+                int id = rs.getInt(1);
 
-	protected final void setLocalDateTime(int parameterIndex, LocalDateTime localDateTime) {
+                if (DbManager.inCache(localObjectType, id)) {
+                    objectList.add((T) DbManager.getFromCache(localObjectType, id));
+                } else {
+                    AbstractGameObject toAdd = localClass.getConstructor(ResultSet.class).newInstance(rs);
+                    DbManager.addToCache(toAdd);
+                    objectList.add((T) toAdd);
 
-		try {
-			this.cs.get().setTimestamp(parameterIndex, Timestamp.valueOf(localDateTime));
-		} catch (SQLException e) {
-			Logger.error("SQL Error number: " + e.getErrorCode());
-		}
-	}
-
-	protected final void setTimeStamp(int parameterIndex, long time) {
-		try {
-			this.cs.get().setTimestamp(parameterIndex, new java.sql.Timestamp(time));
-		} catch (SQLException e) {
-			Logger.error("SQL Error number: " + e.getErrorCode());
-		}
-	}
-
-	protected final boolean execute() {
-		try {
-			return this.cs.get().execute();
-		} catch (SQLException e) {
-			Logger.error("SQL Error number: " + e.getErrorCode());
-			logSQLCommand();
-		}
-		return false;
-	}
-
-	protected final ResultSet executeQuery() {
-		try {
-			return this.cs.get().executeQuery();
-		} catch (SQLException e) {
-			Logger.error("SQL Error number: " + e.getErrorCode());
-			logSQLCommand();
-		}
-		return null;
-	}
-
-	protected final int executeUpdate() {
-		return executeUpdate(true);
-	}
-
-	protected final int executeUpdate(boolean close) {
-		try {
-			return this.cs.get().executeUpdate();
-		} catch (SQLException e) {
-			Logger.error("SQL Error number: " + e.getErrorCode());
-			logSQLCommand();
-		} finally {
-			if (close)
-				closeCallable();
-		}
-		return 0;
-	}
-
-	protected final void logSQLCommand() {
-		try {
-			Logger.error("Failed SQL Command: " + this.cs.get().toString());
-		} catch (Exception e) {
-
-		}
-	}
-
-	// Common return values from the database when calling stored procedures, abstracted to this layer
-	protected final String getResult(){
-		try {
-			ResultSet rs = this.executeQuery();
-			if (rs.next() && !isError(rs))
-				return rs.getString("result");
-		} catch (SQLException e) {
-			Logger.error(e);
-			logSQLCommand();
-		} finally {
-			closeCallable();
-		}
-		return null;
-	}
-
-	// Used for Stored procedures that return true when they succeed.
-	protected final boolean worked() {
-		try {
-			ResultSet rs = this.executeQuery();
-			if (rs.next() && !isError(rs))
-				return rs.getBoolean("result");
-		} catch (SQLException e) {
-			Logger.error(e);
-			logSQLCommand();
-		} finally {
-			closeCallable();
-		}
-		return false;
-	}
-
-	// Common return values from the database when calling stored procedures, abstracted to this layer
-	protected final long getUUID(){
-		try {
-			ResultSet rs = this.executeQuery();
-			if (rs.next() && !isError(rs))
-				return rs.getLong("UID");
-		} catch (SQLException e) {
-			Logger.error(e);
-			logSQLCommand();
-		} finally {
-			closeCallable();
-		}
-		return -1;
-	}
-
-	protected final String getString(String field) {
-		try {
-			ResultSet rs = this.executeQuery();
-			if (rs.next())
-				return rs.getString(field);
-		} catch (SQLException e) {
-			Logger.error(e);
-			logSQLCommand();
-		} finally {
-			closeCallable();
-		}
-		return "";
-	}
-
-	protected final long getLong(String field) {
-		try {
-			ResultSet rs = this.executeQuery();
-			if (rs.next())
-				return rs.getLong(field);
-		} catch (SQLException e) {
-			Logger.error(e);
-			logSQLCommand();
-		} finally {
-			closeCallable();
-		}
-		return 0L;
-	}
-
-	protected final int getInt(String field) {
-		try {
-			ResultSet rs = this.executeQuery();
-			if (rs.next())
-				return rs.getInt(field);
-		} catch (SQLException e) {
-			Logger.error(e);
-			logSQLCommand();
-		} finally {
-			closeCallable();
-		}
-		return 0;
-	}
-
-	protected final int insertGetUUID() {
-		int key = 0;
-		try {
-			this.cs.get().executeUpdate();
-			ResultSet rs = this.cs.get().getGeneratedKeys();
-			if (rs.next())
-				key = rs.getInt(1);
-		} catch (SQLException e) {
-			Logger.error(e);
-			logSQLCommand();
-		} finally {
-			closeCallable();
-		}
-		return key;
-	}
-
-	protected final boolean isError(ResultSet rs) throws SQLException {
-		ResultSetMetaData rsmd = rs.getMetaData();
-		if (rsmd.getColumnCount() > 0 && !rsmd.getColumnName(1).equals("errorno"))
-			return false;
-		printError(rs);
-		return true;
-	}
-
-	protected final void printError(ResultSet rs) {
-		try {
-			int errorNum = rs.getInt("errorno");
-			String errorMsg = rs.getString("errormsg");
-			Logger.error("SQLError: errorNum: " + errorNum + ", errorMsg: " + errorMsg);
-			logSQLCommand();
-		} catch (SQLException e) {}
-	}
-
-	protected final void getColumNames(ResultSet rs) throws SQLException {
-		ResultSetMetaData rsmd = rs.getMetaData();
-		int numColumns = rsmd.getColumnCount();
-		String out = "Column names for resultSet: ";
-		for (int i=1; i<numColumns+1; i++)
-			out += i + ": " + rsmd.getColumnName(i) + ", ";
-		Logger.info(out);
-	}
-
-	// Default actions to the objects table, generic to all objects
-	protected final long SET_PARENT(long objUID, long new_value, long old_value) {
-		prepareCallable("CALL object_GETSETPARENT(?,?,?)");
-		setLong(1, objUID);
-		setLong(2, new_value);
-		setLong(3, old_value);
-		return getUUID();
-	}
-
-	// NOTE: CALLING THIS FUNCTION CASCADE DELETES OBJECTS FROM THE DATABASE
-	protected final long REMOVE(long objUID) {
-		prepareCallable("CALL object_PURGECASCADE(?)");
-		setLong(1, objUID);
-		return getUUID();
-	}
-
-	protected <T extends AbstractGameObject> AbstractGameObject getObjectSingle(int id) {
-		return getObjectSingle(id, false, true);
-	}
-
-	protected <T extends AbstractGameObject> AbstractGameObject getObjectSingle(int id, boolean forceFromDB, boolean storeInCache) {
-
-		if (cs.get() == null){
-			return null;
-		}
-
-		if (!forceFromDB) {
-			if (DbManager.inCache(localObjectType, id)) {
-				closeCallable();
-				return DbManager.getFromCache(localObjectType, id);
-			}
-		}
-
-		AbstractGameObject out = null;
-
-		try {
-			if (MBServerStatics.DB_ENABLE_QUERY_OUTPUT)
-				Logger.info( "[GetObjectList] Executing query:" + cs.get().toString());
-
-			ResultSet rs = cs.get().executeQuery();
-
-			if (rs.next()) {
-				out = localClass.getConstructor(ResultSet.class).newInstance(rs);
-
-				if (storeInCache)
-					DbManager.addToCache(out);
-			}
-
-			rs.close();
-
-		} catch (Exception e) {
-			Logger.error("AbstractGameObject", e);
-			out = null;
-		} finally {
-			closeCallable();
-		}
-
-		// Only call runAfterLoad() for objects instanced on the world server
-
-		if ((out != null && out instanceof AbstractWorldObject) &&
-				(ConfigManager.serverType.equals(Enum.ServerType.WORLDSERVER) ||
-						(out.getObjectType() == GameObjectType.Guild)))
-			((AbstractWorldObject)out).runAfterLoad();
-
-		return out;
-	}
-
-	protected void closeCallable() {
-		try {
-			if (this.cs.get() != null)
-				this.cs.get().close();
-		} catch (SQLException e) {}
-	}
-
-	protected <T extends AbstractGameObject> ArrayList<T> getObjectList() {
-		return getObjectList(20, false);
-	}
-
-	protected <T extends AbstractGameObject> ArrayList<T> getLargeObjectList() {
-		return getObjectList(2000, false);
-	}
-
-	@SuppressWarnings("unchecked")
-	protected <T extends AbstractGameObject> ArrayList<T> getObjectList(int listSize, boolean forceFromDB) {
-
-		String query = "No Callable Statement accessable.";
-
-		ArrayList<T> out = new ArrayList<>(listSize);
-
-		if (this.cs.get() == null)
-			return out;
-
-		try {
-
-			CallableStatement css = this.cs.get();
-
-			if (css != null)
-				query = this.cs.get().toString();
-
-			if (MBServerStatics.DB_ENABLE_QUERY_OUTPUT)
-				Logger.info( "[GetObjectList] Executing query:" + query);
-
-			ResultSet rs = this.cs.get().executeQuery();
-
-			while (rs.next()) {
-
-				int id = rs.getInt(1);
-
-				if (!forceFromDB && DbManager.inCache(localObjectType, id)) {
-					out.add((T) DbManager.getFromCache(localObjectType, id));
-				} else {
-					AbstractGameObject toAdd = localClass.getConstructor(ResultSet.class).newInstance(rs);
-					DbManager.addToCache(toAdd);
-					out.add((T) toAdd);
-
-					if (toAdd != null && toAdd instanceof AbstractWorldObject)
-						((AbstractWorldObject)toAdd).runAfterLoad();
-
-				}
-			}
-			rs.close();
-		} catch (Exception e) {
-			Logger.error(localClass.getCanonicalName(), "List Failure: " + query, e);
-			e.printStackTrace();
-			return new ArrayList<>(); // Do we want a null return on error?
-		} finally {
-			closeCallable();
-		}
-
-		return out;
-	}
-
-	/* Prepared Statements handled below this line */
-
-	protected HashSet<Integer> getIntegerList(final int columnNumber) {
-
-		if (MBServerStatics.DB_ENABLE_QUERY_OUTPUT)
-			Logger.info("[GetIntegerList] Executing query:" + this.cs.toString());
-
-		HashSet<Integer> out = new HashSet<>();
-
-		try {
-			ResultSet rs = executeQuery();
-
-			while (rs.next()) {
-				out.add(rs.getInt(columnNumber));
-			}
-			rs.close();
-		} catch (SQLException e) {
-			Logger.error("SQL Error number: " + e.getErrorCode());
-		} finally {
-			closeCallable();
-		}
-		return out;
-	}
+                    if (toAdd != null && toAdd instanceof AbstractWorldObject)
+                        ((AbstractWorldObject) toAdd).runAfterLoad();
+                }
+            }
+        } catch (Exception e) {
+            Logger.error(e);
+        }
+        return objectList;
+    }
 }

src/engine/db/handlers/dbHeightMapHandler.java

@@ -1,47 +1,43 @@
 package engine.db.handlers;
 
 import engine.InterestManagement.HeightMap;
+import engine.gameManager.DbManager;
 import org.pmw.tinylog.Logger;
 
+import java.sql.Connection;
+import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 
 public class dbHeightMapHandler extends dbHandlerBase {
 
-	public dbHeightMapHandler() {
+    public dbHeightMapHandler() {
 
 
-	}
+    }
 
-	public void LOAD_ALL_HEIGHTMAPS() {
+    public void LOAD_ALL_HEIGHTMAPS() {
 
-		HeightMap thisHeightmap;
+        HeightMap thisHeightmap;
+        HeightMap.heightMapsCreated = 0;
 
-		int recordsRead = 0;
-		int worthlessDupes = 0;
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM static_zone_heightmap INNER JOIN static_zone_size ON static_zone_size.loadNum = static_zone_heightmap.zoneLoadID")) {
 
-		HeightMap.heightMapsCreated = 0;
+            ResultSet rs = preparedStatement.executeQuery();
 
-		prepareCallable("SELECT * FROM static_zone_heightmap INNER JOIN static_zone_size ON static_zone_size.loadNum = static_zone_heightmap.zoneLoadID");
+            while (rs.next()) {
+                thisHeightmap = new HeightMap(rs);
 
-		try {
-			ResultSet rs = executeQuery();
+                if (thisHeightmap.getHeightmapImage() == null) {
+                    Logger.info("Imagemap for " + thisHeightmap.getHeightMapID() + " was null");
+                    continue;
+                }
+            }
 
-			while (rs.next()) {
-
-				recordsRead++;
-				thisHeightmap = new HeightMap(rs);
-
-				if (thisHeightmap.getHeightmapImage() == null) {
-					Logger.info( "Imagemap for " + thisHeightmap.getHeightMapID() + " was null");
-					continue;
-				}
-			}
-		} catch (SQLException e) {
-			Logger.error("LoadAllHeightMaps: " + e.getErrorCode() + ' ' + e.getMessage(), e);
-		} finally {
-			closeCallable();
-		}
-	}
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+    }
 
 }

src/engine/db/handlers/dbItemBaseHandler.java

@@ -9,10 +9,13 @@
 
 package engine.db.handlers;
 
+import engine.gameManager.DbManager;
 import engine.objects.BootySetEntry;
 import engine.objects.ItemBase;
 import org.pmw.tinylog.Logger;
 
+import java.sql.Connection;
+import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.ArrayList;
@@ -20,29 +23,26 @@ import java.util.HashMap;
 
 public class dbItemBaseHandler extends dbHandlerBase {
 
-	public dbItemBaseHandler() {
+    public dbItemBaseHandler() {
 
 	}
 
 	public void LOAD_BAKEDINSTATS(ItemBase itemBase) {
 
-		try {
-			prepareCallable("SELECT * FROM `static_item_bakedinstat` WHERE `itemID` = ?");
-			setInt(1, itemBase.getUUID());
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `static_item_bakedinstat` WHERE `itemID` = ?")) {
 
-			ResultSet rs = executeQuery();
+			preparedStatement.setInt(1, itemBase.getUUID());
+			ResultSet rs = preparedStatement.executeQuery();
 
 			while (rs.next()) {
-
 				if (rs.getBoolean("fromUse"))
 					itemBase.getUsedStats().put(rs.getInt("token"), rs.getInt("numTrains"));
 				else
 					itemBase.getBakedInStats().put(rs.getInt("token"), rs.getInt("numTrains"));
 			}
 		} catch (SQLException e) {
-			Logger.error( e.toString());
-		} finally {
-			closeCallable();
+			Logger.error(e);
 		}
 	}
 
@@ -50,27 +50,24 @@ public class dbItemBaseHandler extends dbHandlerBase {
 
 		ArrayList<Integer> tempList = new ArrayList<>();
 		ArrayList<Integer> tempListOff = new ArrayList<>();
-		try {
-			prepareCallable("SELECT * FROM `static_itembase_animations` WHERE `itemBaseUUID` = ?");
-			setInt(1, itemBase.getUUID());
 
-			ResultSet rs = executeQuery();
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `static_itembase_animations` WHERE `itemBaseUUID` = ?")) {
+
+			preparedStatement.setInt(1, itemBase.getUUID());
+			ResultSet rs = preparedStatement.executeQuery();
 
 			while (rs.next()) {
 				int animation = rs.getInt("animation");
-
 				boolean rightHand = rs.getBoolean("rightHand");
 
 				if (rightHand)
 					tempList.add(animation);
 				else
 					tempListOff.add(animation);
-
 			}
 		} catch (SQLException e) {
-			Logger.error( e.toString());
-		} finally {
-			closeCallable();
+			Logger.error(e);
 		}
 
 		itemBase.setAnimations(tempList);
@@ -80,44 +77,37 @@ public class dbItemBaseHandler extends dbHandlerBase {
 	public void LOAD_ALL_ITEMBASES() {
 
 		ItemBase itemBase;
-
 		int recordsRead = 0;
 
-		prepareCallable("SELECT * FROM static_itembase");
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM static_itembase")) {
 
-		try {
-			ResultSet rs = executeQuery();
+			ResultSet rs = preparedStatement.executeQuery();
 
 			while (rs.next()) {
-
 				recordsRead++;
 				itemBase = new ItemBase(rs);
-
-				// Add ItemBase to internal cache
-
 				ItemBase.addToCache(itemBase);
 			}
 
-			Logger.info( "read: " + recordsRead + "cached: " + ItemBase.getUUIDCache().size());
-
 		} catch (SQLException e) {
-			Logger.error( e.toString());
-		} finally {
-			closeCallable();
+			Logger.error(e);
 		}
+
+		Logger.info("read: " + recordsRead + " cached: " + ItemBase.getUUIDCache().size());
 	}
 
 	public HashMap<Integer, ArrayList<Integer>> LOAD_RUNES_FOR_NPC_AND_MOBS() {
 
 		HashMap<Integer, ArrayList<Integer>> runeSets = new HashMap<>();
-		int	runeSetID;
+		int runeSetID;
 		int runeBaseID;
 		int recordsRead = 0;
 
-		prepareCallable("SELECT * FROM static_npc_runeSet");
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM static_npc_runeSet")) {
 
-		try {
-			ResultSet rs = executeQuery();
+			ResultSet rs = preparedStatement.executeQuery();
 
 			while (rs.next()) {
 
@@ -126,25 +116,23 @@ public class dbItemBaseHandler extends dbHandlerBase {
 				runeSetID = rs.getInt("runeSet");
 				runeBaseID = rs.getInt("runeBase");
 
-				if (runeSets.get(runeSetID) == null){
+				if (runeSets.get(runeSetID) == null) {
 					ArrayList<Integer> runeList = new ArrayList<>();
 					runeList.add(runeBaseID);
 					runeSets.put(runeSetID, runeList);
-				}
-				else{
-					ArrayList<Integer>runeList = runeSets.get(runeSetID);
+				} else {
+					ArrayList<Integer> runeList = runeSets.get(runeSetID);
 					runeList.add(runeSetID);
 					runeSets.put(runeSetID, runeList);
 				}
 			}
 
-			Logger.info("read: " + recordsRead + " cached: " + runeSets.size());
-
 		} catch (SQLException e) {
-			Logger.error( e.toString());
-		} finally {
-			closeCallable();
+			Logger.error(e);
+			return runeSets;
 		}
+
+		Logger.info("read: " + recordsRead + " cached: " + runeSets.size());
 		return runeSets;
 	}
 
@@ -152,14 +140,13 @@ public class dbItemBaseHandler extends dbHandlerBase {
 
 		HashMap<Integer, ArrayList<BootySetEntry>> bootySets = new HashMap<>();
 		BootySetEntry bootySetEntry;
-		int	bootySetID;
-
+		int bootySetID;
 		int recordsRead = 0;
 
-		prepareCallable("SELECT * FROM static_npc_bootySet");
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM static_npc_bootySet")) {
 
-		try {
-			ResultSet rs = executeQuery();
+			ResultSet rs = preparedStatement.executeQuery();
 
 			while (rs.next()) {
 
@@ -168,25 +155,22 @@ public class dbItemBaseHandler extends dbHandlerBase {
 				bootySetID = rs.getInt("bootySet");
 				bootySetEntry = new BootySetEntry(rs);
 
-				if (bootySets.get(bootySetID) == null){
+				if (bootySets.get(bootySetID) == null) {
 					ArrayList<BootySetEntry> bootyList = new ArrayList<>();
 					bootyList.add(bootySetEntry);
 					bootySets.put(bootySetID, bootyList);
-				}
-				else{
-					ArrayList<BootySetEntry>bootyList = bootySets.get(bootySetID);
+				} else {
+					ArrayList<BootySetEntry> bootyList = bootySets.get(bootySetID);
 					bootyList.add(bootySetEntry);
 					bootySets.put(bootySetID, bootyList);
 				}
 			}
-
-			Logger.info("read: " + recordsRead + " cached: " + bootySets.size());
-
 		} catch (SQLException e) {
-			Logger.error( e.toString());
-		} finally {
-			closeCallable();
+			Logger.error(e);
+			return bootySets;
 		}
+
+		Logger.info("read: " + recordsRead + " cached: " + bootySets.size());
 		return bootySets;
 	}
 }

src/engine/db/handlers/dbItemHandler.java

@@ -11,420 +11,489 @@ package engine.db.handlers;
 
 import engine.Enum.ItemContainerType;
 import engine.Enum.ItemType;
-import engine.Enum.OwnerType;
-import engine.objects.*;
+import engine.gameManager.DbManager;
+import engine.objects.AbstractCharacter;
+import engine.objects.CharacterItemManager;
+import engine.objects.Item;
 import org.pmw.tinylog.Logger;
 
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
 import java.util.ArrayList;
 import java.util.HashSet;
 
 
 public class dbItemHandler extends dbHandlerBase {
 
-	public dbItemHandler() {
-		this.localClass = Item.class;
-		this.localObjectType = engine.Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
-	}
+    public dbItemHandler() {
+        this.localClass = Item.class;
+        this.localObjectType = engine.Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
+    }
 
-	public Item ADD_ITEM(Item toAdd) {
-		prepareCallable("CALL `item_CREATE`(?, ?, ?, ?, ?, ?, ?, ?, ?,?);");
-		setInt(1, toAdd.getOwnerID());
-		setInt(2, toAdd.getItemBaseID());
-		setInt(3, toAdd.getChargesRemaining());
-		setInt(4, toAdd.getDurabilityCurrent());
-		setInt(5, toAdd.getDurabilityMax());
-		if (toAdd.getNumOfItems() < 1)
-			setInt(6, 1);
-		else
-			setInt(6, toAdd.getNumOfItems());
+    private static String formatTradeString(HashSet<Integer> list) {
+        int size = list.size();
 
-		switch (toAdd.containerType) {
-			case INVENTORY:
-				setString(7, "inventory");
-				break;
-			case EQUIPPED:
-				setString(7, "equip");
-				break;
-			case BANK:
-				setString(7, "bank");
-				break;
-			case VAULT:
-				setString(7, "vault");
-				break;
-			case FORGE:
-				setString(7, "forge");
-				break;
-				default:
-					setString(7, "none"); //Shouldn't be here
-					break;
-		}
+        String ret = "";
 
-		setByte(8, toAdd.getEquipSlot());
-		setInt(9, toAdd.getFlags());
-		setString(10, toAdd.getCustomName());
-		int objectUUID = (int) getUUID();
+        if (size == 0)
+            return ret;
 
-		if (objectUUID > 0)
-			return GET_ITEM(objectUUID);
-		return null;
-	}
+        boolean start = true;
 
-	public boolean DELETE_ITEM(final Item item) {
-		prepareCallable("DELETE FROM `object` WHERE `UID`=? && `type`='item' limit 1");
-		setLong(1, (long) item.getObjectUUID());
-		return (executeUpdate() > 0);
-	}
+        for (int i : list) {
+            if (start) {
+                ret += i;
+                start = false;
+            } else
+                ret += "," + i;
+        }
+        return ret;
+    }
 
-	public boolean DELETE_ITEM(final int itemUUID) {
-		prepareCallable("DELETE FROM `object` WHERE `UID`=? && `type`='item' limit 1");
-		setLong(1, (long) itemUUID);
-		return (executeUpdate() > 0);
-	}
+    public Item ADD_ITEM(Item toAdd) {
 
-	public String GET_OWNER(int ownerID) {
-		prepareCallable("SELECT `type` FROM `object` WHERE `UID`=?");
-		setLong(1, (long) ownerID);
-		return getString("type");
-	}
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("CALL `item_CREATE`(?, ?, ?, ?, ?, ?, ?, ?, ?,?);")) {
 
-	public boolean DO_TRADE(HashSet<Integer> from1, HashSet<Integer> from2,
-			CharacterItemManager man1, CharacterItemManager man2,
-			Item inventoryGold1, Item inventoryGold2, int goldFrom1, int goldFrom2) {
+            preparedStatement.setInt(1, toAdd.getOwnerID());
+            preparedStatement.setInt(2, toAdd.getItemBaseID());
+            preparedStatement.setInt(3, toAdd.getChargesRemaining());
+            preparedStatement.setInt(4, toAdd.getDurabilityCurrent());
+            preparedStatement.setInt(5, toAdd.getDurabilityMax());
 
-		AbstractCharacter ac1 = man1.getOwner();
-		AbstractCharacter ac2 = man2.getOwner();
-		if (ac1 == null || ac2 == null || inventoryGold1 == null || inventoryGold2 == null)
-			return false;
+            if (toAdd.getNumOfItems() < 1)
+                preparedStatement.setInt(6, 1);
+            else
+                preparedStatement.setInt(6, toAdd.getNumOfItems());
 
-		prepareCallable("CALL `item_TRADE`(?, ?, ?, ?, ?, ?, ?, ?)");
-		setString(1, formatTradeString(from1));
-		setLong(2, (long) ac1.getObjectUUID());
-		setString(3, formatTradeString(from2));
-		setLong(4, (long) ac2.getObjectUUID());
-		setInt(5, goldFrom1);
-		setLong(6, (long) inventoryGold1.getObjectUUID());
-		setInt(7, goldFrom2);
-		setLong(8, (long) inventoryGold2.getObjectUUID());
-        return worked();
-	}
+            switch (toAdd.containerType) {
+                case INVENTORY:
+                    preparedStatement.setString(7, "inventory");
+                    break;
+                case EQUIPPED:
+                    preparedStatement.setString(7, "equip");
+                    break;
+                case BANK:
+                    preparedStatement.setString(7, "bank");
+                    break;
+                case VAULT:
+                    preparedStatement.setString(7, "vault");
+                    break;
+                case FORGE:
+                    preparedStatement.setString(7, "forge");
+                    break;
+                default:
+                    preparedStatement.setString(7, "none"); //Shouldn't be here
+                    break;
+            }
 
-	private static String formatTradeString(HashSet<Integer> list) {
-		int size = list.size();
+            preparedStatement.setByte(8, toAdd.getEquipSlot());
+            preparedStatement.setInt(9, toAdd.getFlags());
+            preparedStatement.setString(10, toAdd.getCustomName());
 
-		String ret = "";
-		if (size == 0)
-			return ret;
-		boolean start = true;
-		for (int i : list) {
-			if (start){
-				ret += i;
-				start = false;
-			}
-			else
-			ret += "," + i;
-		}
-		return ret;
-	}
+            ResultSet rs = preparedStatement.executeQuery();
 
-	public ArrayList<Item> GET_EQUIPPED_ITEMS(final int targetId) {
-		prepareCallable("SELECT `obj_item`.*, `object`.`parent`, `object`.`type` FROM `object` INNER JOIN `obj_item` ON `object`.`UID` = `obj_item`.`UID` WHERE `object`.`parent`=? && `obj_item`.`item_container`='equip';");
-		setLong(1, (long) targetId);
-		return getObjectList();
-	}
+            if (rs.next()) {
+                int objectUUID = (int) rs.getLong("UID");
 
-	public Item GET_ITEM(final int id) {
+                if (objectUUID > 0)
+                    return GET_ITEM(objectUUID);
+            }
 
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
 
-		prepareCallable("SELECT `obj_item`.*, `object`.`parent`, `object`.`type` FROM `object` INNER JOIN `obj_item` ON `object`.`UID` = `obj_item`.`UID` WHERE `object`.`UID`=?;");
-		setLong(1, (long) id);
-		return (Item) getObjectSingle(id);
-	}
+        return null;
+    }
 
-	public Item GET_GOLD_FOR_PLAYER(final int playerID, final int goldID, int worldID) {
-		prepareCallable("SELECT `obj_item`.*, `object`.`parent`, `object`.`type` FROM `object` INNER JOIN `obj_item` ON `object`.`UID` = `obj_item`.`UID` WHERE `object`.`parent`=? AND `obj_item`.`item_itembaseID`=?;");
-		setInt(1, playerID);
-		setInt(2, goldID);
-		int objectUUID = (int) getUUID();
-		return (Item) getObjectSingle(objectUUID);
+    public boolean DO_TRADE(HashSet<Integer> from1, HashSet<Integer> from2,
+                            CharacterItemManager man1, CharacterItemManager man2,
+                            Item inventoryGold1, Item inventoryGold2, int goldFrom1, int goldFrom2) {
 
-	}
+        AbstractCharacter ac1 = man1.getOwner();
+        AbstractCharacter ac2 = man2.getOwner();
+        boolean worked = false;
 
-	public ArrayList<Item> GET_ITEMS_FOR_ACCOUNT(final int accountId) {
-		prepareCallable("SELECT `obj_item`.*, `object`.`parent`, `object`.`type` FROM `object` INNER JOIN `obj_item` ON `object`.`UID` = `obj_item`.`UID` WHERE `object`.`parent`=?;");
-		setLong(1, (long) accountId);
-		return getObjectList();
-	}
+        if (ac1 == null || ac2 == null || inventoryGold1 == null || inventoryGold2 == null)
+            return false;
 
-	public ArrayList<Item> GET_ITEMS_FOR_NPC(final int npcId) {
-		prepareCallable("SELECT `obj_item`.*, `object`.`parent`, `object`.`type` FROM `object` INNER JOIN `obj_item` ON `object`.`UID` = `obj_item`.`UID` WHERE `object`.`parent`=?");
-		setLong(1, (long) npcId);
-		return getObjectList();
-	}
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("CALL `item_TRADE`(?, ?, ?, ?, ?, ?, ?, ?)")) {
 
-	public ArrayList<Item> GET_ITEMS_FOR_PC(final int id) {
-		prepareCallable("SELECT `obj_item`.*, `object`.`parent`, `object`.`type` FROM `object` INNER JOIN `obj_item` ON `object`.`UID` = `obj_item`.`UID` WHERE `object`.`parent`=?");
-		setLong(1, (long) id);
-		return getLargeObjectList();
-	}
+            preparedStatement.setString(1, formatTradeString(from1));
+            preparedStatement.setLong(2, ac1.getObjectUUID());
+            preparedStatement.setString(3, formatTradeString(from2));
+            preparedStatement.setLong(4, ac2.getObjectUUID());
+            preparedStatement.setInt(5, goldFrom1);
+            preparedStatement.setLong(6, inventoryGold1.getObjectUUID());
+            preparedStatement.setInt(7, goldFrom2);
+            preparedStatement.setLong(8, inventoryGold2.getObjectUUID());
 
-	public ArrayList<Item> GET_ITEMS_FOR_PLAYER_AND_ACCOUNT(final int playerID, final int accountID) {
-		prepareCallable("SELECT `obj_item`.*, `object`.`parent`, `object`.`type` FROM `object` INNER JOIN `obj_item` ON `object`.`UID` = `obj_item`.`UID` WHERE (`object`.`parent`=? OR `object`.`parent`=?)");
-		setLong(1, (long) playerID);
-		setLong(2, (long) accountID);
-		return getLargeObjectList();
-	}
+            ResultSet rs = preparedStatement.executeQuery();
 
-	public boolean MOVE_GOLD(final Item from, final Item to, final int amt) {
-		int newFromAmt = from.getNumOfItems() - amt;
-		int newToAmt = to.getNumOfItems() + amt;
-		prepareCallable("UPDATE `obj_item` SET `item_numberOfItems` = CASE WHEN `UID`=?  THEN ? WHEN `UID`=? THEN ? END WHERE `UID` IN (?, ?);");
-		setLong(1, (long) from.getObjectUUID());
-		setInt(2, newFromAmt);
-		setLong(3, (long) to.getObjectUUID());
-		setInt(4, newToAmt);
-		setLong(5, (long) from.getObjectUUID());
-		setLong(6, (long) to.getObjectUUID());
-		return (executeUpdate() != 0);
-	}
+            if (rs.next())
+                worked = rs.getBoolean("result");
 
-	public boolean ORPHAN_INVENTORY(final HashSet<Item> inventory) {
-		boolean worked = true;
-		for (Item item : inventory) {
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return worked;
+    }
 
-			if (item.getItemBase().getType().equals(ItemType.GOLD))
-				continue;
+    public ArrayList<Item> GET_EQUIPPED_ITEMS(final int targetId) {
 
-			prepareCallable("UPDATE `obj_item` LEFT JOIN `object` ON `object`.`UID` = `obj_item`.`UID` SET `object`.`parent`=NULL, `obj_item`.`item_container`='none' WHERE `object`.`UID`=?;");
-			setLong(1, (long) item.getObjectUUID());
-			if (executeUpdate() == 0)
-				worked = false;
-			else
-				item.zeroItem();
-		}
-		return worked;
-	}
+        ArrayList<Item> itemList;
 
-	public Item PURCHASE_ITEM_FROM_VENDOR(final PlayerCharacter pc, final ItemBase ib) {
-		Item item = null;
-		byte charges = 0;
-		charges = (byte) ib.getNumCharges();
-		short durability = (short) ib.getDurability();
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT `obj_item`.*, `object`.`parent`, `object`.`type` FROM `object` INNER JOIN `obj_item` ON `object`.`UID` = `obj_item`.`UID` WHERE `object`.`parent`=? && `obj_item`.`item_container`='equip';")) {
 
-		Item temp = new Item(ib, pc.getObjectUUID(),
-				OwnerType.PlayerCharacter, charges, charges, durability, durability,
-				true, false,ItemContainerType.INVENTORY, (byte) 0,
-                new ArrayList<>(),"");
-		try {
-			item = this.ADD_ITEM(temp);
-		} catch (Exception e) {
-			Logger.error(e);
-		}
-		return item;
-	}
+            preparedStatement.setLong(1, targetId);
+            ResultSet rs = preparedStatement.executeQuery();
 
-	public HashSet<Integer> GET_ITEMS_FOR_VENDOR(final int vendorID) {
-		prepareCallable("SELECT ID FROM static_itembase WHERE vendorType = ?");
-		setInt(1, vendorID);
-		return getIntegerList(1);
-	}
+            itemList = getObjectsFromRs(rs, 10);
 
-	public ArrayList<Item> GET_ITEMS_FOR_VENDOR_FORGING(final int npcID) {
-		prepareCallable("SELECT `obj_item`.*, `object`.`parent` FROM `object` INNER JOIN `obj_item` ON `object`.`UID` = `obj_item`.`UID` WHERE `object`.`parent`=? AND `obj_item`.`item_container` =?");
-		setLong(1, (long) npcID);
-		setString(2, "forge");
-		return getObjectList();
-	}
+        } catch (SQLException e) {
+            Logger.error(e);
+            return null;
+        }
 
-	public String SET_PROPERTY(final Item i, String name, Object new_value) {
-		prepareCallable("CALL item_SETPROP(?,?,?)");
-		setLong(1, (long) i.getObjectUUID());
-		setString(2, name);
-		setString(3, String.valueOf(new_value));
-		return getResult();
-	}
+        return itemList;
+    }
 
-	public String SET_PROPERTY(final Item i, String name, Object new_value, Object old_value) {
-		prepareCallable("CALL item_GETSETPROP(?,?,?,?)");
-		setLong(1, (long) i.getObjectUUID());
-		setString(2, name);
-		setString(3, String.valueOf(new_value));
-		setString(4, String.valueOf(old_value));
-		return getResult();
-	}
+    public Item GET_ITEM(final int itemUUID) {
 
-	//Used to transfer a single item between owners or equip or vault or bank or inventory
-	public boolean UPDATE_OWNER(final Item item, int newOwnerID, boolean ownerNPC, boolean ownerPlayer,
-			boolean ownerAccount, ItemContainerType containerType, int slot) {
+        Item item;
 
-		prepareCallable("CALL `item_TRANSFER_OWNER`(?, ?, ?, ? )");
-		setLong(1, (long) item.getObjectUUID());
-		if (newOwnerID != 0)
-			setLong(2, (long) newOwnerID);
-		else
-			setNULL(2, java.sql.Types.BIGINT);
-		
-		switch (containerType) {
-			case INVENTORY:
-				setString(3, "inventory");
-				break;
-			case EQUIPPED:
-				setString(3, "equip");
-				break;
-			case BANK:
-				setString(3, "bank");
-				break;
-			case VAULT:
-				setString(3, "vault");
-				break;
-			case FORGE:
-				setString(3, "forge");
-				break;
-			default:
-				setString(3, "none"); //Shouldn't be here
-				break;
-		}
-		setInt(4, slot);
-		return worked();
-	}
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT `obj_item`.*, `object`.`parent`, `object`.`type` FROM `object` INNER JOIN `obj_item` ON `object`.`UID` = `obj_item`.`UID` WHERE `object`.`UID`=?;")) {
 
-	public boolean SET_DURABILITY(final Item item, int value) {
-		prepareCallable("UPDATE `obj_item` SET `item_durabilityCurrent`=? WHERE `UID`=? AND `item_durabilityCurrent`=?");
-		setInt(1, value);
-		setLong(2, (long) item.getObjectUUID());
-		setInt(3, (int) item.getDurabilityCurrent());
-		return (executeUpdate() != 0);
+            preparedStatement.setLong(1, itemUUID);
+            ResultSet rs = preparedStatement.executeQuery();
 
-	}
+            item = (Item) getObjectFromRs(rs);
 
-	//Update an item except ownership
-	public boolean UPDATE_DATABASE(final Item item) {
-		prepareCallable("UPDATE `obj_item` SET `item_itembaseID`=?, `item_chargesRemaining`=?, `item_durabilityCurrent`=?, `item_durabilityMax`=?, `item_numberOfItems`=? WHERE `UID`=?");
-		setInt(1, item.getItemBaseID());
-		setInt(2, item.getChargesRemaining());
-		setInt(3, item.getDurabilityCurrent());
-		setInt(4, item.getDurabilityMax());
-		setInt(5, item.getNumOfItems());
-		setLong(6, (long) item.getObjectUUID());
-		return (executeUpdate() != 0);
-	}
+        } catch (SQLException e) {
+            Logger.error(e);
+            return null;
+        }
+        return item;
+    }
 
-	public boolean UPDATE_ROLL_COMPLETE(final Item item) {
-		prepareCallable("UPDATE `obj_item` SET `item_container` = ?, `item_dateToUpgrade` = ? WHERE `UID` = ?");
-		setString(1, "forge");
-		setLong(2, 0L);
-		setLong(3, (long) item.getObjectUUID());
-		return (executeUpdate() != 0);
-	}
+    public ArrayList<Item> GET_ITEMS_FOR_ACCOUNT(final int accountId) {
 
-	public boolean SET_DATE_TO_UPGRADE(final Item item, long date) {
-		prepareCallable("UPDATE `obj_item` SET `item_dateToUPGRADE` = ? WHERE `UID` = ?");
-		setLong(1, date);
-		setLong(2, (long) item.getObjectUUID());
-		return (executeUpdate() != 0);
-	}
+        ArrayList<Item> itemList;
 
-	public boolean UPDATE_FORGE_TO_INVENTORY(final Item item) {
-		prepareCallable("UPDATE `obj_item` SET `item_container` = ? WHERE `UID` = ? AND `item_container` = 'forge';");
-		setString(1, "inventory");
-		setLong(2, (long) item.getObjectUUID());
-		return (executeUpdate() != 0);
-	}
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT `obj_item`.*, `object`.`parent`, `object`.`type` FROM `object` INNER JOIN `obj_item` ON `object`.`UID` = `obj_item`.`UID` WHERE `object`.`parent`=?;")) {
 
-	/**
-	 * Attempts to update the quantity of this gold item
-	 *
-	 * @param value New quantity of gold
-	 * @return True on success
-	 */
-	public boolean UPDATE_GOLD(final Item item, int value) {
-		if (item == null)
-			return false;
-		return UPDATE_GOLD(item, value, item.getNumOfItems());
-	}
+            preparedStatement.setLong(1, accountId);
+            ResultSet rs = preparedStatement.executeQuery();
 
-	/**
-	 * Attempts to update the quantity of this gold item using CAS
-	 *
-	 * @return True on success
-	 */
-	public boolean UPDATE_GOLD(final Item item, int newValue, int oldValue) {
+            itemList = getObjectsFromRs(rs, 100);
 
-		if (item.getItemBase().getType().equals(ItemType.GOLD) == false)
-			return false;
+        } catch (SQLException e) {
+            Logger.error(e);
+            return null;
+        }
+        return itemList;
+    }
 
-		prepareCallable("UPDATE `obj_item` SET `item_numberOfItems`=? WHERE `UID`=?");
-		setInt(1, newValue);
-		setLong(2, (long) item.getObjectUUID());
-		return (executeUpdate() != 0);
-	}
+    public ArrayList<Item> GET_ITEMS_FOR_NPC(final int npcId) {
 
-	/**
-	 * Attempts to update the value of two Gold items simultaneously.
-	 *
-	 * @param value New gold quantity for this item
-	 * @param otherGold Other Gold item being modified
-	 * @param valueOtherGold New quantity of gold for other item
-	 * @return True on success
-	 */
-	public boolean UPDATE_GOLD(Item gold, int value, Item otherGold, int valueOtherGold) {
+        ArrayList<Item> itemList;
 
-		if (gold.getItemBase().getType().equals(ItemType.GOLD) == false)
-			return false;
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT `obj_item`.*, `object`.`parent`, `object`.`type` FROM `object` INNER JOIN `obj_item` ON `object`.`UID` = `obj_item`.`UID` WHERE `object`.`parent`=?;")) {
 
-		if (otherGold.getItemBase().getType().equals(ItemType.GOLD) == false)
-			return false;
+            preparedStatement.setLong(1, npcId);
+            ResultSet rs = preparedStatement.executeQuery();
 
-		int firstOld = gold.getNumOfItems();
-		int secondOld = gold.getNumOfItems();
+            itemList = getObjectsFromRs(rs, 20);
 
-		prepareCallable("UPDATE `obj_item` SET `item_numberOfItems` = CASE WHEN `UID`=? AND `item_numberOfItems`=? THEN ? WHEN `UID`=? AND `item_numberOfItems`=? THEN ? END WHERE `UID` IN (?, ?);");
-		setLong(1, (long) gold.getObjectUUID());
-		setInt(2, firstOld);
-		setInt(3, value);
-		setLong(4, (long) otherGold.getObjectUUID());
-		setInt(5, secondOld);
-		setInt(6, valueOtherGold);
-		setLong(7, (long) gold.getObjectUUID());
-		setLong(8, (long) otherGold.getObjectUUID());
-		return (executeUpdate() != 0);
-	}
+        } catch (SQLException e) {
+            Logger.error(e);
+            return null;
+        }
+        return itemList;
+    }
 
-	public boolean UPDATE_REMAINING_CHARGES(final Item item) {
-		prepareCallable("UPDATE `obj_item` SET `item_chargesRemaining` = ? WHERE `UID` = ?");
-		setInt(1, item.getChargesRemaining());
-		setLong(2, (long) item.getObjectUUID());
-		return (executeUpdate() != 0);
-	}
+    public ArrayList<Item> GET_ITEMS_FOR_PC(final int id) {
 
-	// This is necessary because default number of items is 1.
-	// When we create gold, we want it to start at 0 quantity.
+        ArrayList<Item> itemList;
 
-	public boolean ZERO_ITEM_STACK(Item item) {
-		prepareCallable("UPDATE `obj_item` SET `item_numberOfItems`=0 WHERE `UID` = ?");
-		setLong(1, (long) item.getObjectUUID());
-		return (executeUpdate() != 0);
-	}
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT `obj_item`.*, `object`.`parent`, `object`.`type` FROM `object` INNER JOIN `obj_item` ON `object`.`UID` = `obj_item`.`UID` WHERE `object`.`parent`=?")) {
 
-	public boolean UPDATE_FLAGS(Item item) {
-		prepareCallable("UPDATE `obj_item` SET `item_flags`=? WHERE `UID` = ?");
-		setInt(1, item.getFlags());
-		setLong(2, (long) item.getObjectUUID());
-		return (executeUpdate() != 0);
-	}
+            preparedStatement.setLong(1, id);
+            ResultSet rs = preparedStatement.executeQuery();
 
-	public boolean UPDATE_VALUE(Item item,int value) {
-		prepareCallable("UPDATE `obj_item` SET `item_value`=? WHERE `UID` = ?");
-		setInt(1, value);
-		setLong(2, (long) item.getObjectUUID());
-		return (executeUpdate() != 0);
-	}
+            itemList = getObjectsFromRs(rs, 100);
 
-	public boolean UPDATE_FLAGS(Item item, int flags) {
-		prepareCallable("UPDATE `obj_item` SET `item_flags`=? WHERE `UID` = ?");
-		setInt(1, flags);
-		setLong(2, (long) item.getObjectUUID());
-		return (executeUpdate() != 0);
-	}
+        } catch (SQLException e) {
+            Logger.error(e);
+            return null;
+        }
+        return itemList;
+    }
 
+    public boolean MOVE_GOLD(final Item from, final Item to, final int amt) {
 
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_item` SET `item_numberOfItems` = CASE WHEN `UID`=?  THEN ? WHEN `UID`=? THEN ? END WHERE `UID` IN (?, ?);")) {
+
+            int newFromAmt = from.getNumOfItems() - amt;
+            int newToAmt = to.getNumOfItems() + amt;
+
+            preparedStatement.setLong(1, from.getObjectUUID());
+            preparedStatement.setInt(2, newFromAmt);
+            preparedStatement.setLong(3, to.getObjectUUID());
+            preparedStatement.setInt(4, newToAmt);
+            preparedStatement.setLong(5, from.getObjectUUID());
+            preparedStatement.setLong(6, to.getObjectUUID());
+
+            return (preparedStatement.executeUpdate() > 0);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return false;
+    }
+
+    public boolean ORPHAN_INVENTORY(final HashSet<Item> inventory) {
+
+        boolean worked = true;
+
+        for (Item item : inventory) {
+
+            if (item.getItemBase().getType().equals(ItemType.GOLD))
+                continue;
+
+            try (Connection connection = DbManager.getConnection();
+                 PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_item` LEFT JOIN `object` ON `object`.`UID` = `obj_item`.`UID` SET `object`.`parent`=NULL, `obj_item`.`item_container`='none' WHERE `object`.`UID`=?;")) {
+
+                preparedStatement.setLong(1, item.getObjectUUID());
+                worked = (preparedStatement.executeUpdate() > 0);
+
+                if (worked)
+                    item.zeroItem();
+
+            } catch (SQLException e) {
+                Logger.error(e);
+                return false;
+            }
+        }
+        return worked;
+    }
+
+    public HashSet<Integer> GET_ITEMS_FOR_VENDOR(final int vendorID) {
+
+        HashSet<Integer> itemSet = new HashSet<>();
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT ID FROM static_itembase WHERE vendorType = ?")) {
+
+            preparedStatement.setInt(1, vendorID);
+
+            ResultSet rs = preparedStatement.executeQuery();
+
+            while (rs.next())
+                itemSet.add(rs.getInt(1));
+
+        } catch (SQLException e) {
+            Logger.error(e);
+            return itemSet;
+        }
+
+        return itemSet;
+    }
+
+    //Used to transfer a single item between owners or equip or vault or bank or inventory
+    public boolean UPDATE_OWNER(final Item item, int newOwnerID, boolean ownerNPC, boolean ownerPlayer,
+                                boolean ownerAccount, ItemContainerType containerType, int slot) {
+
+        boolean worked = false;
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("CALL `item_TRANSFER_OWNER`(?, ?, ?, ? )")) {
+
+            preparedStatement.setLong(1, item.getObjectUUID());
+
+            if (newOwnerID != 0)
+                preparedStatement.setLong(2, newOwnerID);
+            else
+                preparedStatement.setNull(2, java.sql.Types.BIGINT);
+
+            switch (containerType) {
+                case INVENTORY:
+                    preparedStatement.setString(3, "inventory");
+                    break;
+                case EQUIPPED:
+                    preparedStatement.setString(3, "equip");
+                    break;
+                case BANK:
+                    preparedStatement.setString(3, "bank");
+                    break;
+                case VAULT:
+                    preparedStatement.setString(3, "vault");
+                    break;
+                case FORGE:
+                    preparedStatement.setString(3, "forge");
+                    break;
+                default:
+                    preparedStatement.setString(3, "none"); //Shouldn't be here
+                    break;
+            }
+            preparedStatement.setInt(4, slot);
+            ResultSet rs = preparedStatement.executeQuery();
+
+            if (rs.next())
+                worked = rs.getBoolean("result");
+
+        } catch (SQLException e) {
+            Logger.error(e);
+            return false;
+        }
+        return worked;
+    }
+
+    public boolean SET_DURABILITY(final Item item, int value) {
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_item` SET `item_durabilityCurrent`=? WHERE `UID`=? AND `item_durabilityCurrent`=?")) {
+
+            preparedStatement.setInt(1, value);
+            preparedStatement.setLong(2, item.getObjectUUID());
+            preparedStatement.setInt(3, item.getDurabilityCurrent());
+
+            return (preparedStatement.executeUpdate() > 0);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+            return false;
+        }
+    }
+
+    public boolean UPDATE_FORGE_TO_INVENTORY(final Item item) {
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_item` SET `item_container` = ? WHERE `UID` = ? AND `item_container` = 'forge';")) {
+
+            preparedStatement.setString(1, "inventory");
+            preparedStatement.setLong(2, item.getObjectUUID());
+
+            return (preparedStatement.executeUpdate() > 0);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+            return false;
+        }
+
+    }
+
+    /**
+     * Attempts to update the quantity of this gold item
+     *
+     * @param value New quantity of gold
+     * @return True on success
+     */
+    public boolean UPDATE_GOLD(final Item item, int value) {
+        if (item == null)
+            return false;
+        return UPDATE_GOLD(item, value, item.getNumOfItems());
+    }
+
+    /**
+     * Attempts to update the quantity of this gold item using CAS
+     *
+     * @return True on success
+     */
+    public boolean UPDATE_GOLD(final Item item, int newValue, int oldValue) {
+
+        if (!item.getItemBase().getType().equals(ItemType.GOLD))
+            return false;
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_item` SET `item_numberOfItems`=? WHERE `UID`=?")) {
+
+            preparedStatement.setInt(1, newValue);
+            preparedStatement.setLong(2, item.getObjectUUID());
+
+            return (preparedStatement.executeUpdate() > 0);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+            return false;
+        }
+
+    }
+
+    public boolean UPDATE_REMAINING_CHARGES(final Item item) {
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_item` SET `item_chargesRemaining` = ? WHERE `UID` = ?")) {
+
+            preparedStatement.setInt(1, item.getChargesRemaining());
+            preparedStatement.setLong(2, item.getObjectUUID());
+
+            return (preparedStatement.executeUpdate() > 0);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+            return false;
+        }
+
+    }
+
+    // This is necessary because default number of items is 1.
+    // When we create gold, we want it to start at 0 quantity.
+
+    public boolean ZERO_ITEM_STACK(Item item) {
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_item` SET `item_numberOfItems`=0 WHERE `UID` = ?")) {
+
+            preparedStatement.setLong(1, item.getObjectUUID());
+
+            return (preparedStatement.executeUpdate() > 0);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+            return false;
+        }
+    }
+
+    public boolean UPDATE_FLAGS(Item item) {
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_item` SET `item_flags`=? WHERE `UID` = ?")) {
+
+            preparedStatement.setInt(1, item.getFlags());
+            preparedStatement.setLong(2, item.getObjectUUID());
+
+            return (preparedStatement.executeUpdate() > 0);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+            return false;
+        }
+    }
+
+    public boolean UPDATE_VALUE(Item item, int value) {
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_item` SET `item_value`=? WHERE `UID` = ?")) {
+
+            preparedStatement.setInt(1, value);
+            preparedStatement.setLong(2, item.getObjectUUID());
+
+            return (preparedStatement.executeUpdate() > 0);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+            return false;
+        }
+    }
 }

src/engine/db/handlers/dbKitHandler.java

@@ -9,28 +9,37 @@
 
 package engine.db.handlers;
 
+import engine.gameManager.DbManager;
 import engine.objects.Kit;
+import org.pmw.tinylog.Logger;
 
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
 import java.util.ArrayList;
 
 public class dbKitHandler extends dbHandlerBase {
 
-	public dbKitHandler() {
-		this.localClass = Kit.class;
-		this.localObjectType = engine.Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
-	}
+    public dbKitHandler() {
+        this.localClass = Kit.class;
+        this.localObjectType = engine.Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
+    }
 
-	public ArrayList<Kit> GET_KITS_FOR_RACE_AND_BASECLASS(int raceID, int baseClassID) {
-		prepareCallable("SELECT vk.* FROM `static_rune_validkit` vk, `static_rune_racebaseclass` rbc WHERE rbc.`RaceID` = ? "
-				+ "&& rbc.`BaseClassID` = ? && rbc.`ID` = vk.`RaceBaseClassesID`");
-		setInt(1, raceID);
-		setInt(2, baseClassID);
-		return getObjectList();
-	}
+    public ArrayList<Kit> GET_ALL_KITS() {
 
-	public ArrayList<Kit> GET_ALL_KITS() {
-		prepareCallable("SELECT * FROM `static_rune_validkit`");
+        ArrayList<Kit> kitList = new ArrayList<>();
 
-		return getObjectList();
-	}
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `static_rune_validkit`")) {
+
+            ResultSet rs = preparedStatement.executeQuery();
+            kitList = getObjectsFromRs(rs, 20);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+
+        return kitList;
+    }
 }

src/engine/db/handlers/dbLootTableHandler.java

@@ -9,11 +9,14 @@
 
 package engine.db.handlers;
 
+import engine.gameManager.DbManager;
 import engine.loot.LootManager;
 import engine.objects.Item;
 import engine.objects.LootTable;
 import org.pmw.tinylog.Logger;
 
+import java.sql.Connection;
+import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 
@@ -23,206 +26,190 @@ public class dbLootTableHandler extends dbHandlerBase {
 
     }
 
-
     public void populateLootGroups() {
+
         int recordsRead = 0;
-        prepareCallable("SELECT `groupID`, `minRoll`, `maxRoll`, `lootTableID`, `pModTableID`, `sModTableID` FROM `static_lootgroups`");
 
-        try {
-            ResultSet rs = executeQuery();
-            if (rs != null)
-                while (rs.next()) {
-                    recordsRead++;
-                    LootTable lootTable = LootTable.getLootGroup(rs.getInt("groupID"));
-                    lootTable.addRow(rs.getFloat("minRoll"), rs.getFloat("maxRoll"), rs.getInt("lootTableID"), rs.getInt("pModTableID"), rs.getInt("sModTableID"), "");
-                }
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT `groupID`, `minRoll`, `maxRoll`, `lootTableID`, `pModTableID`, `sModTableID` FROM `static_lootgroups`")) {
+
+            ResultSet rs = preparedStatement.executeQuery();
+
+            while (rs.next()) {
+                recordsRead++;
+                LootTable lootTable = LootTable.getLootGroup(rs.getInt("groupID"));
+                lootTable.addRow(rs.getFloat("minRoll"), rs.getFloat("maxRoll"), rs.getInt("lootTableID"), rs.getInt("pModTableID"), rs.getInt("sModTableID"), "");
+            }
 
-            Logger.info("read: " + recordsRead + " cached: " + LootTable.getLootGroups().size());
         } catch (SQLException e) {
-        } finally {
-            closeCallable();
+            Logger.error(e);
         }
+
+        Logger.info("read: " + recordsRead + " cached: " + LootTable.getLootGroups().size());
     }
 
     public void populateLootTables() {
+
         int recordsRead = 0;
 
-        prepareCallable("SELECT `lootTable`, `minRoll`, `maxRoll`, `itemBaseUUID`, `minSpawn`, `maxSpawn` FROM `static_loottables`");
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT `lootTable`, `minRoll`, `maxRoll`, `itemBaseUUID`, `minSpawn`, `maxSpawn` FROM `static_loottables`")) {
 
-        try {
-            ResultSet rs = executeQuery();
-            if (rs != null)
-                while (rs.next()) {
-                    recordsRead++;
-                    LootTable lootTable = LootTable.getLootTable(rs.getInt("lootTable"));
-                    lootTable.addRow(rs.getFloat("minRoll"), rs.getFloat("maxRoll"), rs.getInt("itemBaseUUID"), rs.getInt("minSpawn"), rs.getInt("maxSpawn"), "");
-                }
+            ResultSet rs = preparedStatement.executeQuery();
+
+            while (rs.next()) {
+                recordsRead++;
+                LootTable lootTable = LootTable.getLootTable(rs.getInt("lootTable"));
+                lootTable.addRow(rs.getFloat("minRoll"), rs.getFloat("maxRoll"), rs.getInt("itemBaseUUID"), rs.getInt("minSpawn"), rs.getInt("maxSpawn"), "");
+            }
 
-            Logger.info("read: " + recordsRead + " cached: " + LootTable.getLootTables().size());
         } catch (SQLException e) {
-        } finally {
-            closeCallable();
+            Logger.error(e);
         }
+
+        Logger.info("read: " + recordsRead + " cached: " + LootTable.getLootTables().size());
     }
 
     public void populateModTables() {
 
         int recordsRead = 0;
 
-        prepareCallable("SELECT `modTable`,`minRoll`,`maxRoll`,`value`,`action` FROM `static_modtables`");
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT `modTable`,`minRoll`,`maxRoll`,`value`,`action` FROM `static_modtables`")) {
+
+            ResultSet rs = preparedStatement.executeQuery();
+
+            while (rs.next()) {
+                recordsRead++;
+                LootTable lootTable = LootTable.getModTable(rs.getInt("modTable"));
+                lootTable.addRow(rs.getFloat("minRoll"), rs.getFloat("maxRoll"), rs.getInt("value"), 0, 0, rs.getString("action"));
+            }
 
-        try {
-            ResultSet rs = executeQuery();
-            if (rs != null)
-                while (rs.next()) {
-                    recordsRead++;
-                    LootTable lootTable = LootTable.getModTable(rs.getInt("modTable"));
-                    lootTable.addRow(rs.getFloat("minRoll"), rs.getFloat("maxRoll"), rs.getInt("value"), 0, 0, rs.getString("action"));
-                }
-            Logger.info("read: " + recordsRead + " cached: " + LootTable.getModTables().size());
         } catch (SQLException e) {
-        } finally {
-            closeCallable();
+            Logger.error(e);
         }
+
+        Logger.info("read: " + recordsRead + " cached: " + LootTable.getModTables().size());
     }
 
     public void populateModGroups() {
 
         int recordsRead = 0;
 
-        prepareCallable("SELECT `modGroup`,`minRoll`,`maxRoll`,`subTableID` FROM `static_modgroups`");
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT `modGroup`,`minRoll`,`maxRoll`,`subTableID` FROM `static_modgroups`")) {
+
+            ResultSet rs = preparedStatement.executeQuery();
+
+            while (rs.next()) {
+                recordsRead++;
+                LootTable lootTable = LootTable.getModGroup(rs.getInt("modGroup"));
+                lootTable.addRow(rs.getFloat("minRoll"), rs.getFloat("maxRoll"), rs.getInt("subTableID"), 0, 0, "");
+            }
 
-        try {
-            ResultSet rs = executeQuery();
-            if (rs != null)
-                while (rs.next()) {
-                    recordsRead++;
-                    LootTable lootTable = LootTable.getModGroup(rs.getInt("modGroup"));
-                    lootTable.addRow(rs.getFloat("minRoll"), rs.getFloat("maxRoll"), rs.getInt("subTableID"), 0, 0, "");
-                }
-            Logger.info("read: " + recordsRead + " cached: " + LootTable.getModGroups().size());
         } catch (SQLException e) {
-        } finally {
-            closeCallable();
+            Logger.error(e);
         }
+
+        Logger.info("read: " + recordsRead + " cached: " + LootTable.getModGroups().size());
     }
 
     public void LOAD_ENCHANT_VALUES() {
 
-        prepareCallable("SELECT `IDString`, `minMod` FROM `static_power_effectmod` WHERE `modType` = ?");
-        setString(1,"Value");
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT `IDString`, `minMod` FROM `static_power_effectmod` WHERE `modType` = ?")) {
 
-        try {
-            ResultSet rs = executeQuery();
-            while (rs.next()) {
+            preparedStatement.setString(1, "Value");
+            ResultSet rs = preparedStatement.executeQuery();
+
+            while (rs.next())
                 Item.addEnchantValue(rs.getString("IDString"), rs.getInt("minMod"));
-            }
+
         } catch (SQLException e) {
-            Logger.error( e);
-        } finally {
-            closeCallable();
+            Logger.error(e);
         }
     }
 
     public void LOAD_ALL_LOOTGROUPS() {
+
         int recordsRead = 0;
 
-        prepareCallable("SELECT * FROM static_lootgroups");
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM static_lootgroups")) {
 
-        try {
-            ResultSet rs = executeQuery();
+            ResultSet rs = preparedStatement.executeQuery();
 
             while (rs.next()) {
                 LootManager.GenTableRow row = new LootManager.GenTableRow(rs);
                 LootManager.AddGenTableRow(rs.getInt("groupID"), row);
             }
 
-            Logger.info( "read: " + recordsRead);
-
         } catch (SQLException e) {
-            Logger.error( e.getErrorCode() + ' ' + e.getMessage(), e);
-        } finally {
-            closeCallable();
+            Logger.error(e);
         }
+
+        Logger.info("read: " + recordsRead);
     }
 
     public void LOAD_ALL_LOOTTABLES() {
 
         int recordsRead = 0;
 
-        prepareCallable("SELECT * FROM static_loottables");
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM static_loottables")) {
 
-        try {
-            ResultSet rs = executeQuery();
+            ResultSet rs = preparedStatement.executeQuery();
 
             while (rs.next()) {
-
                 recordsRead++;
                 LootManager.ItemTableRow row = new LootManager.ItemTableRow(rs);
-                LootManager.AddItemTableRow(rs.getInt("lootTable"),row);
+                LootManager.AddItemTableRow(rs.getInt("lootTable"), row);
             }
 
-            Logger.info("read: " + recordsRead);
-
         } catch (SQLException e) {
-            Logger.error( e.getErrorCode() + ' ' + e.getMessage(), e);
-        } finally {
-            closeCallable();
+            Logger.error(e);
         }
+
+        Logger.info("read: " + recordsRead);
     }
 
     public void LOAD_ALL_MODGROUPS() {
         int recordsRead = 0;
 
-        prepareCallable("SELECT * FROM static_modgroups");
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM static_modgroups")) {
 
-        try {
-            ResultSet rs = executeQuery();
+            ResultSet rs = preparedStatement.executeQuery();
 
             while (rs.next()) {
-
                 recordsRead++;
-
-                    LootManager.ModTypeTableRow mttr = new LootManager.ModTypeTableRow(rs);
-                    LootManager.AddModTypeTableRow(rs.getInt("modGroup"), mttr);
-
+                LootManager.ModTypeTableRow mttr = new LootManager.ModTypeTableRow(rs);
+                LootManager.AddModTypeTableRow(rs.getInt("modGroup"), mttr);
             }
 
-            Logger.info( "read: " + recordsRead);
-
         } catch (SQLException e) {
-            Logger.error(e.getErrorCode() + ' ' + e.getMessage(), e);
-        } finally {
-            closeCallable();
+            Logger.error(e);
         }
+        Logger.info("read: " + recordsRead);
     }
 
     public void LOAD_ALL_MODTABLES() {
         int recordsRead = 0;
 
-        prepareCallable("SELECT * FROM static_modtables");
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM static_modtables")) {
 
-        try {
-            ResultSet rs = executeQuery();
+            ResultSet rs = preparedStatement.executeQuery();
 
             while (rs.next()) {
-
                 recordsRead++;
-                try {
                 LootManager.ModTableRow mtr = new LootManager.ModTableRow(rs);
-                LootManager.AddModTableRow(rs.getInt("modTable"),mtr);
-                }
-                catch(Exception ex){
-                    Logger.info("MOD TABLE ERROR: " + rs.getInt("modTable"));
-                }
+                LootManager.AddModTableRow(rs.getInt("modTable"), mtr);
             }
 
-            Logger.info( "read: " + recordsRead);
-
         } catch (SQLException e) {
-            Logger.error( e.getErrorCode() + ' ' + e.getMessage(), e);
-        } finally {
-            closeCallable();
+            Logger.error(e);
         }
+        Logger.info("read: " + recordsRead);
     }
 }

src/engine/db/handlers/dbMenuHandler.java

@@ -9,20 +9,39 @@
 
 package engine.db.handlers;
 
+import engine.gameManager.DbManager;
 import engine.objects.MenuOption;
+import org.pmw.tinylog.Logger;
 
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
 import java.util.ArrayList;
 
 public class dbMenuHandler extends dbHandlerBase {
 
-	public dbMenuHandler() {
-		this.localClass = MenuOption.class;
+    public dbMenuHandler() {
+        this.localClass = MenuOption.class;
         this.localObjectType = engine.Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
-	}
+    }
 
-	public ArrayList<MenuOption> GET_MENU_OPTIONS(final int id) {
-		prepareCallable("SELECT * FROM `static_npc_menuoption` WHERE menuID = ?");
-		setInt(1, id);
-		return getObjectList();
-	}
+    public ArrayList<MenuOption> GET_MENU_OPTIONS(final int id) {
+
+        ArrayList<MenuOption> menuOptions = new ArrayList<>();
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `static_npc_menuoption` WHERE menuID = ?")) {
+
+            preparedStatement.setInt(1, id);
+
+            ResultSet rs = preparedStatement.executeQuery();
+            menuOptions = getObjectsFromRs(rs, 1000);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+
+        return menuOptions;
+    }
 }

src/engine/db/handlers/dbMineHandler.java

@@ -13,84 +13,123 @@ import engine.gameManager.DbManager;
 import engine.objects.Mine;
 import engine.objects.MineProduction;
 import engine.objects.Resource;
+import org.pmw.tinylog.Logger;
 
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
 import java.util.ArrayList;
 
 public class dbMineHandler extends dbHandlerBase {
 
-	public dbMineHandler() {
-		this.localClass = Mine.class;
-		this.localObjectType = Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
-	}
+    public dbMineHandler() {
+        this.localClass = Mine.class;
+        this.localObjectType = Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
+    }
 
-	public Mine GET_MINE(int id) {
+    public Mine GET_MINE(int id) {
 
-		if (id == 0)
-			return null;
+        if (id == 0)
+            return null;
 
-		Mine mine = (Mine) DbManager.getFromCache(Enum.GameObjectType.Mine, id);
-		if (mine != null)
-			return mine;
+        Mine mine = (Mine) DbManager.getFromCache(Enum.GameObjectType.Mine, id);
 
-		prepareCallable("SELECT `obj_building`.*, `object`.`parent` FROM `object` INNER JOIN `obj_building` ON `obj_building`.`UID` = `object`.`UID` WHERE `object`.`UID` = ?;");
+        if (mine != null)
+            return mine;
 
-		setLong(1, (long) id);
-		return (Mine) getObjectSingle(id);
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT `obj_building`.*, `object`.`parent` FROM `object` INNER JOIN `obj_building` ON `obj_building`.`UID` = `object`.`UID` WHERE `object`.`UID` = ?;")) {
 
-	}
+            preparedStatement.setLong(1, id);
 
-	public ArrayList<Mine> GET_ALL_MINES_FOR_SERVER() {
-		prepareCallable("SELECT `obj_mine`.*, `object`.`parent` FROM `object` INNER JOIN `obj_mine` ON `obj_mine`.`UID` = `object`.`UID`");
-		return getObjectList();
-	}
+            ResultSet rs = preparedStatement.executeQuery();
+            mine = (Mine) getObjectFromRs(rs);
 
-	public boolean CHANGE_OWNER(Mine mine, int playerUID) {
-		prepareCallable("UPDATE `obj_mine` SET `mine_ownerUID`=? WHERE `UID`=?");
-		setInt(1, playerUID);
-		setLong(2, (long) mine.getObjectUUID());
-		return (executeUpdate() > 0);
-	}
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return mine;
+    }
 
-	public boolean CHANGE_RESOURCE(Mine mine, Resource resource) {
-		prepareCallable("UPDATE `obj_mine` SET `mine_resource`=? WHERE `UID`=?");
-		setString(1, resource.name());
-		setLong(2, (long) mine.getObjectUUID());
-		return (executeUpdate() > 0);
-	}
+    public ArrayList<Mine> GET_ALL_MINES_FOR_SERVER() {
 
-	public boolean CHANGE_TYPE(Mine mine, MineProduction productionType) {
-		prepareCallable("UPDATE `obj_mine` SET `mine_type`=? WHERE `UID`=?");
-		setString(1, productionType.name());
-		setLong(2, (long) mine.getObjectUUID());
-		return (executeUpdate() > 0);
-	}
+        ArrayList<Mine> mines = new ArrayList<>();
 
-	public boolean SET_FLAGS(Mine mine, int newFlags) {
-		prepareCallable("UPDATE `obj_mine` SET `flags`=? WHERE `UID`=?");
-		setInt(1, newFlags);
-		setLong(2, (long) mine.getObjectUUID());
-		return (executeUpdate() > 0);
-	}
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT `obj_mine`.*, `object`.`parent` FROM `object` INNER JOIN `obj_mine` ON `obj_mine`.`UID` = `object`.`UID`")) {
 
-	public String SET_PROPERTY(final Mine m, String name, Object new_value) {
-		prepareCallable("CALL mine_SETPROP(?,?,?)");
-		setLong(1, (long) m.getObjectUUID());
-		setString(2, name);
-		setString(3, String.valueOf(new_value));
-		return getResult();
-	}
+            ResultSet rs = preparedStatement.executeQuery();
+            mines = getObjectsFromRs(rs, 1000);
 
-	// Advance all the mine windows respective to the current day
-	// at boot time.  This ensures that mines always go live
-	// no matter what date in the database
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return mines;
+    }
 
-	public String SET_PROPERTY(final Mine m, String name, Object new_value, Object old_value) {
-		prepareCallable("CALL mine_GETSETPROP(?,?,?,?)");
-		setLong(1, (long) m.getObjectUUID());
-		setString(2, name);
-		setString(3, String.valueOf(new_value));
-		setString(4, String.valueOf(old_value));
-		return getResult();
-	}
+    public boolean CHANGE_OWNER(Mine mine, int playerUID) {
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_mine` SET `mine_ownerUID`=? WHERE `UID`=?")) {
+
+            preparedStatement.setInt(1, playerUID);
+            preparedStatement.setLong(2, mine.getObjectUUID());
+
+            return (preparedStatement.executeUpdate() > 0);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return false;
+    }
+
+    public boolean CHANGE_RESOURCE(Mine mine, Resource resource) {
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_mine` SET `mine_resource`=? WHERE `UID`=?")) {
+
+            preparedStatement.setString(1, resource.name());
+            preparedStatement.setLong(2, mine.getObjectUUID());
+
+            return (preparedStatement.executeUpdate() > 0);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return false;
+    }
+
+    public boolean CHANGE_TYPE(Mine mine, MineProduction productionType) {
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_mine` SET `mine_type`=? WHERE `UID`=?")) {
+
+            preparedStatement.setString(1, productionType.name());
+            preparedStatement.setLong(2, mine.getObjectUUID());
+
+            return (preparedStatement.executeUpdate() > 0);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return false;
+    }
+
+    public boolean SET_FLAGS(Mine mine, int newFlags) {
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_mine` SET `flags`=? WHERE `UID`=?")) {
+
+            preparedStatement.setInt(1, newFlags);
+            preparedStatement.setLong(2, mine.getObjectUUID());
+
+            return (preparedStatement.executeUpdate() > 0);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return false;
+    }
 
 }

src/engine/db/handlers/dbMobBaseHandler.java

@@ -11,10 +11,14 @@ package engine.db.handlers;
 
 import engine.Enum.GameObjectType;
 import engine.gameManager.DbManager;
-import engine.objects.*;
+import engine.objects.MobBase;
+import engine.objects.MobBaseEffects;
+import engine.objects.MobBaseStats;
 import engine.server.MBServerStatics;
 import org.pmw.tinylog.Logger;
 
+import java.sql.Connection;
+import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.ArrayList;
@@ -22,160 +26,173 @@ import java.util.HashMap;
 
 public class dbMobBaseHandler extends dbHandlerBase {
 
-	public dbMobBaseHandler() {
-		this.localClass = MobBase.class;
-		this.localObjectType = engine.Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
-	}
+    public dbMobBaseHandler() {
+        this.localClass = MobBase.class;
+        this.localObjectType = engine.Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
+    }
 
-    public MobBase GET_MOBBASE(int id, boolean forceDB) {
+    public MobBase GET_MOBBASE(int id) {
+
+        if (id == 0)
+            return null;
+
+        MobBase mobBase = (MobBase) DbManager.getFromCache(GameObjectType.MobBase, id);
+
+        if (mobBase != null)
+            return mobBase;
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `static_npc_mobbase` WHERE `ID`=?")) {
+
+            preparedStatement.setInt(1, id);
+
+            ResultSet rs = preparedStatement.executeQuery();
+            mobBase = (MobBase) getObjectFromRs(rs);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+
+        return mobBase;
+    }
 
 
-		if (id == 0)
-			return null;
+    public ArrayList<MobBase> GET_ALL_MOBBASES() {
 
-		MobBase mobBase = (MobBase) DbManager.getFromCache(GameObjectType.MobBase, id);
+        ArrayList<MobBase> mobbaseList = new ArrayList<>();
 
-		if ( mobBase != null)
-			return mobBase;
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `static_npc_mobbase`;")) {
 
-		prepareCallable("SELECT * FROM `static_npc_mobbase` WHERE `ID`=?");
-		setInt(1, id);
-		return (MobBase) getObjectSingle(id, forceDB, true);
-	}
+            ResultSet rs = preparedStatement.executeQuery();
+            mobbaseList = getObjectsFromRs(rs, 1000);
 
-	public ArrayList<MobBase> GET_ALL_MOBBASES() {
-		prepareCallable("SELECT * FROM `static_npc_mobbase`;");
-		return  getObjectList();
-	}
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return mobbaseList;
+    }
 
-	public void SET_AI_DEFAULTS() {
-		prepareCallable("SELECT * FROM `static_ai_defaults`");
-		try {
-			ResultSet rs = executeQuery();
-			while (rs.next()) {
-				MBServerStatics.AI_BASE_AGGRO_RANGE = rs.getInt("aggro_range");
-				MBServerStatics.AI_PATROL_DIVISOR = rs.getInt("patrol_chance");
-				MBServerStatics.AI_DROP_AGGRO_RANGE = rs.getInt("drop_aggro_range");
-				MBServerStatics.AI_POWER_DIVISOR = rs.getInt("cast_chance");
-				MBServerStatics.AI_RECALL_RANGE = rs.getInt("recall_range");
-				MBServerStatics.AI_PET_HEEL_DISTANCE = rs.getInt("pet_heel_distance");
-			}
-			rs.close();
-		} catch (SQLException e) {
-			Logger.error( e.getMessage());
-		} finally {
-			closeCallable();
-		}
+    public void SET_AI_DEFAULTS() {
 
-	}
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `static_ai_defaults`")) {
 
-	public boolean UPDATE_AI_DEFAULTS() {
-		prepareCallable("UPDATE `static_ai_defaults` SET `aggro_range` = ?,`patrol_chance`= ?,`drop_aggro_range`= ?,`cast_chance`= ?,`recall_range`= ? WHERE `ID` = 1");
-		setInt(1, MBServerStatics.AI_BASE_AGGRO_RANGE);
-		setInt(2, MBServerStatics.AI_PATROL_DIVISOR);
-		setInt(3, MBServerStatics.AI_DROP_AGGRO_RANGE);
-		setInt(4, MBServerStatics.AI_POWER_DIVISOR);
-		setInt(5, MBServerStatics.AI_RECALL_RANGE);
-		return (executeUpdate() > 0);
+            ResultSet rs = preparedStatement.executeQuery();
 
-	}
+            while (rs.next()) {
+                MBServerStatics.AI_BASE_AGGRO_RANGE = rs.getInt("aggro_range");
+                MBServerStatics.AI_PATROL_DIVISOR = rs.getInt("patrol_chance");
+                MBServerStatics.AI_DROP_AGGRO_RANGE = rs.getInt("drop_aggro_range");
+                MBServerStatics.AI_POWER_DIVISOR = rs.getInt("cast_chance");
+                MBServerStatics.AI_RECALL_RANGE = rs.getInt("recall_range");
+                MBServerStatics.AI_PET_HEEL_DISTANCE = rs.getInt("pet_heel_distance");
+            }
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+    }
 
-	public HashMap<Integer, Integer> LOAD_STATIC_POWERS(int mobBaseUUID) {
-		HashMap<Integer, Integer> powersList = new HashMap<>();
-		prepareCallable("SELECT * FROM `static_npc_mobbase_powers` WHERE `mobbaseUUID`=?");
-		setInt(1, mobBaseUUID);
-		try {
-			ResultSet rs = executeQuery();
-			while (rs.next()) {
+    public boolean UPDATE_AI_DEFAULTS() {
 
-				powersList.put(rs.getInt("token"), rs.getInt("rank"));
-			}
-			rs.close();
-		} catch (SQLException e) {
-			Logger.error( e.getMessage());
-		} finally {
-			closeCallable();
-		}
-		return powersList;
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `static_ai_defaults` SET `aggro_range` = ?,`patrol_chance`= ?,`drop_aggro_range`= ?,`cast_chance`= ?,`recall_range`= ? WHERE `ID` = 1")) {
 
-	}
+            preparedStatement.setInt(1, MBServerStatics.AI_BASE_AGGRO_RANGE);
+            preparedStatement.setInt(2, MBServerStatics.AI_PATROL_DIVISOR);
+            preparedStatement.setInt(3, MBServerStatics.AI_DROP_AGGRO_RANGE);
+            preparedStatement.setInt(4, MBServerStatics.AI_POWER_DIVISOR);
+            preparedStatement.setInt(5, MBServerStatics.AI_RECALL_RANGE);
 
-	public ArrayList<MobBaseEffects> GET_RUNEBASE_EFFECTS(int runeID) {
-		ArrayList<MobBaseEffects> effectsList = new ArrayList<>();
-		prepareCallable("SELECT * FROM `static_npc_mobbase_effects` WHERE `mobbaseUUID` = ?");
-		setInt(1, runeID);
+            return (preparedStatement.executeUpdate() > 0);
 
-		try {
-			ResultSet rs = executeQuery();
-			while (rs.next()) {
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return false;
+    }
 
-				MobBaseEffects mbs = new MobBaseEffects(rs);
-				effectsList.add(mbs);
-			}
-			rs.close();
-		} catch (SQLException e) {
-			Logger.error (e.getMessage());
-		} finally {
-			closeCallable();
-		}
+    public HashMap<Integer, Integer> LOAD_STATIC_POWERS(int mobBaseUUID) {
 
-		return effectsList;
+        HashMap<Integer, Integer> powersList = new HashMap<>();
 
-	}
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `static_npc_mobbase_powers` WHERE `mobbaseUUID`=?")) {
 
-	public MobBaseStats LOAD_STATS(int mobBaseUUID) {
-		MobBaseStats mbs = MobBaseStats.GetGenericStats();
+            preparedStatement.setInt(1, mobBaseUUID);
+            ResultSet rs = preparedStatement.executeQuery();
 
-		prepareCallable("SELECT * FROM `static_npc_mobbase_stats` WHERE `mobbaseUUID` = ?");
-		setInt(1, mobBaseUUID);
-		try {
-			ResultSet rs = executeQuery();
-			while (rs.next()) {
+            while (rs.next())
+                powersList.put(rs.getInt("token"), rs.getInt("rank"));
 
-				mbs = new MobBaseStats(rs);
-			}
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return powersList;
+    }
 
-		} catch (SQLException e) {
-			Logger.error(e.getErrorCode() + ' ' + e.getMessage(), e);
-		} finally {
-			closeCallable();
-		}
-		return mbs;
+    public ArrayList<MobBaseEffects> GET_RUNEBASE_EFFECTS(int runeID) {
 
-	}
+        ArrayList<MobBaseEffects> effectsList = new ArrayList<>();
 
-	public boolean RENAME_MOBBASE(int ID, String newName) {
-		prepareCallable("UPDATE `static_npc_mobbase` SET `name`=? WHERE `ID`=?;");
-		setString(1, newName);
-		setInt(2, ID);
-		return (executeUpdate() > 0);
-	}
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `static_npc_mobbase_effects` WHERE `mobbaseUUID` = ?")) {
 
-	public void LOAD_ALL_MOBBASE_SPEEDS(MobBase mobBase) {
+            preparedStatement.setInt(1, runeID);
+            ResultSet rs = preparedStatement.executeQuery();
 
-		if (mobBase.getLoadID() == 0)
-			return;
-		ArrayList<MobLootBase> mobLootList = new ArrayList<>();
-		prepareCallable("SELECT * FROM `static_npc_mobbase_race` WHERE `mobbaseID` = ?");
-		setInt(1, mobBase.getLoadID());
+            while (rs.next()) {
+                MobBaseEffects mbs = new MobBaseEffects(rs);
+                effectsList.add(mbs);
+            }
 
-		try {
-			ResultSet rs = executeQuery();
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
 
-			//shrines cached in rs for easy cache on creation.
-			while (rs.next()) {
-				float walk = rs.getFloat("walkStandard");
-				float walkCombat = rs.getFloat("walkCombat");
-				float run = rs.getFloat("runStandard");
-				float runCombat = rs.getFloat("runCombat");
-				mobBase.updateSpeeds(walk, walkCombat, run, runCombat);
-			}
+        return effectsList;
+    }
 
+    public MobBaseStats LOAD_STATS(int mobBaseUUID) {
 
-		} catch (SQLException e) {
-			Logger.error(e.getErrorCode() + ' ' + e.getMessage(), e);
-		} finally {
-			closeCallable();
-		}
-	}
+        MobBaseStats mobBaseStats = MobBaseStats.GetGenericStats();
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `static_npc_mobbase_stats` WHERE `mobbaseUUID` = ?")) {
+
+            preparedStatement.setInt(1, mobBaseUUID);
+            ResultSet rs = preparedStatement.executeQuery();
+
+            while (rs.next())
+                mobBaseStats = new MobBaseStats(rs);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return mobBaseStats;
+    }
+
+    public void LOAD_ALL_MOBBASE_SPEEDS(MobBase mobBase) {
+
+        if (mobBase.getLoadID() == 0)
+            return;
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `static_npc_mobbase_race` WHERE `mobbaseID` = ?")) {
+
+            preparedStatement.setInt(1, mobBase.getLoadID());
+            ResultSet rs = preparedStatement.executeQuery();
+
+            while (rs.next()) {
+                float walk = rs.getFloat("walkStandard");
+                float walkCombat = rs.getFloat("walkCombat");
+                float run = rs.getFloat("runStandard");
+                float runCombat = rs.getFloat("runCombat");
+                mobBase.updateSpeeds(walk, walkCombat, run, runCombat);
+            }
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+    }
 }

src/engine/db/handlers/dbMobHandler.java

@@ -9,168 +9,244 @@
 
 package engine.db.handlers;
 
+import engine.gameManager.DbManager;
 import engine.objects.Mob;
 import engine.objects.Zone;
 import engine.server.MBServerStatics;
 import org.joda.time.DateTime;
 import org.pmw.tinylog.Logger;
 
+import java.sql.Connection;
+import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.ArrayList;
 
 public class dbMobHandler extends dbHandlerBase {
 
-	public dbMobHandler() {
-		this.localClass = Mob.class;
-		this.localObjectType = engine.Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
-	}
+    public dbMobHandler() {
+        this.localClass = Mob.class;
+        this.localObjectType = engine.Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
+    }
 
-	public Mob ADD_MOB(Mob toAdd)
-			 {
-		prepareCallable("CALL `mob_CREATE`(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);");
-				 setLong(1, toAdd.getParentZoneID());
-		setInt(2, toAdd.getMobBaseID());
-		setInt(3, toAdd.getGuildUUID());
-		setFloat(4, toAdd.getSpawnX());
-		setFloat(5, toAdd.getSpawnY());
-		setFloat(6, toAdd.getSpawnZ());
-		setInt(7, 0);
-		setFloat(8, toAdd.getSpawnRadius());
-		setInt(9, toAdd.getTrueSpawnTime());
-		if (toAdd.getContract() != null)
-			setInt(10, toAdd.getContract().getContractID());
-		else
-			setInt(10, 0);
-		setInt(11, toAdd.getBuildingID());
-		setInt(12, toAdd.getLevel());
-		setString(13, toAdd.getFirstName());
-		int objectUUID = (int) getUUID();
-		if (objectUUID > 0)
-			return GET_MOB(objectUUID);
-		return null;
-	}
+    public Mob ADD_MOB(Mob toAdd) {
 
-	public boolean updateUpgradeTime(Mob mob, DateTime upgradeDateTime) {
+        Mob mobile = null;
 
-		try {
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("CALL `mob_CREATE`(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);")) {
 
-			prepareCallable("UPDATE obj_mob SET upgradeDate=? "
-					+ "WHERE UID = ?");
+            preparedStatement.setLong(1, toAdd.getParentZoneID());
+            preparedStatement.setInt(2, toAdd.getMobBaseID());
+            preparedStatement.setInt(3, toAdd.getGuildUUID());
+            preparedStatement.setFloat(4, toAdd.getSpawnX());
+            preparedStatement.setFloat(5, toAdd.getSpawnY());
+            preparedStatement.setFloat(6, toAdd.getSpawnZ());
+            preparedStatement.setInt(7, 0);
+            preparedStatement.setFloat(8, toAdd.getSpawnRadius());
+            preparedStatement.setInt(9, toAdd.getTrueSpawnTime());
 
-			if (upgradeDateTime == null)
-				setNULL(1, java.sql.Types.DATE);
-			else
-				setTimeStamp(1, upgradeDateTime.getMillis());
+            if (toAdd.getContract() != null)
+                preparedStatement.setInt(10, toAdd.getContract().getContractID());
+            else
+                preparedStatement.setInt(10, 0);
 
-			setInt(2, mob.getObjectUUID());
-			executeUpdate();
-		} catch (Exception e) {
-			Logger.error("Mob.updateUpgradeTime", "UUID: " + mob.getObjectUUID());
-			return false;
-		}
-		return true;
-	}
+            preparedStatement.setInt(11, toAdd.getBuildingID());
+            preparedStatement.setInt(12, toAdd.getLevel());
+            preparedStatement.setString(13, toAdd.getFirstName());
 
-	public int DELETE_MOB(final Mob mob) {
-		prepareCallable("DELETE FROM `object` WHERE `UID` = ?");
-		setLong(1, mob.getDBID());
-		return executeUpdate();
-	}
+            ResultSet rs = preparedStatement.executeQuery();
 
-	public void LOAD_PATROL_POINTS(Mob captain) {
+            if (rs.next()) {
+                int objectUUID = (int) rs.getLong("UID");
 
+                if (objectUUID > 0)
+                    mobile = GET_MOB(objectUUID);
+            }
 
+        } catch (SQLException e) {
+            throw new RuntimeException(e);
+        }
+        return mobile;
+    }
 
-		prepareCallable("SELECT * FROM `dyn_guards` WHERE `captainUID` = ?");
-		setInt(1,captain.getObjectUUID());
+    public boolean updateUpgradeTime(Mob mob, DateTime upgradeDateTime) {
 
-		try {
-			ResultSet rs = executeQuery();
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE obj_mob SET upgradeDate=? "
+                     + "WHERE UID = ?")) {
 
-			//shrines cached in rs for easy cache on creation.
-			while (rs.next()) {
-				int mobBaseID = rs.getInt("mobBaseID");
-				String name = rs.getString("name");
-				Mob toCreate = Mob.createGuardMob(captain, captain.getGuild(), captain.getParentZone(), captain.building.getLoc(), captain.getLevel(),name);
-				if (toCreate == null)
-					return;
+            if (upgradeDateTime == null)
+                preparedStatement.setNull(1, java.sql.Types.DATE);
+            else
+                preparedStatement.setTimestamp(1, new java.sql.Timestamp(upgradeDateTime.getMillis()));
 
-				//   toCreate.despawn();
-				if (toCreate != null) {
-					
-					toCreate.setTimeToSpawnSiege(System.currentTimeMillis() + MBServerStatics.FIFTEEN_MINUTES);
-					toCreate.setDeathTime(System.currentTimeMillis());
+            preparedStatement.setInt(2, mob.getObjectUUID());
 
+            preparedStatement.execute();
+            return true;
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return false;
+    }
+
+    public int DELETE_MOB(final Mob mob) {
+
+        int row_count = 0;
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("DELETE FROM `object` WHERE `UID` = ?")) {
+
+            preparedStatement.setLong(1, mob.getDBID());
+            row_count = preparedStatement.executeUpdate();
+
+        } catch (SQLException e) {
+            Logger.error(e);
+
+        }
+        return row_count;
+    }
+
+    public void LOAD_PATROL_POINTS(Mob captain) {
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `dyn_guards` WHERE `captainUID` = ?")) {
+
+            preparedStatement.setInt(1, captain.getObjectUUID());
+            ResultSet rs = preparedStatement.executeQuery();
+
+            while (rs.next()) {
+                String name = rs.getString("name");
+                Mob toCreate = Mob.createGuardMob(captain, captain.getGuild(), captain.getParentZone(), captain.building.getLoc(), captain.getLevel(), name);
+
+                if (toCreate == null)
+                    return;
+
+                if (toCreate != null) {
+                    toCreate.setTimeToSpawnSiege(System.currentTimeMillis() + MBServerStatics.FIFTEEN_MINUTES);
+                    toCreate.setDeathTime(System.currentTimeMillis());
                 }
-			}
+            }
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+    }
+
+    public boolean ADD_TO_GUARDS(final long captainUID, final int mobBaseID, final String name, final int slot) {
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("INSERT INTO `dyn_guards` (`captainUID`, `mobBaseID`,`name`, `slot`) VALUES (?,?,?,?)")) {
+
+            preparedStatement.setLong(1, captainUID);
+            preparedStatement.setInt(2, mobBaseID);
+            preparedStatement.setString(3, name);
+            preparedStatement.setInt(4, slot);
+
+            return (preparedStatement.executeUpdate() > 0);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+            return false;
+        }
+    }
+
+    public boolean REMOVE_FROM_GUARDS(final long captainUID, final int mobBaseID, final int slot) {
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("DELETE FROM `dyn_guards` WHERE `captainUID`=? AND `mobBaseID`=? AND `slot` =?")) {
+
+            preparedStatement.setLong(1, captainUID);
+            preparedStatement.setInt(2, mobBaseID);
+            preparedStatement.setInt(3, slot);
+
+            return (preparedStatement.executeUpdate() > 0);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+            return false;
+        }
+    }
 
 
-		} catch (SQLException e) {
-			Logger.error( e.toString());
-		} finally {
-			closeCallable();
-		}
+    public ArrayList<Mob> GET_ALL_MOBS_FOR_ZONE(Zone zone) {
 
+        ArrayList<Mob> mobileList = new ArrayList<>();
 
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT `obj_mob`.*, `object`.`parent` FROM `object` INNER JOIN `obj_mob` ON `obj_mob`.`UID` = `object`.`UID` WHERE `object`.`parent` = ?;")) {
 
-	}
+            preparedStatement.setLong(1, zone.getObjectUUID());
 
-	public boolean ADD_TO_GUARDS(final long captainUID, final int mobBaseID, final String name, final int slot) {
-		prepareCallable("INSERT INTO `dyn_guards` (`captainUID`, `mobBaseID`,`name`, `slot`) VALUES (?,?,?,?)");
-		setLong(1, captainUID);
-		setInt(2, mobBaseID);
-		setString(3, name);
-		setInt(4, slot);
-		return (executeUpdate() > 0);
-	}
+            ResultSet rs = preparedStatement.executeQuery();
+            mobileList = getObjectsFromRs(rs, 1000);
 
-	public boolean REMOVE_FROM_GUARDS(final long captainUID, final int mobBaseID, final int slot) {
-		prepareCallable("DELETE FROM `dyn_guards` WHERE `captainUID`=? AND `mobBaseID`=? AND `slot` =?");
-		setLong(1, captainUID);
-		setInt(2, mobBaseID);
-		setInt(3,slot);
-		return (executeUpdate() > 0);
-	}
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
 
+        return mobileList;
+    }
 
-	public ArrayList<Mob> GET_ALL_MOBS_FOR_ZONE(Zone zone) {
-		prepareCallable("SELECT `obj_mob`.*, `object`.`parent` FROM `object` INNER JOIN `obj_mob` ON `obj_mob`.`UID` = `object`.`UID` WHERE `object`.`parent` = ?;");
-		setLong(1, zone.getObjectUUID());
-		return getLargeObjectList();
-	}
+    public Mob GET_MOB(final int objectUUID) {
 
-	public Mob GET_MOB(final int objectUUID) {
-		prepareCallable("SELECT `obj_mob`.*, `object`.`parent` FROM `object` INNER JOIN `obj_mob` ON `obj_mob`.`UID` = `object`.`UID` WHERE `object`.`UID` = ?;");
-		setLong(1, objectUUID);
-		return (Mob) getObjectSingle(objectUUID);
-	}
+        Mob mobile = null;
 
-	public int MOVE_MOB(long mobID, long parentID, float locX, float locY, float locZ) {
-		prepareCallable("UPDATE `object` INNER JOIN `obj_mob` On `object`.`UID` = `obj_mob`.`UID` SET `object`.`parent`=?, `obj_mob`.`mob_spawnX`=?, `obj_mob`.`mob_spawnY`=?, `obj_mob`.`mob_spawnZ`=? WHERE `obj_mob`.`UID`=?;");
-		setLong(1, parentID);
-		setFloat(2, locX);
-		setFloat(3, locY);
-		setFloat(4, locZ);
-		setLong(5, mobID);
-		return executeUpdate();
-	}
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT `obj_mob`.*, `object`.`parent` FROM `object` INNER JOIN `obj_mob` ON `obj_mob`.`UID` = `object`.`UID` WHERE `object`.`UID` = ?;")) {
 
-	public String SET_PROPERTY(final Mob m, String name, Object new_value) {
-		prepareCallable("CALL mob_SETPROP(?,?,?)");
-		setLong(1, m.getObjectUUID());
-		setString(2, name);
-		setString(3, String.valueOf(new_value));
-		return getResult();
-	}
+            preparedStatement.setLong(1, objectUUID);
+            ResultSet rs = preparedStatement.executeQuery();
+            mobile = (Mob) getObjectFromRs(rs);
 
-	public String SET_PROPERTY(final Mob m, String name, Object new_value, Object old_value) {
-		prepareCallable("CALL mob_GETSETPROP(?,?,?,?)");
-		setLong(1, m.getObjectUUID());
-		setString(2, name);
-		setString(3, String.valueOf(new_value));
-		setString(4, String.valueOf(old_value));
-		return getResult();
-	}
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return mobile;
+    }
+
+    public int MOVE_MOB(long mobID, long parentID, float locX, float locY, float locZ) {
+
+        int row_count = 0;
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `object` INNER JOIN `obj_mob` On `object`.`UID` = `obj_mob`.`UID` SET `object`.`parent`=?, `obj_mob`.`mob_spawnX`=?, `obj_mob`.`mob_spawnY`=?, `obj_mob`.`mob_spawnZ`=? WHERE `obj_mob`.`UID`=?;")) {
+
+            preparedStatement.setLong(1, parentID);
+            preparedStatement.setFloat(2, locX);
+            preparedStatement.setFloat(3, locY);
+            preparedStatement.setFloat(4, locZ);
+            preparedStatement.setLong(5, mobID);
+
+            ResultSet rs = preparedStatement.executeQuery();
+            row_count = preparedStatement.executeUpdate();
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return row_count;
+    }
+
+    public String SET_PROPERTY(final Mob m, String name, Object new_value) {
+
+        String result = "";
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("CALL mob_SETPROP(?,?,?)")) {
+
+            preparedStatement.setLong(1, m.getObjectUUID());
+            preparedStatement.setString(2, name);
+            preparedStatement.setString(3, String.valueOf(new_value));
+
+            ResultSet rs = preparedStatement.executeQuery();
+
+            if (rs.next())
+                result = rs.getString("result");
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return result;
+    }
 
 }

src/engine/db/handlers/dbNPCHandler.java

@@ -10,347 +10,456 @@
 package engine.db.handlers;
 
 import engine.Enum.ProfitType;
-import engine.objects.*;
+import engine.gameManager.DbManager;
+import engine.objects.NPC;
+import engine.objects.NPCProfits;
+import engine.objects.ProducedItem;
+import engine.objects.Zone;
 import org.joda.time.DateTime;
 import org.pmw.tinylog.Logger;
 
+import java.sql.Connection;
+import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.ArrayList;
-import java.util.HashMap;
 
 public class dbNPCHandler extends dbHandlerBase {
 
-	public dbNPCHandler() {
-		this.localClass = NPC.class;
-		this.localObjectType = engine.Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
-	}
+    public dbNPCHandler() {
+        this.localClass = NPC.class;
+        this.localObjectType = engine.Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
+    }
 
-	public NPC ADD_NPC(NPC toAdd, boolean isMob) {
-		prepareCallable("CALL `npc_CREATE`(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);");
-		setLong(1, toAdd.getParentZoneID());
-		setString(2, toAdd.getName());
-		setInt(3, toAdd.getContractID());
-		setInt(4, toAdd.getGuildUUID());
-		setFloat(5, toAdd.getSpawnX());
-		setFloat(6, toAdd.getSpawnY());
-		setFloat(7, toAdd.getSpawnZ());
-		setInt(8, toAdd.getLevel());
-		setFloat(9, toAdd.getBuyPercent());
-		setFloat(10, toAdd.getSellPercent());
-		if (toAdd.getBuilding() != null) {
-			setInt(11, toAdd.getBuilding().getObjectUUID());
-		} else {
-			setInt(11, 0);
-		}
+    public NPC ADD_NPC(NPC toAdd, boolean isMob) {
 
-		int objectUUID = (int) getUUID();
-		if (objectUUID > 0) {
-			return GET_NPC(objectUUID);
-		}
-		return null;
-	}
+        NPC npc = null;
 
-	public int DELETE_NPC(final NPC npc) {
-		if (npc.isStatic()) {
-			return DELETE_STATIC_NPC(npc);
-		}
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("CALL `npc_CREATE`(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);")) {
 
-		npc.removeFromZone();
-		prepareCallable("DELETE FROM `object` WHERE `UID` = ?");
-		setLong(1, (long) npc.getDBID());
-		return executeUpdate();
-	}
+            preparedStatement.setLong(1, toAdd.getParentZoneID());
+            preparedStatement.setString(2, toAdd.getName());
+            preparedStatement.setInt(3, toAdd.getContractID());
+            preparedStatement.setInt(4, toAdd.getGuildUUID());
+            preparedStatement.setFloat(5, toAdd.getSpawnX());
+            preparedStatement.setFloat(6, toAdd.getSpawnY());
+            preparedStatement.setFloat(7, toAdd.getSpawnZ());
+            preparedStatement.setInt(8, toAdd.getLevel());
+            preparedStatement.setFloat(9, toAdd.getBuyPercent());
+            preparedStatement.setFloat(10, toAdd.getSellPercent());
 
-	private int DELETE_STATIC_NPC(final NPC npc) {
-		npc.removeFromZone();
-		prepareCallable("DELETE FROM `_init_npc` WHERE `ID` = ?");
-		setInt(1, npc.getDBID());
-		return executeUpdate();
-	}
+            if (toAdd.getBuilding() != null)
+                preparedStatement.setInt(11, toAdd.getBuilding().getObjectUUID());
+            else
+                preparedStatement.setInt(11, 0);
 
-	public ArrayList<NPC> GET_ALL_NPCS_FOR_ZONE(Zone zone) {
-		prepareCallable("SELECT `obj_npc`.*, `object`.`parent` FROM `object` INNER JOIN `obj_npc` ON `obj_npc`.`UID` = `object`.`UID` WHERE `object`.`parent` = ?;");
-		setLong(1, (long) zone.getObjectUUID());
-		return getLargeObjectList();
-	}
+            ResultSet rs = preparedStatement.executeQuery();
 
-	public ArrayList<NPC> GET_ALL_NPCS() {
-		prepareCallable("SELECT `obj_npc`.*, `object`.`parent` FROM `object` INNER JOIN `obj_npc` ON `obj_npc`.`UID` = `object`.`UID`;");
-		
-		return getObjectList();
-	}
+            if (rs.next()) {
+                int objectUUID = (int) rs.getLong("UID");
 
-	public ArrayList<NPC> GET_NPCS_BY_BUILDING(final int buildingID) {
-		prepareCallable("SELECT `obj_npc`.*, `object`.`parent` FROM `obj_npc` INNER JOIN `object` ON `obj_npc`.`UID` = `object`.`UID` WHERE `npc_buildingID` = ? LIMIT 3");
-		setInt(1, buildingID);
-		return getObjectList();
-	}
+                if (objectUUID > 0)
+                    npc = GET_NPC(objectUUID);
+            }
 
-	public NPC GET_NPC(final int objectUUID) {
-		prepareCallable("SELECT `obj_npc`.*, `object`.`parent` FROM `object` INNER JOIN `obj_npc` ON `obj_npc`.`UID` = `object`.`UID` WHERE `object`.`UID` = ?;");
-		setLong(1, (long) objectUUID);
-		return (NPC) getObjectSingle(objectUUID);
-	}
+        } catch (SQLException e) {
+            throw new RuntimeException(e);
+        }
 
-	public int MOVE_NPC(long npcID, long parentID, float locX, float locY, float locZ) {
-		prepareCallable("UPDATE `object` INNER JOIN `obj_npc` On `object`.`UID` = `obj_npc`.`UID` SET `object`.`parent`=?, `obj_npc`.`npc_spawnX`=?, `obj_npc`.`npc_spawnY`=?, `obj_npc`.`npc_spawnZ`=? WHERE `obj_npc`.`UID`=?;");
-		setLong(1, parentID);
-		setFloat(2, locX);
-		setFloat(3, locY);
-		setFloat(4, locZ);
-		setLong(5, npcID);
-		return executeUpdate();
-	}
+        return npc;
+    }
+
+    public int DELETE_NPC(final NPC npc) {
+
+        int row_count = 0;
+
+        npc.removeFromZone();
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("DELETE FROM `object` WHERE `UID` = ?")) {
+
+            preparedStatement.setLong(1, npc.getDBID());
+            row_count = preparedStatement.executeUpdate();
+
+        } catch (SQLException e) {
+            Logger.error(e);
+
+        }
+        return row_count;
+    }
+
+    public ArrayList<NPC> GET_ALL_NPCS_FOR_ZONE(Zone zone) {
+
+        ArrayList<NPC> npcList = new ArrayList<>();
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT `obj_npc`.*, `object`.`parent` FROM `object` INNER JOIN `obj_npc` ON `obj_npc`.`UID` = `object`.`UID` WHERE `object`.`parent` = ?;")) {
+
+            preparedStatement.setLong(1, zone.getObjectUUID());
+
+            ResultSet rs = preparedStatement.executeQuery();
+            npcList = getObjectsFromRs(rs, 1000);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+
+        return npcList;
+    }
+
+    public NPC GET_NPC(final int objectUUID) {
+
+        NPC npc = null;
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT `obj_npc`.*, `object`.`parent` FROM `object` INNER JOIN `obj_npc` ON `obj_npc`.`UID` = `object`.`UID` WHERE `object`.`UID` = ?;")) {
+
+            preparedStatement.setLong(1, objectUUID);
+
+            ResultSet rs = preparedStatement.executeQuery();
+            npc = (NPC) getObjectFromRs(rs);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return npc;
+    }
+
+    public int MOVE_NPC(long npcID, long parentID, float locX, float locY, float locZ) {
+
+        int rowCount;
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `object` INNER JOIN `obj_npc` On `object`.`UID` = `obj_npc`.`UID` SET `object`.`parent`=?, `obj_npc`.`npc_spawnX`=?, `obj_npc`.`npc_spawnY`=?, `obj_npc`.`npc_spawnZ`=? WHERE `obj_npc`.`UID`=?;")) {
+
+            preparedStatement.setLong(1, parentID);
+            preparedStatement.setFloat(2, locX);
+            preparedStatement.setFloat(3, locY);
+            preparedStatement.setFloat(4, locZ);
+            preparedStatement.setLong(5, npcID);
+
+            rowCount = preparedStatement.executeUpdate();
+
+        } catch (SQLException e) {
+            Logger.error(e);
+            return 0;
+        }
+        return rowCount;
+    }
 
 
-	public String SET_PROPERTY(final NPC n, String name, Object new_value) {
-		prepareCallable("CALL npc_SETPROP(?,?,?)");
-		setLong(1, (long) n.getDBID());
-		setString(2, name);
-		setString(3, String.valueOf(new_value));
-		return getResult();
-	}
+    public String SET_PROPERTY(final NPC n, String name, Object new_value) {
 
-	public String SET_PROPERTY(final NPC n, String name, Object new_value, Object old_value) {
-		prepareCallable("CALL npc_GETSETPROP(?,?,?,?)");
-		setLong(1, (long) n.getDBID());
-		setString(2, name);
-		setString(3, String.valueOf(new_value));
-		setString(4, String.valueOf(old_value));
-		return getResult();
-	}
+        String result = "";
 
-	public void updateDatabase(final NPC npc) {
-		prepareCallable("UPDATE obj_npc SET npc_name=?, npc_contractID=?, npc_typeID=?, npc_guildID=?,"
-				+ " npc_spawnX=?, npc_spawnY=?, npc_spawnZ=?, npc_level=? ,"
-				+ " npc_buyPercent=?, npc_sellPercent=?, npc_buildingID=? WHERE UID = ?");
-		setString(1, npc.getName());
-		setInt(2, (npc.getContract() != null) ? npc.getContract().getObjectUUID() : 0);
-		setInt(3, 0);
-		setInt(4, (npc.getGuild() != null) ? npc.getGuild().getObjectUUID() : 0);
-		setFloat(5, npc.getBindLoc().x);
-		setFloat(6, npc.getBindLoc().y);
-		setFloat(7, npc.getBindLoc().z);
-		setShort(8, npc.getLevel());
-		setFloat(9, npc.getBuyPercent());
-		setFloat(10, npc.getSellPercent());
-		setInt(11, (npc.getBuilding() != null) ? npc.getBuilding().getObjectUUID() : 0);
-		setInt(12, npc.getDBID());
-		executeUpdate();
-	}
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("CALL npc_SETPROP(?,?,?)")) {
 
-	public boolean updateUpgradeTime(NPC npc, DateTime upgradeDateTime) {
+            preparedStatement.setLong(1, n.getDBID());
+            preparedStatement.setString(2, name);
+            preparedStatement.setString(3, String.valueOf(new_value));
 
+            ResultSet rs = preparedStatement.executeQuery();
 
+            if (rs.next())
+                result = rs.getString("result");
 
-		try {
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return result;
+    }
 
-			prepareCallable("UPDATE obj_npc SET upgradeDate=? "
-					+ "WHERE UID = ?");
+    public void updateDatabase(final NPC npc) {
 
-			if (upgradeDateTime == null)
-				setNULL(1, java.sql.Types.DATE);
-			else
-				setTimeStamp(1, upgradeDateTime.getMillis());
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE obj_npc SET npc_name=?, npc_contractID=?, npc_typeID=?, npc_guildID=?,"
+                     + " npc_spawnX=?, npc_spawnY=?, npc_spawnZ=?, npc_level=? ,"
+                     + " npc_buyPercent=?, npc_sellPercent=?, npc_buildingID=? WHERE UID = ?")) {
 
-			setInt(2, npc.getObjectUUID());
-			executeUpdate();
-		} catch (Exception e) {
-			Logger.error("UUID: " + npc.getObjectUUID());
-			return false;
-		}
-		return true;
-	}
+            preparedStatement.setString(1, npc.getName());
+            preparedStatement.setInt(2, (npc.getContract() != null) ? npc.getContract().getObjectUUID() : 0);
+            preparedStatement.setInt(3, 0);
+            preparedStatement.setInt(4, (npc.getGuild() != null) ? npc.getGuild().getObjectUUID() : 0);
+            preparedStatement.setFloat(5, npc.getBindLoc().x);
+            preparedStatement.setFloat(6, npc.getBindLoc().y);
+            preparedStatement.setFloat(7, npc.getBindLoc().z);
+            preparedStatement.setShort(8, npc.getLevel());
+            preparedStatement.setFloat(9, npc.getBuyPercent());
+            preparedStatement.setFloat(10, npc.getSellPercent());
+            preparedStatement.setInt(11, (npc.getBuilding() != null) ? npc.getBuilding().getObjectUUID() : 0);
+            preparedStatement.setInt(12, npc.getDBID());
 
-	public boolean UPDATE_BUY_PROFIT(NPC npc,float percent) {
-		prepareCallable("UPDATE `obj_npc` SET `npc_buyPercent`=? WHERE `UID`=?");
-		setFloat(1, percent);
-		setLong(2, npc.getObjectUUID());
-		return (executeUpdate() > 0);
-	}
+            preparedStatement.executeUpdate();
 
-	public boolean UPDATE_SELL_PROFIT(NPC npc,float percent) {
-		prepareCallable("UPDATE `obj_npc` SET `npc_sellPercent`=? WHERE `UID`=?");
-		setFloat(1, percent);
-		setLong(2, npc.getObjectUUID());
-		return (executeUpdate() > 0);
-	}
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+    }
 
-	public boolean UPDATE_SLOT(NPC npc,int slot) {
-		prepareCallable("UPDATE `obj_npc` SET `npc_slot`=? WHERE `UID`=?");
-		setFloat(1, slot);
-		setLong(2, npc.getObjectUUID());
-		return (executeUpdate() > 0);
-	}
+    public boolean updateUpgradeTime(NPC npc, DateTime upgradeDateTime) {
 
-	public boolean UPDATE_MOBBASE(NPC npc, int mobBaseID) {
-		prepareCallable("UPDATE `obj_npc` SET `npc_raceID`=? WHERE `UID`=?");
-		setLong(1, mobBaseID);
-		setLong(2, npc.getObjectUUID());
-		return (executeUpdate() > 0);
-	}
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE obj_npc SET upgradeDate=? "
+                     + "WHERE UID = ?")) {
 
-	public boolean UPDATE_EQUIPSET(NPC npc, int equipSetID) {
-		prepareCallable("UPDATE `obj_npc` SET `equipsetID`=? WHERE `UID`=?");
-		setInt(1, equipSetID);
-		setLong(2, npc.getObjectUUID());
-		return (executeUpdate() > 0);
-	}
-	
-	public boolean UPDATE_NAME(NPC npc,String name) {
-		prepareCallable("UPDATE `obj_npc` SET `npc_name`=? WHERE `UID`=?");
-		setString(1, name);
-		setLong(2, npc.getObjectUUID());
-		return (executeUpdate() > 0);
-	}
+            if (upgradeDateTime == null)
+                preparedStatement.setNull(1, java.sql.Types.DATE);
+            else
+                preparedStatement.setTimestamp(1, new java.sql.Timestamp(upgradeDateTime.getMillis()));
 
-	public void LOAD_PIRATE_NAMES() {
+            preparedStatement.setInt(2, npc.getObjectUUID());
 
-		String pirateName;
-		int mobBase;
-		int recordsRead = 0;
+            preparedStatement.execute();
+            return true;
 
-		prepareCallable("SELECT * FROM static_piratenames");
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return false;
+    }
 
-		try {
-			ResultSet rs = executeQuery();
+    public boolean UPDATE_MOBBASE(NPC npc, int mobBaseID) {
 
-			while (rs.next()) {
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_npc` SET `npc_raceID`=? WHERE `UID`=?")) {
 
-				recordsRead++;
-				mobBase = rs.getInt("mobbase");
-				pirateName = rs.getString("first_name");
+            preparedStatement.setLong(1, mobBaseID);
+            preparedStatement.setLong(2, npc.getObjectUUID());
 
-				// Handle new mobbbase entries
+            return (preparedStatement.executeUpdate() > 0);
 
-				if (NPC._pirateNames.get(mobBase) == null) {
-					NPC._pirateNames.putIfAbsent(mobBase, new ArrayList<>());
-					}
+        } catch (SQLException e) {
+            Logger.error(e);
+            return false;
+        }
+    }
 
-				// Insert name into proper arraylist
+    public boolean UPDATE_EQUIPSET(NPC npc, int equipSetID) {
 
-				NPC._pirateNames.get(mobBase).add(pirateName);
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_npc` SET `equipsetID`=? WHERE `UID`=?")) {
 
-			}
+            preparedStatement.setInt(1, equipSetID);
+            preparedStatement.setLong(2, npc.getObjectUUID());
 
-			Logger.info("names read: " + recordsRead + " for "
-			             + NPC._pirateNames.size() + " mobBases");
+            return (preparedStatement.executeUpdate() > 0);
 
-		} catch (SQLException e) {
-			Logger.error(e.getErrorCode() + ' ' + e.getMessage(), e);
-		} finally {
-			closeCallable();
-		}
-	}
+        } catch (SQLException e) {
+            Logger.error(e);
+            return false;
+        }
+    }
 
+    public boolean UPDATE_NAME(NPC npc, String name) {
 
-	public boolean ADD_TO_PRODUCTION_LIST(final long ID,final long npcUID, final long itemBaseID, DateTime dateTime, String prefix, String suffix, String name, boolean isRandom, int playerID) {
-		prepareCallable("INSERT INTO `dyn_npc_production` (`ID`,`npcUID`, `itemBaseID`,`dateToUpgrade`, `isRandom`, `prefix`, `suffix`, `name`,`playerID`) VALUES (?,?,?,?,?,?,?,?,?)");
-		setLong(1,ID);
-		setLong(2, npcUID);
-		setLong(3, itemBaseID);
-		setTimeStamp(4, dateTime.getMillis());
-		setBoolean(5, isRandom);
-		setString(6, prefix);
-		setString(7, suffix);
-		setString(8, name);
-		setInt(9,playerID);
-		return (executeUpdate() > 0);
-	}
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_npc` SET `npc_name`=? WHERE `UID`=?")) {
 
-	public boolean REMOVE_FROM_PRODUCTION_LIST(final long ID,final long npcUID) {
-		prepareCallable("DELETE FROM `dyn_npc_production` WHERE `ID`=? AND `npcUID`=?;");
-		setLong(1,ID);
-		setLong(2, npcUID);
-		return (executeUpdate() > 0);
-	}
+            preparedStatement.setString(1, name);
+            preparedStatement.setLong(2, npc.getObjectUUID());
 
-	public boolean UPDATE_ITEM_TO_INVENTORY(final long ID,final long npcUID) {
-		prepareCallable("UPDATE `dyn_npc_production` SET `inForge`=? WHERE `ID`=? AND `npcUID`=?;");
-		setByte(1, (byte)0);
-		setLong(2, ID);
-		setLong(3, npcUID);
-		return (executeUpdate() > 0);
-	}
+            return (preparedStatement.executeUpdate() > 0);
 
-	public boolean UPDATE_ITEM_PRICE(final long ID,final long npcUID, int value) {
-		prepareCallable("UPDATE `dyn_npc_production` SET `value`=? WHERE `ID`=? AND `npcUID`=?;");
-		setInt(1, value);
-		setLong(2, ID);
-		setLong(3, npcUID);
+        } catch (SQLException e) {
+            Logger.error(e);
+            return false;
+        }
+    }
 
-		return (executeUpdate() > 0);
-	}
+    public void LOAD_PIRATE_NAMES() {
 
-	public boolean UPDATE_ITEM_ID(final long ID,final long npcUID,final long value) {
-		prepareCallable("UPDATE `dyn_npc_production` SET `ID`=? WHERE `ID`=? AND `npcUID`=? LIMIT 1;");
-		setLong(1, value);
-		setLong(2, ID);
-		setLong(3, npcUID);
+        String pirateName;
+        int mobBase;
+        int recordsRead = 0;
 
-		return (executeUpdate() > 0);
-	}
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM static_piratenames")) {
 
-	public void LOAD_ALL_ITEMS_TO_PRODUCE(NPC npc) {
+            ResultSet rs = preparedStatement.executeQuery();
 
-		if (npc == null)
-			return;
+            while (rs.next()) {
 
-		prepareCallable("SELECT * FROM `dyn_npc_production` WHERE `npcUID` = ?");
-		setInt(1,npc.getObjectUUID());
+                recordsRead++;
+                mobBase = rs.getInt("mobbase");
+                pirateName = rs.getString("first_name");
 
-		try {
-			ResultSet rs = executeQuery();
+                // Handle new mobbbase entries
 
-			//shrines cached in rs for easy cache on creation.
-			while (rs.next()) {
-				ProducedItem producedItem = new ProducedItem(rs);
-				npc.forgedItems.add(producedItem);
-			}
+                if (NPC._pirateNames.get(mobBase) == null)
+                    NPC._pirateNames.putIfAbsent(mobBase, new ArrayList<>());
 
-		} catch (SQLException e) {
-			Logger.error(e.getErrorCode() + ' ' + e.getMessage(), e);
-		} finally {
-			closeCallable();
-		}
-	}
-	
-	public boolean UPDATE_PROFITS(NPC npc,ProfitType profitType, float value){
-		prepareCallable("UPDATE `dyn_npc_profits` SET `" + profitType.dbField + "` = ? WHERE `npcUID`=?");
-		setFloat(1, value);
-		setInt(2, npc.getObjectUUID());
-		return (executeUpdate() > 0);
-	}
-	
-	public void LOAD_NPC_PROFITS() {
+                // Insert name into proper arraylist
 
-		HashMap<Integer, ArrayList<BuildingRegions>> regions;
-		NPCProfits npcProfit;
+                NPC._pirateNames.get(mobBase).add(pirateName);
+            }
 
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
 
-		prepareCallable("SELECT * FROM dyn_npc_profits");
+        Logger.info("names read: " + recordsRead + " for "
+                + NPC._pirateNames.size() + " mobBases");
+    }
 
-		try {
-			ResultSet rs = executeQuery();
+    public boolean ADD_TO_PRODUCTION_LIST(final long ID, final long npcUID, final long itemBaseID, DateTime dateTime, String prefix, String suffix, String name, boolean isRandom, int playerID) {
 
-			while (rs.next()) {
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("INSERT INTO `dyn_npc_production` (`ID`,`npcUID`, `itemBaseID`,`dateToUpgrade`, `isRandom`, `prefix`, `suffix`, `name`,`playerID`) VALUES (?,?,?,?,?,?,?,?,?)")) {
 
-				
-				npcProfit = new NPCProfits(rs);
-				NPCProfits.ProfitCache.put(npcProfit.npcUID, npcProfit);
-			}
+            preparedStatement.setLong(1, ID);
+            preparedStatement.setLong(2, npcUID);
+            preparedStatement.setLong(3, itemBaseID);
+            preparedStatement.setTimestamp(4, new java.sql.Timestamp(dateTime.getMillis()));
+            preparedStatement.setBoolean(5, isRandom);
+            preparedStatement.setString(6, prefix);
+            preparedStatement.setString(7, suffix);
+            preparedStatement.setString(8, name);
+            preparedStatement.setInt(9, playerID);
 
-		} catch (SQLException e) {
-			Logger.error(": " + e.getErrorCode() + ' ' + e.getMessage(), e);
-		} finally {
-			closeCallable();
-		}
-	}
-	
-	public boolean CREATE_PROFITS(NPC npc){
-			prepareCallable("INSERT INTO `dyn_npc_profits` (`npcUID`) VALUES (?)");
-			setLong(1,npc.getObjectUUID());
-			return (executeUpdate() > 0);
-	}
+            return (preparedStatement.executeUpdate() > 0);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+            return false;
+        }
+    }
+
+    public boolean REMOVE_FROM_PRODUCTION_LIST(final long ID, final long npcUID) {
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("DELETE FROM `dyn_npc_production` WHERE `ID`=? AND `npcUID`=?;")) {
+
+            preparedStatement.setLong(1, ID);
+            preparedStatement.setLong(2, npcUID);
+
+            return (preparedStatement.executeUpdate() > 0);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+            return false;
+        }
+    }
+
+    public boolean UPDATE_ITEM_TO_INVENTORY(final long ID, final long npcUID) {
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `dyn_npc_production` SET `inForge`=? WHERE `ID`=? AND `npcUID`=?;")) {
+
+            preparedStatement.setByte(1, (byte) 0);
+            preparedStatement.setLong(2, ID);
+            preparedStatement.setLong(3, npcUID);
+
+            return (preparedStatement.executeUpdate() > 0);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+            return false;
+        }
+    }
+
+    public boolean UPDATE_ITEM_PRICE(final long ID, final long npcUID, int value) {
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `dyn_npc_production` SET `value`=? WHERE `ID`=? AND `npcUID`=?;")) {
+
+            preparedStatement.setInt(1, value);
+            preparedStatement.setLong(2, ID);
+            preparedStatement.setLong(3, npcUID);
+
+            return (preparedStatement.executeUpdate() > 0);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+            return false;
+        }
+    }
+
+    public boolean UPDATE_ITEM_ID(final long ID, final long npcUID, final long value) {
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `dyn_npc_production` SET `ID`=? WHERE `ID`=? AND `npcUID`=? LIMIT 1;")) {
+
+            preparedStatement.setLong(1, value);
+            preparedStatement.setLong(2, ID);
+            preparedStatement.setLong(3, npcUID);
+
+            return (preparedStatement.executeUpdate() > 0);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+            return false;
+        }
+    }
+
+    public void LOAD_ALL_ITEMS_TO_PRODUCE(NPC npc) {
+
+        if (npc == null)
+            return;
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `dyn_npc_production` WHERE `npcUID` = ?")) {
+
+            preparedStatement.setInt(1, npc.getObjectUUID());
+            ResultSet rs = preparedStatement.executeQuery();
+
+            while (rs.next()) {
+                ProducedItem producedItem = new ProducedItem(rs);
+                npc.forgedItems.add(producedItem);
+            }
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+    }
+
+    public boolean UPDATE_PROFITS(NPC npc, ProfitType profitType, float value) {
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `dyn_npc_profits` SET `" + profitType.dbField + "` = ? WHERE `npcUID`=?")) {
+
+            preparedStatement.setFloat(1, value);
+            preparedStatement.setInt(2, npc.getObjectUUID());
+
+            return (preparedStatement.executeUpdate() > 0);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+            return false;
+        }
+    }
+
+    public void LOAD_NPC_PROFITS() {
+
+        NPCProfits npcProfit;
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM dyn_npc_profits")) {
+
+            ResultSet rs = preparedStatement.executeQuery();
+
+            while (rs.next()) {
+                npcProfit = new NPCProfits(rs);
+                NPCProfits.ProfitCache.put(npcProfit.npcUID, npcProfit);
+            }
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+    }
+
+    public boolean CREATE_PROFITS(NPC npc) {
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("INSERT INTO `dyn_npc_profits` (`npcUID`) VALUES (?)")) {
+
+            preparedStatement.setLong(1, npc.getObjectUUID());
+            return (preparedStatement.executeUpdate() > 0);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+            return false;
+        }
+    }
 }

src/engine/db/handlers/dbPlayerCharacterHandler.java

@@ -18,6 +18,8 @@ import engine.objects.PlayerFriends;
 import engine.server.MBServerStatics;
 import org.pmw.tinylog.Logger;
 
+import java.sql.Connection;
+import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.ArrayList;
@@ -25,378 +27,545 @@ import java.util.concurrent.ConcurrentHashMap;
 
 public class dbPlayerCharacterHandler extends dbHandlerBase {
 
-	public dbPlayerCharacterHandler() {
-		this.localClass = PlayerCharacter.class;
-		this.localObjectType = Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
-	}
+    public dbPlayerCharacterHandler() {
+        this.localClass = PlayerCharacter.class;
+        this.localObjectType = Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
+    }
 
-	public PlayerCharacter ADD_PLAYER_CHARACTER(final PlayerCharacter toAdd) {
-		if (toAdd.getAccount() == null) {
-			return null;
-		}
-		prepareCallable("CALL `character_CREATE`(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);");
-		setLong(1, toAdd.getAccount().getObjectUUID());
-		setString(2, toAdd.getFirstName());
-		setString(3, toAdd.getLastName());
-		setInt(4, toAdd.getRace().getRaceRuneID());
-		setInt(5, toAdd.getBaseClass().getObjectUUID());
-		setInt(6, toAdd.getStrMod());
-		setInt(7, toAdd.getDexMod());
-		setInt(8, toAdd.getConMod());
-		setInt(9, toAdd.getIntMod());
-		setInt(10, toAdd.getSpiMod());
-		setInt(11, toAdd.getExp());
-		setInt(12, toAdd.getSkinColor());
-		setInt(13, toAdd.getHairColor());
-		setByte(14, toAdd.getHairStyle());
-		setInt(15, toAdd.getBeardColor());
-		setByte(16, toAdd.getBeardStyle());
+    public PlayerCharacter ADD_PLAYER_CHARACTER(final PlayerCharacter toAdd) {
 
-		int objectUUID = (int) getUUID();
-		if (objectUUID > 0) {
-			return GET_PLAYER_CHARACTER(objectUUID);
-		}
-		return null;
-	}
+        PlayerCharacter playerCharacter = null;
 
-	public boolean SET_IGNORE_LIST(int sourceID, int targetID, boolean toIgnore, String charName) {
-		if (toIgnore) {
-			//Add to ignore list
-			prepareCallable("INSERT INTO `dyn_character_ignore` (`accountUID`, `ignoringUID`, `characterName`) VALUES (?, ?, ?)");
-			setLong(1, (long) sourceID);
-			setLong(2, (long) targetID);
-			setString(3, charName);
-			return (executeUpdate() > 0);
-		} else {
-			//delete from ignore list
-			prepareCallable("DELETE FROM `dyn_character_ignore` WHERE `accountUID` = ? && `ignoringUID` = ?");
-			setLong(1, (long) sourceID);
-			setLong(2, (long) targetID);
-			return (executeUpdate() > 0);
-		}
-	}
+        if (toAdd.getAccount() == null)
+            return null;
 
-	public static boolean DELETE_CHARACTER_IGNORE(final PlayerCharacter pc, final ArrayList<Integer> toDelete) {
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("CALL `character_CREATE`(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);")) {
 
-		return false;
-	}
+            preparedStatement.setLong(1, toAdd.getAccount().getObjectUUID());
+            preparedStatement.setString(2, toAdd.getFirstName());
+            preparedStatement.setString(3, toAdd.getLastName());
+            preparedStatement.setInt(4, toAdd.getRace().getRaceRuneID());
+            preparedStatement.setInt(5, toAdd.getBaseClass().getObjectUUID());
+            preparedStatement.setInt(6, toAdd.getStrMod());
+            preparedStatement.setInt(7, toAdd.getDexMod());
+            preparedStatement.setInt(8, toAdd.getConMod());
+            preparedStatement.setInt(9, toAdd.getIntMod());
+            preparedStatement.setInt(10, toAdd.getSpiMod());
+            preparedStatement.setInt(11, toAdd.getExp());
+            preparedStatement.setInt(12, toAdd.getSkinColor());
+            preparedStatement.setInt(13, toAdd.getHairColor());
+            preparedStatement.setByte(14, toAdd.getHairStyle());
+            preparedStatement.setInt(15, toAdd.getBeardColor());
+            preparedStatement.setByte(16, toAdd.getBeardStyle());
 
-	public ArrayList<PlayerCharacter> GET_ALL_PLAYERCHARACTERS() {
-		prepareCallable("SELECT * FROM `obj_character`");
-		return getObjectList();
-	}
+            ResultSet rs = preparedStatement.executeQuery();
 
-	public ArrayList<PlayerCharacter> GET_CHARACTERS_FOR_ACCOUNT(final int id, boolean forceFromDB) {
-		prepareCallable("SELECT `obj_character`.*, `object`.`parent` FROM `object` INNER JOIN `obj_character` ON `obj_character`.`UID` = `object`.`UID` WHERE `object`.`parent`=? && `obj_character`.`char_isActive`='1';");
-		setLong(1, (long) id);
-		return getObjectList(10, forceFromDB);
-	}
+            if (rs.next()) {
+                int objectUUID = (int) rs.getLong("UID");
 
-	public ArrayList<PlayerCharacter> GET_CHARACTERS_FOR_ACCOUNT(final int id) {
-		prepareCallable("SELECT `obj_character`.*, `object`.`parent` FROM `object` INNER JOIN `obj_character` ON `obj_character`.`UID` = `object`.`UID` WHERE `object`.`parent`=? && `obj_character`.`char_isActive`='1';");
-		setLong(1, (long) id);
-		return getObjectList();
-	}
+                if (objectUUID > 0)
+                    playerCharacter = GET_PLAYER_CHARACTER(objectUUID);
+            }
 
-	public ArrayList<PlayerCharacter> GET_ALL_CHARACTERS() {
-		prepareCallable("SELECT `obj_character`.*, `object`.`parent` FROM `object` INNER JOIN `obj_character` ON `obj_character`.`UID` = `object`.`UID` WHERE `obj_character`.`char_isActive`='1';");
-		return getObjectList();
-	}
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
 
-	/**
-	 *
-	 * <code>getFirstName</code> looks up the first name of a PlayerCharacter by
-	 * first checking the GOM cache and then querying the database.
-	 * PlayerCharacter objects that are not already cached won't be instantiated
-	 * and cached.
-	 *
-	 */
-	public String GET_FIRST_NAME(final int objectUUID) {
-		prepareCallable("SELECT `char_firstname` from `obj_character` WHERE `UID` = ? LIMIT 1");
-		setLong(1, (long) objectUUID);
-		String firstName = "";
-		try {
-			ResultSet rs = executeQuery();
-			if (rs.next()) {
-				firstName = rs.getString("char_firstname");
-			}
-		} catch (SQLException e) {
-			Logger.error( e);
-		} finally {
-			closeCallable();
-		}
-		return firstName;
-	}
+        return playerCharacter;
+    }
 
-	public ConcurrentHashMap<Integer, String> GET_IGNORE_LIST(final int objectUUID, final boolean skipActiveCheck) {
-		ConcurrentHashMap<Integer, String> out = new ConcurrentHashMap<>(MBServerStatics.CHM_INIT_CAP, MBServerStatics.CHM_LOAD, MBServerStatics.CHM_THREAD_LOW);
-		prepareCallable("SELECT * FROM `dyn_character_ignore` WHERE `accountUID` = ?;");
-		setLong(1, (long) objectUUID);
-		try {
-			ResultSet rs = executeQuery();
-			while (rs.next()) {
-				int ignoreCharacterID = rs.getInt("ignoringUID");
-				if (ignoreCharacterID == 0) {
-					continue;
-				}
-				String name = rs.getString("characterName");
-				out.put(ignoreCharacterID, name);
-			}
-			rs.close();
-		} catch (SQLException e) {
-			Logger.error("SQL Error number: " + e.getErrorCode());
-			return out; // null to explicitly indicate a problem and prevent data loss
-		} finally {
-			closeCallable();
-		}
-		return out;
-	}
+    public boolean SET_IGNORE_LIST(int sourceID, int targetID, boolean toIgnore, String charName) {
 
-	public PlayerCharacter GET_PLAYER_CHARACTER(final int objectUUID) {
+        String queryString = "";
 
-		if (objectUUID == 0)
-			return null;
+        if (toIgnore)
+            queryString = "INSERT INTO `dyn_character_ignore` (`accountUID`, `ignoringUID`, `characterName`) VALUES (?, ?, ?)";
+        else
+            queryString = "DELETE FROM `dyn_character_ignore` WHERE `accountUID` = ? && `ignoringUID` = ?";
 
-		PlayerCharacter pc = (PlayerCharacter) DbManager.getFromCache(Enum.GameObjectType.PlayerCharacter, objectUUID);
-		if (pc != null)
-			return pc;
-		prepareCallable("SELECT `obj_character`.*, `object`.`parent` FROM `object` INNER JOIN `obj_character` ON `obj_character`.`UID` = `object`.`UID` WHERE `object`.`UID` = ?");
-		setLong(1, (long) objectUUID);
-		return (PlayerCharacter) getObjectSingle(objectUUID);
-	}
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement(queryString)) {
 
-	public boolean INSERT_CHARACTER_IGNORE(final PlayerCharacter pc, final ArrayList<Integer> toAdd) {
-		boolean allWorked = true;
-		prepareCallable("INSERT INTO `dyn_character_ignore` (`characterUID`, `ignoringUID`) VALUES (?, ?)");
-		setLong(1, (long) pc.getObjectUUID());
-		for (int id : toAdd) {
-			setLong(2, (long) id);
-			if (executeUpdate(false) == 0) {
-				allWorked = false;
-			}
-		}
-		closeCallable();
-		return allWorked;
-	}
+            preparedStatement.setLong(1, sourceID);
+            preparedStatement.setLong(2, targetID);
 
-	public boolean IS_CHARACTER_NAME_UNIQUE(final String firstName) {
-		boolean unique = true;
-		prepareCallable("SELECT `char_firstname` FROM `obj_character` WHERE `char_isActive`=1 && `char_firstname`=?");
-		setString(1, firstName);
-		try {
-			ResultSet rs = executeQuery();
-			if (rs.next()) {
-				unique = false;
-			}
-			rs.close();
-		} catch (SQLException e) {
-			Logger.error("SQL Error number: " + e.getMessage());
-			unique = false;
-		} finally {
-			closeCallable();
-		}
-		return unique;
-	}
+            if (toIgnore)
+                preparedStatement.setString(3, charName);
 
-	public boolean UPDATE_NAME(String oldFirstName, String newFirstName, String newLastName) {
-		prepareCallable("UPDATE `obj_character` SET `char_firstname`=?, `char_lastname`=? WHERE `char_firstname`=? AND `char_isActive`='1'");
-		setString(1, newFirstName);
-		setString(2, newLastName);
-		setString(3, oldFirstName);
-		return (executeUpdate() != 0);
-	}
+            return (preparedStatement.executeUpdate() > 0);
 
-	public boolean SET_DELETED(final PlayerCharacter pc) {
-		prepareCallable("UPDATE `obj_character` SET `char_isActive`=? WHERE `UID` = ?");
-		setBoolean(1, !pc.isDeleted());
-		setLong(2, (long) pc.getObjectUUID());
-		return (executeUpdate() != 0);
-	}
-	public boolean SET_ACTIVE(final PlayerCharacter pc, boolean status) {
-		prepareCallable("UPDATE `obj_character` SET `char_isActive`=? WHERE `UID` = ?");
-		setBoolean(1, status);
-		setLong(2, (long) pc.getObjectUUID());
-		return (executeUpdate() != 0);
-	}
-	public boolean SET_BIND_BUILDING(final PlayerCharacter pc, int bindBuildingID) {
-		prepareCallable("UPDATE `obj_character` SET `char_bindBuilding`=? WHERE `UID` = ?");
-		setInt(1, bindBuildingID);
-		setLong(2, (long) pc.getObjectUUID());
-		return (executeUpdate() != 0);
-	}
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return false;
+    }
 
-	public boolean SET_ANNIVERSERY(final PlayerCharacter pc, boolean flag) {
-		prepareCallable("UPDATE `obj_character` SET `anniversery`=? WHERE `UID` = ?");
-		setBoolean(1, flag);
-		setLong(2, (long) pc.getObjectUUID());
-		return (executeUpdate() != 0);
-	}
+    public ArrayList<PlayerCharacter> GET_CHARACTERS_FOR_ACCOUNT(final int id) {
+
+        ArrayList<PlayerCharacter> characterList = new ArrayList<>();
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT `obj_character`.*, `object`.`parent` FROM `object` INNER JOIN `obj_character` ON `obj_character`.`UID` = `object`.`UID` WHERE `object`.`parent`=? && `obj_character`.`char_isActive`='1';")) {
+
+            preparedStatement.setLong(1, id);
+            ResultSet rs = preparedStatement.executeQuery();
+            characterList = getObjectsFromRs(rs, 10);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+
+        return characterList;
+    }
+
+    public ArrayList<PlayerCharacter> GET_ALL_CHARACTERS() {
+
+        ArrayList<PlayerCharacter> characterList = new ArrayList<>();
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT `obj_character`.*, `object`.`parent` FROM `object` INNER JOIN `obj_character` ON `obj_character`.`UID` = `object`.`UID` WHERE `obj_character`.`char_isActive`='1';")) {
+
+            ResultSet rs = preparedStatement.executeQuery();
+            characterList = getObjectsFromRs(rs, 2000);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+
+        return characterList;
+    }
+
+    /**
+     * <code>getFirstName</code> looks up the first name of a PlayerCharacter by
+     * first checking the GOM cache and then querying the database.
+     * PlayerCharacter objects that are not already cached won't be instantiated
+     * and cached.
+     */
+
+    public ConcurrentHashMap<Integer, String> GET_IGNORE_LIST(final int objectUUID, final boolean skipActiveCheck) {
+
+        ConcurrentHashMap<Integer, String> ignoreList = new ConcurrentHashMap<>(MBServerStatics.CHM_INIT_CAP, MBServerStatics.CHM_LOAD, MBServerStatics.CHM_THREAD_LOW);
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `dyn_character_ignore` WHERE `accountUID` = ?;")) {
+
+            preparedStatement.setLong(1, objectUUID);
+
+            ResultSet rs = preparedStatement.executeQuery();
+
+            while (rs.next()) {
+                int ignoreCharacterID = rs.getInt("ignoringUID");
+
+                if (ignoreCharacterID == 0)
+                    continue;
+
+                String name = rs.getString("characterName");
+                ignoreList.put(ignoreCharacterID, name);
+            }
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+
+        return ignoreList;
+    }
+
+    public PlayerCharacter GET_PLAYER_CHARACTER(final int objectUUID) {
+
+        if (objectUUID == 0)
+            return null;
+
+        PlayerCharacter playerCharacter = (PlayerCharacter) DbManager.getFromCache(Enum.GameObjectType.PlayerCharacter, objectUUID);
+
+        if (playerCharacter != null)
+            return playerCharacter;
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT `obj_character`.*, `object`.`parent` FROM `object` INNER JOIN `obj_character` ON `obj_character`.`UID` = `object`.`UID` WHERE `object`.`UID` = ?")) {
+
+            preparedStatement.setLong(1, objectUUID);
+
+            ResultSet rs = preparedStatement.executeQuery();
+            playerCharacter = (PlayerCharacter) getObjectFromRs(rs);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return playerCharacter;
+    }
+
+    public boolean IS_CHARACTER_NAME_UNIQUE(final String firstName) {
+
+        boolean unique = true;
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT `char_firstname` FROM `obj_character` WHERE `char_isActive`=1 && `char_firstname`=?")) {
+
+            preparedStatement.setString(1, firstName);
+
+            ResultSet rs = preparedStatement.executeQuery();
+
+            if (rs.next())
+                unique = false;
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+
+        return unique;
+    }
+
+    public boolean UPDATE_NAME(String oldFirstName, String newFirstName, String newLastName) {
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_character` SET `char_firstname`=?, `char_lastname`=? WHERE `char_firstname`=? AND `char_isActive`='1'")) {
+
+            preparedStatement.setString(1, newFirstName);
+            preparedStatement.setString(2, newLastName);
+            preparedStatement.setString(3, oldFirstName);
+
+            return (preparedStatement.executeUpdate() > 0);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return false;
+    }
+
+    public boolean SET_DELETED(final PlayerCharacter pc) {
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_character` SET `char_isActive`=? WHERE `UID` = ?")) {
+
+            preparedStatement.setBoolean(1, !pc.isDeleted());
+            preparedStatement.setLong(2, pc.getObjectUUID());
+
+            return (preparedStatement.executeUpdate() > 0);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return false;
+    }
+
+    public boolean SET_ACTIVE(final PlayerCharacter pc, boolean status) {
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_character` SET `char_isActive`=? WHERE `UID` = ?")) {
+
+            preparedStatement.setBoolean(1, status);
+            preparedStatement.setLong(2, pc.getObjectUUID());
+
+            return (preparedStatement.executeUpdate() > 0);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return false;
+    }
+
+    public boolean SET_BIND_BUILDING(final PlayerCharacter pc, int bindBuildingID) {
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_character` SET `char_bindBuilding`=? WHERE `UID` = ?")) {
+
+            preparedStatement.setInt(1, bindBuildingID);
+            preparedStatement.setLong(2, pc.getObjectUUID());
+
+            return (preparedStatement.executeUpdate() > 0);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return false;
+    }
+
+    public boolean SET_ANNIVERSERY(final PlayerCharacter pc, boolean flag) {
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_character` SET `anniversery`=? WHERE `UID` = ?")) {
+
+            preparedStatement.setBoolean(1, flag);
+            preparedStatement.setLong(2, pc.getObjectUUID());
+
+            return (preparedStatement.executeUpdate() > 0);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return false;
+    }
 
 
-	public boolean UPDATE_CHARACTER_EXPERIENCE(final PlayerCharacter pc) {
-		prepareCallable("UPDATE `obj_character` SET `char_experience`=? WHERE `UID` = ?");
-		setInt(1, pc.getExp());
-		setLong(2, (long) pc.getObjectUUID());
-		return (executeUpdate() != 0);
-	}
-	
-	public boolean UPDATE_GUILD(final PlayerCharacter pc, int guildUUID) {
-		prepareCallable("UPDATE `obj_character` SET `guildUID`=? WHERE `UID` = ?");
-		setInt(1, guildUUID);
-		setLong(2, (long) pc.getObjectUUID());
-		return (executeUpdate() != 0);
-	}
+    public boolean UPDATE_CHARACTER_EXPERIENCE(final PlayerCharacter pc) {
 
-	public boolean UPDATE_CHARACTER_STAT(final PlayerCharacter pc, String stat, short amount) {
-		prepareCallable("UPDATE `obj_character` SET `" + stat + "`=? WHERE `UID`=?");
-		setInt(1, pc.getExp());
-		setLong(2, (long) pc.getObjectUUID());
-		return (executeUpdate() != 0);
-	}
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_character` SET `char_experience`=? WHERE `UID` = ?")) {
 
-	public boolean UPDATE_CHARACTER_STATS(final PlayerCharacter pc) {
-		prepareCallable("UPDATE `obj_character` SET `char_strMod`=?, `char_dexMod`=?, `char_conMod`=?, `char_intMod`=?, `char_spiMod`=? WHERE `UID`=?");
-		setInt(1, pc.getStrMod());
-		setInt(2, pc.getDexMod());
-		setInt(3, pc.getConMod());
-		setInt(4, pc.getIntMod());
-		setInt(5, pc.getSpiMod());
-		setLong(6, (long) pc.getObjectUUID());
-		return (executeUpdate() != 0);
-	}
+            preparedStatement.setInt(1, pc.getExp());
+            preparedStatement.setLong(2, pc.getObjectUUID());
 
-	public String SET_PROPERTY(final PlayerCharacter c, String name, Object new_value) {
-		prepareCallable("CALL character_SETPROP(?,?,?)");
-		setLong(1, (long) c.getObjectUUID());
-		setString(2, name);
-		setString(3, String.valueOf(new_value));
-		return getResult();
-	}
+            return (preparedStatement.executeUpdate() > 0);
 
-	public String SET_PROPERTY(final PlayerCharacter c, String name, Object new_value, Object old_value) {
-		prepareCallable("CALL character_GETSETPROP(?,?,?,?)");
-		setLong(1, (long) c.getObjectUUID());
-		setString(2, name);
-		setString(3, String.valueOf(new_value));
-		setString(4, String.valueOf(old_value));
-		return getResult();
-	}
-	
-	public boolean SET_PROMOTION_CLASS(PlayerCharacter player, int promotionClassID) {
-		prepareCallable("UPDATE `obj_character` SET `char_promotionClassID`=?  WHERE `UID`=?;");
-		setInt(1,promotionClassID);
-		setInt(2, player.getObjectUUID());
-		return (executeUpdate() != 0);
-	}
-	
-	public boolean SET_INNERCOUNCIL(PlayerCharacter player, boolean isInnerCouncil) {
-		prepareCallable("UPDATE `obj_character` SET `guild_isInnerCouncil`=?  WHERE `UID`=?;");
-		setBoolean(1,isInnerCouncil);
-		setInt(2, player.getObjectUUID());
-		return (executeUpdate() != 0);
-	}
-	
-	public boolean SET_FULL_MEMBER(PlayerCharacter player, boolean isFullMember) {
-		prepareCallable("UPDATE `obj_character` SET `guild_isFullMember`=?  WHERE `UID`=?;");
-		setBoolean(1,isFullMember);
-		setInt(2, player.getObjectUUID());
-		return (executeUpdate() != 0);
-	}
-	
-	public boolean SET_TAX_COLLECTOR(PlayerCharacter player, boolean isTaxCollector) {
-		prepareCallable("UPDATE `obj_character` SET `guild_isTaxCollector`=?  WHERE `UID`=?;");
-		setBoolean(1,isTaxCollector);
-		setInt(2, player.getObjectUUID());
-		return (executeUpdate() != 0);
-	}
-	
-	public boolean SET_RECRUITER(PlayerCharacter player, boolean isRecruiter) {
-		prepareCallable("UPDATE `obj_character` SET `guild_isRecruiter`=?  WHERE `UID`=?;");
-		setBoolean(1,isRecruiter);
-		setInt(2, player.getObjectUUID());
-		return (executeUpdate() != 0);
-	}
-	
-	public boolean SET_GUILD_TITLE(PlayerCharacter player, int title) {
-		prepareCallable("UPDATE `obj_character` SET `guild_title`=?  WHERE `UID`=?;");
-		setInt(1,title);
-		setInt(2, player.getObjectUUID());
-		return (executeUpdate() != 0);
-	}
-	
-	
-	
-	public boolean ADD_FRIEND(int source, long friend){
-		prepareCallable("INSERT INTO `dyn_character_friends` (`playerUID`, `friendUID`) VALUES (?, ?)");
-		setLong(1, (long) source);
-		setLong(2, (long)friend);
-		return (executeUpdate() != 0);
-	}
-	
-	public boolean REMOVE_FRIEND(int source, int friend){
-		prepareCallable("DELETE FROM `dyn_character_friends` WHERE (`playerUID`=?) AND (`friendUID`=?)");
-		setLong(1, (long) source);
-		setLong(2, (long)friend);
-		return (executeUpdate() != 0);
-	}
-	
-	public void LOAD_PLAYER_FRIENDS() {
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return false;
+    }
 
-		PlayerFriends playerFriend;
+    public boolean UPDATE_GUILD(final PlayerCharacter pc, int guildUUID) {
 
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_character` SET `guildUID`=? WHERE `UID` = ?")) {
 
-		prepareCallable("SELECT * FROM dyn_character_friends");
+            preparedStatement.setInt(1, guildUUID);
+            preparedStatement.setLong(2, pc.getObjectUUID());
 
-		try {
-			ResultSet rs = executeQuery();
+            return (preparedStatement.executeUpdate() > 0);
 
-			while (rs.next()) {
-				playerFriend = new PlayerFriends(rs);
-			}
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return false;
+    }
 
+    public boolean UPDATE_CHARACTER_STATS(final PlayerCharacter pc) {
 
-		} catch (SQLException e) {
-			Logger.error("LoadMeshBounds: " + e.getErrorCode() + ' ' + e.getMessage(), e);
-		} finally {
-			closeCallable();
-		}
-	}
-	
-	public boolean ADD_HERALDY(int source, AbstractWorldObject character){
-		prepareCallable("INSERT INTO `dyn_character_heraldy` (`playerUID`, `characterUID`,`characterType`) VALUES (?, ?,?)");
-		setLong(1, (long) source);
-		setLong(2, (long)character.getObjectUUID());
-		setInt(3, character.getObjectType().ordinal());
-		return (executeUpdate() != 0);
-	}
-	
-	public boolean REMOVE_HERALDY(int source, int characterUID){
-		prepareCallable("DELETE FROM `dyn_character_heraldy` WHERE (`playerUID`=?) AND (`characterUID`=?)");
-		setLong(1, (long) source);
-		setLong(2, (long)characterUID);
-		return (executeUpdate() != 0);
-	}
-	
-	public void LOAD_HERALDY() {
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_character` SET `char_strMod`=?, `char_dexMod`=?, `char_conMod`=?, `char_intMod`=?, `char_spiMod`=? WHERE `UID`=?")) {
 
-		Heraldry heraldy;
+            preparedStatement.setInt(1, pc.getStrMod());
+            preparedStatement.setInt(2, pc.getDexMod());
+            preparedStatement.setInt(3, pc.getConMod());
+            preparedStatement.setInt(4, pc.getIntMod());
+            preparedStatement.setInt(5, pc.getSpiMod());
+            preparedStatement.setLong(6, pc.getObjectUUID());
 
+            return (preparedStatement.executeUpdate() > 0);
 
-		prepareCallable("SELECT * FROM dyn_character_heraldy");
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return false;
+    }
 
-		try {
-			ResultSet rs = executeQuery();
+    public String SET_PROPERTY(final PlayerCharacter playerCharacter, String name, Object new_value) {
 
-			while (rs.next()) {
-				heraldy = new Heraldry(rs);
-			}
+        String result = "";
 
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("CALL character_SETPROP(?,?,?)")) {
+
+            preparedStatement.setLong(1, playerCharacter.getObjectUUID());
+            preparedStatement.setString(2, name);
+            preparedStatement.setString(3, String.valueOf(new_value));
+
+            ResultSet rs = preparedStatement.executeQuery();
+
+            if (rs.next())
+                result = rs.getString("result");
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return result;
+    }
+
+    public boolean SET_PROMOTION_CLASS(PlayerCharacter player, int promotionClassID) {
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_character` SET `char_promotionClassID`=?  WHERE `UID`=?;")) {
+
+            preparedStatement.setInt(1, promotionClassID);
+            preparedStatement.setInt(2, player.getObjectUUID());
+
+            return (preparedStatement.executeUpdate() > 0);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return false;
+    }
+
+    public boolean SET_INNERCOUNCIL(PlayerCharacter player, boolean isInnerCouncil) {
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_character` SET `guild_isInnerCouncil`=?  WHERE `UID`=?;")) {
+
+            preparedStatement.setBoolean(1, isInnerCouncil);
+            preparedStatement.setInt(2, player.getObjectUUID());
+
+            return (preparedStatement.executeUpdate() > 0);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return false;
+    }
+
+    public boolean SET_FULL_MEMBER(PlayerCharacter player, boolean isFullMember) {
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_character` SET `guild_isFullMember`=?  WHERE `UID`=?;")) {
+
+            preparedStatement.setBoolean(1, isFullMember);
+            preparedStatement.setInt(2, player.getObjectUUID());
+
+            return (preparedStatement.executeUpdate() > 0);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return false;
+    }
+
+    public boolean SET_TAX_COLLECTOR(PlayerCharacter player, boolean isTaxCollector) {
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_character` SET `guild_isTaxCollector`=?  WHERE `UID`=?;")) {
+
+            preparedStatement.setBoolean(1, isTaxCollector);
+            preparedStatement.setInt(2, player.getObjectUUID());
+
+            return (preparedStatement.executeUpdate() > 0);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return false;
+    }
+
+    public boolean SET_RECRUITER(PlayerCharacter player, boolean isRecruiter) {
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_character` SET `guild_isRecruiter`=?  WHERE `UID`=?;")) {
+
+            preparedStatement.setBoolean(1, isRecruiter);
+            preparedStatement.setInt(2, player.getObjectUUID());
+
+            return (preparedStatement.executeUpdate() > 0);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return false;
+    }
+
+    public boolean SET_GUILD_TITLE(PlayerCharacter player, int title) {
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_character` SET `guild_title`=?  WHERE `UID`=?;")) {
+
+            preparedStatement.setInt(1, title);
+            preparedStatement.setInt(2, player.getObjectUUID());
+
+            return (preparedStatement.executeUpdate() > 0);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return false;
+    }
+
+    public boolean ADD_FRIEND(int source, long friend) {
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("INSERT INTO `dyn_character_friends` (`playerUID`, `friendUID`) VALUES (?, ?)")) {
+
+            preparedStatement.setLong(1, source);
+            preparedStatement.setLong(2, friend);
+
+            return (preparedStatement.executeUpdate() > 0);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return false;
+    }
+
+    public boolean REMOVE_FRIEND(int source, int friend) {
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("DELETE FROM `dyn_character_friends` WHERE (`playerUID`=?) AND (`friendUID`=?)")) {
+
+            preparedStatement.setLong(1, source);
+            preparedStatement.setLong(2, friend);
+
+            return (preparedStatement.executeUpdate() > 0);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return false;
+    }
+
+    public void LOAD_PLAYER_FRIENDS() {
+
+        PlayerFriends playerFriend;
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM dyn_character_friends")) {
+
+            ResultSet rs = preparedStatement.executeQuery();
+
+            while (rs.next())
+                playerFriend = new PlayerFriends(rs);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+
+    }
+
+    public boolean ADD_HERALDY(int source, AbstractWorldObject character) {
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("INSERT INTO `dyn_character_heraldy` (`playerUID`, `characterUID`,`characterType`) VALUES (?, ?,?)")) {
+
+            preparedStatement.setLong(1, source);
+            preparedStatement.setLong(2, character.getObjectUUID());
+            preparedStatement.setInt(3, character.getObjectType().ordinal());
+
+            return (preparedStatement.executeUpdate() > 0);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return false;
+    }
+
+    public boolean REMOVE_HERALDY(int source, int characterUID) {
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("DELETE FROM `dyn_character_heraldy` WHERE (`playerUID`=?) AND (`characterUID`=?)")) {
+
+            preparedStatement.setLong(1, source);
+            preparedStatement.setLong(2, characterUID);
+
+            return (preparedStatement.executeUpdate() > 0);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return false;
+    }
+
+    public void LOAD_HERALDY() {
+
+        Heraldry heraldy;
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM dyn_character_heraldy")) {
+
+            ResultSet rs = preparedStatement.executeQuery();
+
+            while (rs.next())
+                heraldy = new Heraldry(rs);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+    }
 
-		} catch (SQLException e) {
-			Logger.error("LoadHeraldy: " + e.getErrorCode() + ' ' + e.getMessage(), e);
-		} finally {
-			closeCallable();
-		}
-	}
-	
 }

src/engine/db/handlers/dbPromotionClassHandler.java

@@ -9,9 +9,12 @@
 
 package engine.db.handlers;
 
+import engine.gameManager.DbManager;
 import engine.objects.PromotionClass;
 import org.pmw.tinylog.Logger;
 
+import java.sql.Connection;
+import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.ArrayList;
@@ -24,31 +27,59 @@ public class dbPromotionClassHandler extends dbHandlerBase {
     }
 
     public ArrayList<Integer> GET_ALLOWED_RUNES(final PromotionClass pc) {
-        ArrayList<Integer> runes = new ArrayList<>();
-        prepareCallable("SELECT * FROM `static_rune_promotionrunereq` WHERE `promoID`=?");
-        setInt(1, pc.getObjectUUID());
-        try {
-            ResultSet rs = executeQuery();
-            while (rs.next()) {
-                runes.add(rs.getInt("runereqID"));
-            }
+
+        ArrayList<Integer> runeList = new ArrayList<>();
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `static_rune_promotionrunereq` WHERE `promoID`=?")) {
+
+            preparedStatement.setInt(1, pc.getObjectUUID());
+
+            ResultSet rs = preparedStatement.executeQuery();
+
+            while (rs.next())
+                runeList.add(rs.getInt("runereqID"));
+
         } catch (SQLException e) {
-            Logger.error("Failed to retrieve Allowed Runes for PromotionClass " + pc.getObjectUUID() + ". Error number: " + e.getErrorCode(), e);
-            return null;
-        } finally {
-            closeCallable();
+            Logger.error(e);
+
         }
-        return runes;
+        return runeList;
     }
 
     public PromotionClass GET_PROMOTION_CLASS(final int objectUUID) {
-        prepareCallable("SELECT * FROM `static_rune_promotion` WHERE `ID` = ?");
-        setInt(1, objectUUID);
-        return (PromotionClass) getObjectSingle(objectUUID);
+
+        PromotionClass promotionClass = null;
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `static_rune_promotion` WHERE `ID` = ?")) {
+
+            preparedStatement.setInt(1, objectUUID);
+
+            ResultSet rs = preparedStatement.executeQuery();
+            promotionClass = (PromotionClass) getObjectFromRs(rs);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+
+        return promotionClass;
     }
-    
+
     public ArrayList<PromotionClass> GET_ALL_PROMOTIONS() {
-		prepareCallable("SELECT * FROM `static_rune_promotion`");
-		return getObjectList();
-	}
+
+        ArrayList<PromotionClass> promotionList = new ArrayList<>();
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `static_rune_promotion`")) {
+
+            ResultSet rs = preparedStatement.executeQuery();
+            promotionList = getObjectsFromRs(rs, 30);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+
+        return promotionList;
+    }
 }

src/engine/db/handlers/dbRaceHandler.java

@@ -9,9 +9,12 @@
 
 package engine.db.handlers;
 
+import engine.gameManager.DbManager;
 import engine.objects.Race;
 import org.pmw.tinylog.Logger;
 
+import java.sql.Connection;
+import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.HashSet;
@@ -23,33 +26,110 @@ public class dbRaceHandler extends dbHandlerBase {
     }
 
     public HashSet<Integer> BEARD_COLORS_FOR_RACE(final int id) {
-        prepareCallable("SELECT `color` FROM `static_rune_racebeardcolor` WHERE `RaceID` = ?");
-        setInt(1, id);
-        return getIntegerList(1);
+
+        HashSet<Integer> integerSet = new HashSet<>();
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT `color` FROM `static_rune_racebeardcolor` WHERE `RaceID` = ?")) {
+
+            preparedStatement.setInt(1, id);
+
+            ResultSet rs = preparedStatement.executeQuery();
+
+            while (rs.next())
+                integerSet.add(rs.getInt(1));
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+
+        return integerSet;
     }
 
     public HashSet<Integer> BEARD_STYLES_FOR_RACE(final int id) {
-        prepareCallable("SELECT `beardStyle` FROM `static_rune_racebeardstyle` WHERE `RaceID` = ?");
-        setInt(1, id);
-        return getIntegerList(1);
+
+        HashSet<Integer> integerSet = new HashSet<>();
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT `beardStyle` FROM `static_rune_racebeardstyle` WHERE `RaceID` = ?")) {
+
+            preparedStatement.setInt(1, id);
+
+            ResultSet rs = preparedStatement.executeQuery();
+
+            while (rs.next())
+                integerSet.add(rs.getInt(1));
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+
+        return integerSet;
     }
 
     public HashSet<Integer> HAIR_COLORS_FOR_RACE(final int id) {
-        prepareCallable("SELECT `color` FROM `static_rune_racehaircolor` WHERE `RaceID` = ?");
-        setInt(1, id);
-        return getIntegerList(1);
+
+        HashSet<Integer> integerSet = new HashSet<>();
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT `color` FROM `static_rune_racehaircolor` WHERE `RaceID` = ?")) {
+
+            preparedStatement.setInt(1, id);
+
+            ResultSet rs = preparedStatement.executeQuery();
+
+            while (rs.next())
+                integerSet.add(rs.getInt(1));
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+
+        return integerSet;
+
     }
 
     public HashSet<Integer> HAIR_STYLES_FOR_RACE(final int id) {
-        prepareCallable("SELECT `hairStyle` FROM `static_rune_racehairstyle` WHERE `RaceID` = ?");
-        setInt(1, id);
-        return getIntegerList(1);
+
+        HashSet<Integer> integerSet = new HashSet<>();
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT `hairStyle` FROM `static_rune_racehairstyle` WHERE `RaceID` = ?")) {
+
+            preparedStatement.setInt(1, id);
+
+            ResultSet rs = preparedStatement.executeQuery();
+
+            while (rs.next())
+                integerSet.add(rs.getInt(1));
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+
+        return integerSet;
+
     }
 
     public HashSet<Integer> SKIN_COLOR_FOR_RACE(final int id) {
-        prepareCallable("SELECT `color` FROM `static_rune_raceskincolor` WHERE `RaceID` = ?");
-        setInt(1, id);
-        return getIntegerList(1);
+
+        HashSet<Integer> integerSet = new HashSet<>();
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT `color` FROM `static_rune_raceskincolor` WHERE `RaceID` = ?")) {
+
+            preparedStatement.setInt(1, id);
+
+            ResultSet rs = preparedStatement.executeQuery();
+
+            while (rs.next())
+                integerSet.add(rs.getInt(1));
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+
+        return integerSet;
     }
 
     public ConcurrentHashMap<Integer, Race> LOAD_ALL_RACES() {
@@ -60,10 +140,10 @@ public class dbRaceHandler extends dbHandlerBase {
         races = new ConcurrentHashMap<>();
         int recordsRead = 0;
 
-        prepareCallable("SELECT * FROM static_rune_race");
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM static_rune_race")) {
 
-        try {
-            ResultSet rs = executeQuery();
+            ResultSet rs = preparedStatement.executeQuery();
 
             while (rs.next()) {
 
@@ -73,13 +153,11 @@ public class dbRaceHandler extends dbHandlerBase {
                 races.put(thisRace.getRaceRuneID(), thisRace);
             }
 
-            Logger.info("read: " + recordsRead + " cached: " + races.size());
-
         } catch (SQLException e) {
-            Logger.error( e.toString());
-        } finally {
-            closeCallable();
+            Logger.error(e);
         }
+
+        Logger.info("read: " + recordsRead + " cached: " + races.size());
         return races;
     }
 }

src/engine/db/handlers/dbRealmHandler.java

@@ -9,14 +9,12 @@
 
 package engine.db.handlers;
 
+import engine.gameManager.DbManager;
 import engine.objects.Realm;
 import org.pmw.tinylog.Logger;
 
-import java.net.UnknownHostException;
-import java.sql.ResultSet;
-import java.sql.SQLException;
+import java.sql.*;
 import java.util.concurrent.ConcurrentHashMap;
-import java.util.logging.Level;
 
 public class dbRealmHandler extends dbHandlerBase {
 
@@ -24,50 +22,51 @@ public class dbRealmHandler extends dbHandlerBase {
 
     }
 
-        public ConcurrentHashMap<Integer, Realm> LOAD_ALL_REALMS() {
-        
-            ConcurrentHashMap<Integer, Realm> realmList;
-            Realm thisRealm;
-                    
-            realmList = new ConcurrentHashMap<>();
-            int recordsRead = 0;
-            
-		prepareCallable("SELECT * FROM obj_realm");
+    public ConcurrentHashMap<Integer, Realm> LOAD_ALL_REALMS() {
+
+        ConcurrentHashMap<Integer, Realm> realmList;
+        Realm thisRealm;
+
+        realmList = new ConcurrentHashMap<>();
+        int recordsRead = 0;
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM obj_realm")) {
+
+            ResultSet rs = preparedStatement.executeQuery();
+
+            while (rs.next()) {
+                recordsRead++;
+                thisRealm = new Realm(rs);
+                realmList.put(thisRealm.getRealmID(), thisRealm);
+            }
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+
+        Logger.info("read: " + recordsRead + " cached: " + realmList.size());
+        return realmList;
+    }
 
-		try {
-			ResultSet rs = executeQuery();
-                        
-			while (rs.next()) {
-                            
-                          recordsRead++;
-                          thisRealm = new Realm(rs);
-                          realmList.put(thisRealm.getRealmID(), thisRealm);
-			}
-                        
-                        Logger.info( "read: " + recordsRead + " cached: " + realmList.size());
-                                
-		} catch (SQLException e) {
-			Logger.error(e.getErrorCode() + ' ' + e.getMessage(), e);
-		} catch (UnknownHostException ex) {
-            java.util.logging.Logger.getLogger(dbRealmHandler.class.getName()).log(Level.SEVERE, null, ex);
-        } finally {
-			closeCallable();
-		}
-		return realmList;
-	}
-        
     public void REALM_UPDATE(Realm realm) {
 
-            prepareCallable("CALL realm_UPDATE(?,?,?,?)");
-            
-            setInt(1, realm.getRealmID());
-            setInt(2, (realm.getRulingCity() == null) ? 0 : realm.getRulingCity().getObjectUUID());
-            setInt(3, realm.getCharterType());
-        if (realm.ruledSince != null)
-            setLocalDateTime(4, realm.ruledSince);
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("CALL realm_UPDATE(?,?,?,?)")) {
+
+            preparedStatement.setInt(1, realm.getRealmID());
+            preparedStatement.setInt(2, (realm.getRulingCity() == null) ? 0 : realm.getRulingCity().getObjectUUID());
+            preparedStatement.setInt(3, realm.getCharterType());
+
+            if (realm.ruledSince != null)
+                preparedStatement.setTimestamp(4, Timestamp.valueOf(realm.ruledSince));
             else
-                setNULL(4, java.sql.Types.DATE);
-            
-            executeUpdate();
+                preparedStatement.setNull(4, java.sql.Types.DATE);
+
+            preparedStatement.execute();
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
     }
 }

src/engine/db/handlers/dbResistHandler.java

@@ -9,8 +9,12 @@
 
 package engine.db.handlers;
 
+import engine.gameManager.DbManager;
 import engine.objects.Resists;
+import org.pmw.tinylog.Logger;
 
+import java.sql.Connection;
+import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 
@@ -21,17 +25,23 @@ public class dbResistHandler extends dbHandlerBase {
     }
 
     public Resists GET_RESISTS_FOR_MOB(int resistID) {
-        prepareCallable("SELECT * FROM `static_npc_mob_resists` WHERE `ID` = ?;");
-        setInt(1, resistID);
-        try {
-            ResultSet rs = executeQuery();
-            if (rs.next()) {
-                return new Resists(rs);
-            }
+
+        Resists resists = null;
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `static_npc_mob_resists` WHERE `ID` = ?;")) {
+
+            preparedStatement.setInt(1, resistID);
+
+            ResultSet rs = preparedStatement.executeQuery();
+
+            if (rs.next())
+                resists = new Resists(rs);
+
         } catch (SQLException e) {
-        } finally {
-            closeCallable();
+            Logger.error(e);
         }
-        return null;
+
+        return resists;
     }
 }

src/engine/db/handlers/dbRuneBaseAttributeHandler.java

@@ -9,27 +9,39 @@
 
 package engine.db.handlers;
 
+import engine.gameManager.DbManager;
 import engine.objects.RuneBaseAttribute;
+import org.pmw.tinylog.Logger;
 
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
 import java.util.ArrayList;
 
 public class dbRuneBaseAttributeHandler extends dbHandlerBase {
 
-	public dbRuneBaseAttributeHandler() {
-		this.localClass = RuneBaseAttribute.class;
-		this.localObjectType = engine.Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
-	}
+    public dbRuneBaseAttributeHandler() {
+        this.localClass = RuneBaseAttribute.class;
+        this.localObjectType = engine.Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
+    }
 
-	public ArrayList<RuneBaseAttribute> GET_ATTRIBUTES_FOR_RUNEBASE(int id) {
-		prepareCallable("SELECT * FROM `static_rune_runebaseattribute` WHERE `RuneBaseID`=?");
-		setInt(1, id);
-		return getObjectList();
-	}
+    public ArrayList<RuneBaseAttribute> GET_ATTRIBUTES_FOR_RUNEBASE() {
 
-	public ArrayList<RuneBaseAttribute> GET_ATTRIBUTES_FOR_RUNEBASE() {
-		prepareCallable("SELECT * FROM `static_rune_runebaseattribute`");
-		return getObjectList();
-	}
+        ArrayList<RuneBaseAttribute> runeBaseAttributesList = new ArrayList<>();
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `static_rune_runebaseattribute`")) {
+
+            ResultSet rs = preparedStatement.executeQuery();
+            runeBaseAttributesList = getObjectsFromRs(rs, 10);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+
+        return runeBaseAttributesList;
+    }
 
 
 }

src/engine/db/handlers/dbRuneBaseEffectHandler.java

@@ -13,61 +13,79 @@ import engine.Enum.GameObjectType;
 import engine.gameManager.DbManager;
 import engine.objects.AbstractGameObject;
 import engine.objects.RuneBaseEffect;
+import org.pmw.tinylog.Logger;
 
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
 import java.util.ArrayList;
 import java.util.HashMap;
 
 public class dbRuneBaseEffectHandler extends dbHandlerBase {
 
-	public dbRuneBaseEffectHandler() {
-		this.localClass = RuneBaseEffect.class;
-		this.localObjectType = engine.Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
-	}
+    public dbRuneBaseEffectHandler() {
+        this.localClass = RuneBaseEffect.class;
+        this.localObjectType = engine.Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
+    }
 
-	public ArrayList<RuneBaseEffect> GET_EFFECTS_FOR_RUNEBASE(int id) {
-		prepareCallable("SELECT * FROM `static_rune_baseeffect` WHERE `runeID`=?");
-		setInt(1, id);
-		return getObjectList();
-	}
+    public ArrayList<RuneBaseEffect> GET_EFFECTS_FOR_RUNEBASE(int id) {
 
-	public RuneBaseEffect GET_RUNEBASE_EFFECT(int id) {
+        ArrayList<RuneBaseEffect> runeBaseEffectsList = new ArrayList<>();
 
-		if (id == 0)
-			return null;
-		RuneBaseEffect runeBaseEffect = (RuneBaseEffect) DbManager.getFromCache(GameObjectType.RuneBaseEffect, id);
-		if (runeBaseEffect != null)
-			return runeBaseEffect;
-		prepareCallable("SELECT * FROM `static_rune_baseeffect` WHERE `ID` = ?");
-		setInt(1, id);
-		return (RuneBaseEffect) getObjectSingle(id);
-	}
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `static_rune_baseeffect` WHERE `runeID`=?")) {
 
-	public ArrayList<RuneBaseEffect> GET_ALL_RUNEBASE_EFFECTS(){
-		prepareCallable("SELECT * FROM `static_rune_baseeffect`;");
-		return  getObjectList();
-	}
+            preparedStatement.setInt(1, id);
 
-	//This calls from cache only. Call this AFTER caching all runebase effects;
-	public HashMap<Integer, ArrayList<RuneBaseEffect>> LOAD_BASEEFFECTS_FOR_RUNEBASE() {
-		HashMap<Integer, ArrayList<RuneBaseEffect>> runeBaseEffectSet;
-		runeBaseEffectSet = new HashMap<>();
+            ResultSet rs = preparedStatement.executeQuery();
+            runeBaseEffectsList = getObjectsFromRs(rs, 250);
 
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
 
-		for (AbstractGameObject runeBaseEffect:DbManager.getList(GameObjectType.RuneBaseEffect)){
+        return runeBaseEffectsList;
+    }
 
-			int runeBaseID = ((RuneBaseEffect)runeBaseEffect).getRuneBaseID();
-			if (runeBaseEffectSet.get(runeBaseID) == null){
-				ArrayList<RuneBaseEffect> runeBaseEffectList = new ArrayList<>();
-				runeBaseEffectList.add((RuneBaseEffect)runeBaseEffect);
-				runeBaseEffectSet.put(runeBaseID, runeBaseEffectList);
-			}
-			else{
-				ArrayList<RuneBaseEffect>runeBaseEffectList = runeBaseEffectSet.get(runeBaseID);
-				runeBaseEffectList.add((RuneBaseEffect)runeBaseEffect);
-				runeBaseEffectSet.put(runeBaseID, runeBaseEffectList);
-			}
-		}
-		return runeBaseEffectSet;
-	}
+    public ArrayList<RuneBaseEffect> GET_ALL_RUNEBASE_EFFECTS() {
+
+        ArrayList<RuneBaseEffect> runeBaseEffectsList = new ArrayList<>();
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `static_rune_baseeffect`;")) {
+
+            ResultSet rs = preparedStatement.executeQuery();
+            runeBaseEffectsList = getObjectsFromRs(rs, 250);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+
+        return runeBaseEffectsList;
+    }
+
+    //This calls from cache only. Call this AFTER caching all runebase effects;
+
+    public HashMap<Integer, ArrayList<RuneBaseEffect>> LOAD_BASEEFFECTS_FOR_RUNEBASE() {
+
+        HashMap<Integer, ArrayList<RuneBaseEffect>> runeBaseEffectSet;
+        runeBaseEffectSet = new HashMap<>();
+
+        for (AbstractGameObject runeBaseEffect : DbManager.getList(GameObjectType.RuneBaseEffect)) {
+
+            int runeBaseID = ((RuneBaseEffect) runeBaseEffect).getRuneBaseID();
+            if (runeBaseEffectSet.get(runeBaseID) == null) {
+                ArrayList<RuneBaseEffect> runeBaseEffectList = new ArrayList<>();
+                runeBaseEffectList.add((RuneBaseEffect) runeBaseEffect);
+                runeBaseEffectSet.put(runeBaseID, runeBaseEffectList);
+            } else {
+                ArrayList<RuneBaseEffect> runeBaseEffectList = runeBaseEffectSet.get(runeBaseID);
+                runeBaseEffectList.add((RuneBaseEffect) runeBaseEffect);
+                runeBaseEffectSet.put(runeBaseID, runeBaseEffectList);
+            }
+        }
+        return runeBaseEffectSet;
+    }
 
 }

src/engine/db/handlers/dbRuneBaseHandler.java

@@ -9,165 +9,171 @@
 
 package engine.db.handlers;
 
+import engine.gameManager.DbManager;
 import engine.objects.RuneBase;
 import org.pmw.tinylog.Logger;
 
+import java.sql.Connection;
+import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.ArrayList;
 import java.util.HashMap;
-import java.util.HashSet;
 
 public class dbRuneBaseHandler extends dbHandlerBase {
 
-	public dbRuneBaseHandler() {
-		this.localClass = RuneBase.class;
-		this.localObjectType = engine.Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
-	}
+    public dbRuneBaseHandler() {
+        this.localClass = RuneBase.class;
+        this.localObjectType = engine.Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
+    }
 
-	public void GET_RUNE_REQS(final RuneBase rb) {
-		prepareCallable("SELECT * FROM `static_rune_runereq` WHERE `runeID` = ?");
-		setInt(1, rb.getObjectUUID());
-		try {
+    public void GET_RUNE_REQS(final RuneBase rb) {
 
-			ResultSet rs = executeQuery();
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `static_rune_runereq` WHERE `runeID` = ?")) {
 
-			while (rs.next()) {
-				int type = rs.getInt("type");
+            preparedStatement.setInt(1, rb.getObjectUUID());
 
-				switch (type) {
-				case 1:
-					rb.getRace().put(rs.getInt("requiredRuneID"), rs.getBoolean("isAllowed"));
-					break;
-				case 2:
-					rb.getBaseClass().put(rs.getInt("requiredRuneID"), rs.getBoolean("isAllowed"));
-					break;
-				case 3:
-					rb.getPromotionClass().put(rs.getInt("requiredRuneID"), rs.getBoolean("isAllowed"));
-					break;
-				case 4:
-					rb.getDiscipline().put(rs.getInt("requiredRuneID"), rs.getBoolean("isAllowed"));
-					break;
-				case 5:
-					rb.getOverwrite().add(rs.getInt("requiredRuneID"));
-					break;
-				case 6:
-					rb.setLevelRequired(rs.getInt("requiredRuneID"));
-					break;
-				}
-			}
-			rs.close();
-		} catch (SQLException e) {
-			Logger.error("SQL Error number: " + e.getErrorCode());
-		} finally {
-			closeCallable();
-		}
-	}
+            ResultSet rs = preparedStatement.executeQuery();
 
-	public RuneBase GET_RUNEBASE(final int id) {
-		prepareCallable("SELECT * FROM `static_rune_runebase` WHERE `ID` = ?");
-		setInt(1, id);
-		return (RuneBase) getObjectSingle(id);
-	}
+            while (rs.next()) {
+                int type = rs.getInt("type");
 
-	public ArrayList<RuneBase> LOAD_ALL_RUNEBASES() {
-		prepareCallable("SELECT * FROM `static_rune_runebase`;");
-		return  getObjectList();
-	}
+                switch (type) {
+                    case 1:
+                        rb.getRace().put(rs.getInt("requiredRuneID"), rs.getBoolean("isAllowed"));
+                        break;
+                    case 2:
+                        rb.getBaseClass().put(rs.getInt("requiredRuneID"), rs.getBoolean("isAllowed"));
+                        break;
+                    case 3:
+                        rb.getPromotionClass().put(rs.getInt("requiredRuneID"), rs.getBoolean("isAllowed"));
+                        break;
+                    case 4:
+                        rb.getDiscipline().put(rs.getInt("requiredRuneID"), rs.getBoolean("isAllowed"));
+                        break;
+                    case 5:
+                        rb.getOverwrite().add(rs.getInt("requiredRuneID"));
+                        break;
+                    case 6:
+                        rb.setLevelRequired(rs.getInt("requiredRuneID"));
+                        break;
+                }
+            }
 
-	public HashMap<Integer, ArrayList<Integer>> LOAD_ALLOWED_STARTING_RUNES_FOR_BASECLASS() {
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
 
-		HashMap<Integer, ArrayList<Integer>> runeSets;
+    }
 
-		runeSets = new HashMap<>();
-		int recordsRead = 0;
+    public RuneBase GET_RUNEBASE(final int id) {
 
-		prepareCallable("SELECT * FROM static_rune_baseclassrune");
+        RuneBase runeBase = null;
 
-		try {
-			ResultSet rs = executeQuery();
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `static_rune_runebase` WHERE `ID` = ?")) {
 
-			while (rs.next()) {
+            preparedStatement.setInt(1, id);
 
-				recordsRead++;
+            ResultSet rs = preparedStatement.executeQuery();
+            runeBase = (RuneBase) getObjectFromRs(rs);
 
-				int baseClassID = rs.getInt("BaseClassesID");
-				int runeBaseID = rs.getInt("RuneBaseID");
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return runeBase;
+    }
 
-				if (runeSets.get(baseClassID) == null){
-					ArrayList<Integer> runeList = new ArrayList<>();
-					runeList.add(runeBaseID);
-					runeSets.put(baseClassID, runeList);
-				}
-				else{
-					ArrayList<Integer>runeList = runeSets.get(baseClassID);
-					runeList.add(runeBaseID);
-					runeSets.put(baseClassID, runeList);
-				}
-			}
+    public ArrayList<RuneBase> LOAD_ALL_RUNEBASES() {
 
-			Logger.info("read: " + recordsRead + " cached: " + runeSets.size());
+        ArrayList<RuneBase> runeBasesList = new ArrayList<>();
 
-		} catch (SQLException e) {
-			Logger.error(e.getErrorCode() + ' ' + e.getMessage(), e);
-		} finally {
-			closeCallable();
-		}
-		return runeSets;
-	}
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `static_rune_runebase`;")) {
 
-	public HashMap<Integer, ArrayList<Integer>> LOAD_ALLOWED_STARTING_RUNES_FOR_RACE() {
+            ResultSet rs = preparedStatement.executeQuery();
+            runeBasesList = getObjectsFromRs(rs, 1000);
 
-		HashMap<Integer, ArrayList<Integer>> runeSets;
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
 
-		runeSets = new HashMap<>();
-		int recordsRead = 0;
+        return runeBasesList;
+    }
 
-		prepareCallable("SELECT * FROM static_rune_racerune");
+    public HashMap<Integer, ArrayList<Integer>> LOAD_ALLOWED_STARTING_RUNES_FOR_BASECLASS() {
 
-		try {
-			ResultSet rs = executeQuery();
+        HashMap<Integer, ArrayList<Integer>> runeSets = new HashMap<>();
 
-			while (rs.next()) {
+        int recordsRead = 0;
 
-				recordsRead++;
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM static_rune_baseclassrune")) {
 
-				int raceID = rs.getInt("RaceID");
-				int runeBaseID = rs.getInt("RuneBaseID");
+            ResultSet rs = preparedStatement.executeQuery();
 
-				if (runeSets.get(raceID) == null){
-					ArrayList<Integer> runeList = new ArrayList<>();
-					runeList.add(runeBaseID);
-					runeSets.put(raceID, runeList);
-				}
-				else{
-					ArrayList<Integer>runeList = runeSets.get(raceID);
-					runeList.add(runeBaseID);
-					runeSets.put(raceID, runeList);
-				}
-			}
+            while (rs.next()) {
 
-			Logger.info( "read: " + recordsRead + " cached: " + runeSets.size());
+                recordsRead++;
 
-		} catch (SQLException e) {
-			Logger.error(e.getErrorCode() + ' ' + e.getMessage(), e);
-		} finally {
-			closeCallable();
-		}
-		return runeSets;
-	}
+                int baseClassID = rs.getInt("BaseClassesID");
+                int runeBaseID = rs.getInt("RuneBaseID");
 
-	public ArrayList<RuneBase> GET_RUNEBASE_FOR_BASECLASS(final int id) {
-		prepareCallable("SELECT rb.* FROM static_rune_baseclassrune bcr, static_rune_runebase rb WHERE bcr.RuneBaseID = rb.ID "
-				+ "&& ( bcr.BaseClassesID = 111111 || bcr.BaseClassesID = ? )");
-		setInt(1, id);
-		return getObjectList();
-	}
+                if (runeSets.get(baseClassID) == null) {
+                    ArrayList<Integer> runeList = new ArrayList<>();
+                    runeList.add(runeBaseID);
+                    runeSets.put(baseClassID, runeList);
+                } else {
+                    ArrayList<Integer> runeList = runeSets.get(baseClassID);
+                    runeList.add(runeBaseID);
+                    runeSets.put(baseClassID, runeList);
+                }
+            }
 
-	public HashSet<RuneBase> GET_RUNEBASE_FOR_RACE(final int id) {
-		prepareCallable("SELECT rb.* FROM static_rune_racerune rr, static_rune_runebase rb"
-				+ " WHERE rr.RuneBaseID = rb.ID && ( rr.RaceID = 111111 || rr.RaceID = ?)");
-		setInt(1, id);
-		return new HashSet<>(getObjectList());
-	}
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+
+        Logger.info("read: " + recordsRead + " cached: " + runeSets.size());
+
+        return runeSets;
+    }
+
+    public HashMap<Integer, ArrayList<Integer>> LOAD_ALLOWED_STARTING_RUNES_FOR_RACE() {
+
+        HashMap<Integer, ArrayList<Integer>> runeSets;
+
+        runeSets = new HashMap<>();
+        int recordsRead = 0;
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM static_rune_racerune")) {
+
+            ResultSet rs = preparedStatement.executeQuery();
+
+            while (rs.next()) {
+
+                recordsRead++;
+
+                int raceID = rs.getInt("RaceID");
+                int runeBaseID = rs.getInt("RuneBaseID");
+
+                if (runeSets.get(raceID) == null) {
+                    ArrayList<Integer> runeList = new ArrayList<>();
+                    runeList.add(runeBaseID);
+                    runeSets.put(raceID, runeList);
+                } else {
+                    ArrayList<Integer> runeList = runeSets.get(raceID);
+                    runeList.add(runeBaseID);
+                    runeSets.put(raceID, runeList);
+                }
+            }
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+
+        Logger.info("read: " + recordsRead + " cached: " + runeSets.size());
+        return runeSets;
+    }
 }

src/engine/db/handlers/dbRunegateHandler.java

@@ -13,7 +13,10 @@ import engine.Enum;
 import engine.gameManager.DbManager;
 import engine.objects.Building;
 import engine.objects.Portal;
+import org.pmw.tinylog.Logger;
 
+import java.sql.Connection;
+import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.ArrayList;
@@ -28,17 +31,18 @@ public class dbRunegateHandler extends dbHandlerBase {
 
         ArrayList<Integer> gateList = new ArrayList<>();
 
-        prepareCallable("SELECT DISTINCT `sourceBuilding` FROM `static_runegate_portals`;");
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT DISTINCT `sourceBuilding` FROM `static_runegate_portals`;")) {
 
-        try {
-            ResultSet rs = executeQuery();
-            while (rs.next()) {
+            ResultSet rs = preparedStatement.executeQuery();
+
+            while (rs.next())
                 gateList.add(rs.getInt("sourceBuilding"));
-            }
+
         } catch (SQLException e) {
-        } finally {
-            closeCallable();
+            Logger.error(e);
         }
+
         return gateList;
     }
 
@@ -47,11 +51,12 @@ public class dbRunegateHandler extends dbHandlerBase {
         ArrayList<Portal> portalList = new ArrayList<>();
         Building sourceBuilding = (Building) DbManager.getObject(Enum.GameObjectType.Building, gateUID);
 
-        prepareCallable("SELECT * FROM `static_runegate_portals` WHERE `sourceBuilding` = ?;");
-        setInt(1, gateUID);
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `static_runegate_portals` WHERE `sourceBuilding` = ?;")) {
 
-        try {
-            ResultSet rs = executeQuery();
+            preparedStatement.setInt(1, gateUID);
+
+            ResultSet rs = preparedStatement.executeQuery();
 
             while (rs.next()) {
                 int targetBuildingID = rs.getInt("targetBuilding");
@@ -62,8 +67,7 @@ public class dbRunegateHandler extends dbHandlerBase {
             }
 
         } catch (SQLException e) {
-        } finally {
-            closeCallable();
+            Logger.error(e);
         }
         return portalList;
     }

src/engine/db/handlers/dbShrineHandler.java

@@ -18,7 +18,8 @@ import engine.objects.Shrine;
 import org.joda.time.DateTime;
 import org.pmw.tinylog.Logger;
 
-import java.net.UnknownHostException;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.ArrayList;
@@ -30,83 +31,10 @@ public class dbShrineHandler extends dbHandlerBase {
         this.localObjectType = engine.Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
     }
 
-    public ArrayList<AbstractGameObject> CREATE_SHRINE( int parentZoneID, int OwnerUUID, String name, int meshUUID,
-            Vector3fImmutable location, float meshScale, int currentHP,
-            ProtectionState protectionState, int currentGold, int rank,
-            DateTime upgradeDate, int blueprintUUID, float w, float rotY, String shrineType) {
+    public static void addObject(ArrayList<AbstractGameObject> list, ResultSet rs) throws SQLException {
 
-        prepareCallable("CALL `shrine_CREATE`(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ? ,? ,? ,?, ?,?);");
-
-      
-        setInt(1, parentZoneID);
-        setInt(2, OwnerUUID);
-        setString(3, name);
-        setInt(4, meshUUID);
-        setFloat(5, location.x);
-        setFloat(6, location.y);
-        setFloat(7, location.z);
-        setFloat(8, meshScale);
-        setInt(9, currentHP);
-        setString(10, protectionState.name());
-        setInt(11, currentGold);
-        setInt(12, rank);
-
-        if (upgradeDate != null) {
-            setTimeStamp(13, upgradeDate.getMillis());
-        } else {
-            setNULL(13, java.sql.Types.DATE);
-        }
-
-        setInt(14, blueprintUUID);
-        setFloat(15, w);
-        setFloat(16, rotY);
-        setString(17, shrineType);
-
-        ArrayList<AbstractGameObject> list = new ArrayList<>();
-        //System.out.println(this.cs.get().toString());
-        try {
-            boolean work = execute();
-            if (work) {
-                ResultSet rs = this.cs.get().getResultSet();
-                while (rs.next()) {
-                    addObject(list, rs);
-                }
-                rs.close();
-            } else {
-                Logger.info("Shrine Creation Failed: " + this.cs.get().toString());
-                return list; //city creation failure
-            }
-            while (this.cs.get().getMoreResults()) {
-                ResultSet rs = this.cs.get().getResultSet();
-                while (rs.next()) {
-                    addObject(list, rs);
-                }
-                rs.close();
-            }
-        } catch (SQLException e) {
-            Logger.info("Shrine Creation Failed, SQLException: " + this.cs.get().toString() + e.toString());
-            return list; //city creation failure
-        } catch (UnknownHostException e) {
-            Logger.info("Shrine Creation Failed, UnknownHostException: " + this.cs.get().toString());
-            return list; //city creation failure
-        } finally {
-            closeCallable();
-        }
-        return list;
-
-    }
-
-    public boolean updateFavors(Shrine shrine, int amount, int oldAmount) {
-
-        prepareCallable("UPDATE `obj_shrine` SET `shrine_favors`=? WHERE `UID` = ? AND `shrine_favors` = ?");
-        setInt(1, amount);
-        setLong(2, (long) shrine.getObjectUUID());
-        setInt(3, oldAmount);
-        return (executeUpdate() != 0);
-    }
-
-    public static void addObject(ArrayList<AbstractGameObject> list, ResultSet rs) throws SQLException, UnknownHostException {
         String type = rs.getString("type");
+
         switch (type) {
             case "building":
                 Building building = new Building(rs);
@@ -121,27 +49,95 @@ public class dbShrineHandler extends dbHandlerBase {
         }
     }
 
-    public void LOAD_ALL_SHRINES() {
+    public ArrayList<AbstractGameObject> CREATE_SHRINE(int parentZoneID, int OwnerUUID, String name, int meshUUID,
+                                                       Vector3fImmutable location, float meshScale, int currentHP,
+                                                       ProtectionState protectionState, int currentGold, int rank,
+                                                       DateTime upgradeDate, int blueprintUUID, float w, float rotY, String shrineType) {
 
-        Shrine thisShrine;
+        ArrayList<AbstractGameObject> shrineList = new ArrayList<>();
 
-        prepareCallable("SELECT `obj_shrine`.*, `object`.`parent`, `object`.`type` FROM `object` LEFT JOIN `obj_shrine` ON `object`.`UID` = `obj_shrine`.`UID` WHERE `object`.`type` = 'shrine';");
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("CALL `shrine_CREATE`(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ? ,? ,? ,?, ?,?);")) {
 
-        try {
-            ResultSet rs = executeQuery();
+            preparedStatement.setInt(1, parentZoneID);
+            preparedStatement.setInt(2, OwnerUUID);
+            preparedStatement.setString(3, name);
+            preparedStatement.setInt(4, meshUUID);
+            preparedStatement.setFloat(5, location.x);
+            preparedStatement.setFloat(6, location.y);
+            preparedStatement.setFloat(7, location.z);
+            preparedStatement.setFloat(8, meshScale);
+            preparedStatement.setInt(9, currentHP);
+            preparedStatement.setString(10, protectionState.name());
+            preparedStatement.setInt(11, currentGold);
+            preparedStatement.setInt(12, rank);
 
-            //shrines cached in rs for easy cache on creation.
-            while (rs.next()) {
-                thisShrine = new Shrine(rs);
-                thisShrine.getShrineType().addShrineToServerList(thisShrine);
+            if (upgradeDate != null)
+                preparedStatement.setTimestamp(13, new java.sql.Timestamp(upgradeDate.getMillis()));
+            else
+                preparedStatement.setNull(13, java.sql.Types.DATE);
+
+            preparedStatement.setInt(14, blueprintUUID);
+            preparedStatement.setFloat(15, w);
+            preparedStatement.setFloat(16, rotY);
+            preparedStatement.setString(17, shrineType);
+
+            preparedStatement.execute();
+
+            ResultSet rs = preparedStatement.getResultSet();
+
+            while (rs.next())
+                addObject(shrineList, rs);
+
+            while (preparedStatement.getMoreResults()) {
+                rs = preparedStatement.getResultSet();
+
+                while (rs.next())
+                    addObject(shrineList, rs);
             }
 
         } catch (SQLException e) {
-            Logger.error( e.getErrorCode() + ' ' + e.getMessage(), e);
-        } finally {
-            closeCallable();
+            Logger.error(e);
+        }
+
+        return shrineList;
+    }
+
+    public boolean updateFavors(Shrine shrine, int amount, int oldAmount) {
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_shrine` SET `shrine_favors`=? WHERE `UID` = ? AND `shrine_favors` = ?")) {
+
+            preparedStatement.setInt(1, amount);
+            preparedStatement.setLong(2, shrine.getObjectUUID());
+            preparedStatement.setInt(3, oldAmount);
+
+            return (preparedStatement.executeUpdate() > 0);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+            return false;
         }
 
     }
 
+    public void LOAD_ALL_SHRINES() {
+
+        Shrine shrine;
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT `obj_shrine`.*, `object`.`parent`, `object`.`type` FROM `object` LEFT JOIN `obj_shrine` ON `object`.`UID` = `obj_shrine`.`UID` WHERE `object`.`type` = 'shrine';")) {
+
+            ResultSet rs = preparedStatement.executeQuery();
+
+            while (rs.next()) {
+                shrine = new Shrine(rs);
+                shrine.getShrineType().addShrineToServerList(shrine);
+            }
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+    }
+
 }

src/engine/db/handlers/dbSkillBaseHandler.java

@@ -12,11 +12,12 @@ package engine.db.handlers;
 import engine.Enum;
 import engine.Enum.GameObjectType;
 import engine.gameManager.DbManager;
-import engine.objects.AbstractGameObject;
 import engine.objects.MaxSkills;
 import engine.objects.SkillsBase;
 import org.pmw.tinylog.Logger;
 
+import java.sql.Connection;
+import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.ArrayList;
@@ -24,120 +25,128 @@ import java.util.HashMap;
 
 public class dbSkillBaseHandler extends dbHandlerBase {
 
-	public dbSkillBaseHandler() {
-		this.localClass = SkillsBase.class;
-		this.localObjectType = Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
-	}
+    public dbSkillBaseHandler() {
+        this.localClass = SkillsBase.class;
+        this.localObjectType = Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
+    }
 
-	public SkillsBase GET_BASE(final int objectUUID) {
+    public SkillsBase GET_BASE(final int objectUUID) {
 
-		SkillsBase skillsBase = (SkillsBase) DbManager.getFromCache(GameObjectType.SkillsBase, objectUUID);
-		if (skillsBase != null)
-			return skillsBase;
-		prepareCallable("SELECT * FROM static_skill_skillsbase WHERE ID = ?");
-		setInt(1, objectUUID);
-		SkillsBase sb;
-		sb = (SkillsBase) getObjectSingle(objectUUID);
-		SkillsBase.putInCache(sb);
-		return sb;
-	}
+        SkillsBase skillsBase = (SkillsBase) DbManager.getFromCache(GameObjectType.SkillsBase, objectUUID);
 
-	public SkillsBase GET_BASE_BY_NAME(String name) {
-		SkillsBase sb = SkillsBase.getFromCache(name);
-		if (sb != null) {
-			return sb;
-		}
-		prepareCallable("SELECT * FROM static_skill_skillsbase WHERE name = ?");
-		setString(1, name);
-		ArrayList<AbstractGameObject> result = getObjectList();
-		if (result.size() > 0) {
-			sb = (SkillsBase) result.get(0);
-			SkillsBase.putInCache(sb);
-			return sb;
-		} else {
-			return null;
-		}
-	}
+        if (skillsBase != null)
+            return skillsBase;
 
-	public SkillsBase GET_BASE_BY_TOKEN(final int token) {
-		SkillsBase sb = SkillsBase.getFromCache(token);
-		if (sb != null) {
-			return sb;
-		}
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM static_skill_skillsbase WHERE ID = ?")) {
 
-		prepareCallable("SELECT * FROM static_skill_skillsbase WHERE token = ?");
-		setInt(1, token);
-		ArrayList<AbstractGameObject> result = getObjectList();
-		if (result.size() > 0) {
-			sb = (SkillsBase) result.get(0);
-			SkillsBase.putInCache(sb);
-			return sb;
-		} else {
-			return null;
-		}
-	}
+            preparedStatement.setInt(1, objectUUID);
+            ResultSet rs = preparedStatement.executeQuery();
 
-	public void LOAD_ALL_MAX_SKILLS_FOR_CONTRACT() {
+            skillsBase = (SkillsBase) getObjectFromRs(rs);
 
-		prepareCallable("SELECT * FROM `static_rune_maxskills`");
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+
+        SkillsBase.putInCache(skillsBase);
+        return skillsBase;
+    }
+
+    public SkillsBase GET_BASE_BY_NAME(String name) {
+
+        SkillsBase skillsBase = SkillsBase.getFromCache(name);
+
+        if (skillsBase != null)
+            return skillsBase;
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM static_skill_skillsbase WHERE name = ?")) {
+
+            preparedStatement.setString(1, name);
+            ResultSet rs = preparedStatement.executeQuery();
+
+            skillsBase = (SkillsBase) getObjectFromRs(rs);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+
+        SkillsBase.putInCache(skillsBase);
+        return skillsBase;
+    }
+
+    public SkillsBase GET_BASE_BY_TOKEN(final int token) {
+
+        SkillsBase skillsBase = SkillsBase.getFromCache(token);
+
+        if (skillsBase != null)
+            return skillsBase;
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM static_skill_skillsbase WHERE token = ?")) {
+
+            preparedStatement.setInt(1, token);
+            ResultSet rs = preparedStatement.executeQuery();
+
+            skillsBase = (SkillsBase) getObjectFromRs(rs);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+
+        SkillsBase.putInCache(skillsBase);
+        return skillsBase;
+    }
+
+    public void LOAD_ALL_MAX_SKILLS_FOR_CONTRACT() {
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `static_rune_maxskills`")) {
+
+            ResultSet rs = preparedStatement.executeQuery();
+
+            while (rs.next()) {
+
+                MaxSkills maxSKills = new MaxSkills(rs);
+
+                if (MaxSkills.MaxSkillsSet.get(maxSKills.getRuneID()) == null) {
+                    ArrayList<MaxSkills> newMaxSkillsList = new ArrayList<>();
+                    newMaxSkillsList.add(maxSKills);
+                    MaxSkills.MaxSkillsSet.put(maxSKills.getRuneID(), newMaxSkillsList);
+                } else
+                    MaxSkills.MaxSkillsSet.get(maxSKills.getRuneID()).add(maxSKills);
+
+            }
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+    }
 
 
-		try {
-			ResultSet rs = executeQuery();
+    public void LOAD_ALL_RUNE_SKILLS() {
 
-			//shrines cached in rs for easy cache on creation.
-			while (rs.next()) {
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `static_skill_skillsgranted`")) {
 
-				MaxSkills maxSKills = new MaxSkills(rs);
-				if (MaxSkills.MaxSkillsSet.get(maxSKills.getRuneID()) == null){
-					ArrayList<MaxSkills> newMaxSkillsList = new ArrayList<>();
-					newMaxSkillsList.add(maxSKills);
-					MaxSkills.MaxSkillsSet.put(maxSKills.getRuneID(), newMaxSkillsList);
-				}else
-					MaxSkills.MaxSkillsSet.get(maxSKills.getRuneID()).add(maxSKills);
+            ResultSet rs = preparedStatement.executeQuery();
 
-			}
+            while (rs.next()) {
 
+                int runeID = rs.getInt("runeID");
+                int token = rs.getInt("token");
+                int amount = rs.getInt("amount");
 
+                if (SkillsBase.runeSkillsCache.get(runeID) == null)
+                    SkillsBase.runeSkillsCache.put(runeID, new HashMap<>());
 
-		} catch (SQLException e) {
-			Logger.error( e.getErrorCode() + ' ' + e.getMessage(), e);
-		} finally {
-			closeCallable();
-		}
-
-	}
-	
-	public void LOAD_ALL_RUNE_SKILLS() {
-
-		prepareCallable("SELECT * FROM `static_skill_skillsgranted`");
-
-
-		try {
-			ResultSet rs = executeQuery();
-
-			//shrines cached in rs for easy cache on creation.
-			while (rs.next()) {
-
-				int runeID = rs.getInt("runeID");
-				int token = rs.getInt("token");
-				int amount = rs.getInt("amount");
-				
-				if (SkillsBase.runeSkillsCache.get(runeID) == null)
-					SkillsBase.runeSkillsCache.put(runeID, new HashMap<>());
-				
-				SkillsBase.runeSkillsCache.get(runeID).put(token, amount);
-			}
-
-
-
-		} catch (SQLException e) {
-			Logger.error( e.getErrorCode() + ' ' + e.getMessage(), e);
-		} finally {
-			closeCallable();
-		}
-
-	}
+                SkillsBase.runeSkillsCache.get(runeID).put(token, amount);
+            }
 
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+    }
 
 }

src/engine/db/handlers/dbSkillReqHandler.java

@@ -9,9 +9,17 @@
 
 package engine.db.handlers;
 
+import engine.gameManager.DbManager;
 import engine.objects.SkillReq;
+import engine.powers.PowersBase;
+import org.pmw.tinylog.Logger;
 
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
 import java.util.ArrayList;
+import java.util.HashMap;
 
 public class dbSkillReqHandler extends dbHandlerBase {
 
@@ -20,16 +28,71 @@ public class dbSkillReqHandler extends dbHandlerBase {
         this.localObjectType = engine.Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
     }
 
+    public static ArrayList<PowersBase> getAllPowersBase() {
+
+        ArrayList<PowersBase> powerBaseList = new ArrayList<>();
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM static_power_powerbase")) {
+
+            ResultSet rs = preparedStatement.executeQuery();
+
+            while (rs.next()) {
+                PowersBase toAdd = new PowersBase(rs);
+                powerBaseList.add(toAdd);
+            }
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+
+        return powerBaseList;
+    }
+
+    public static void getFailConditions(HashMap<String, PowersBase> powers) {
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT IDString, type FROM static_power_failcondition where powerOrEffect = 'Power'")) {
+
+            ResultSet rs = preparedStatement.executeQuery();
+
+            while (rs.next()) {
+                String type = rs.getString("type");
+                String IDString = rs.getString("IDString");
+                PowersBase pb = powers.get(IDString);
+
+                if (pb != null)
+                    switch (type) {
+                        case "CastSpell":
+                            pb.cancelOnCastSpell = true;
+                            break;
+                        case "TakeDamage":
+                            pb.cancelOnTakeDamage = true;
+                            break;
+                    }
+            }
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+    }
+
     public ArrayList<SkillReq> GET_REQS_FOR_RUNE(final int objectUUID) {
-        prepareCallable("SELECT * FROM `static_skill_skillreq` WHERE `runeID`=?");
-        setInt(1, objectUUID);
-        return getObjectList();
-    }
-    
-    public SkillReq GET_REQS_BY_SKILLID(int skillID) {
-        prepareCallable("SELECT * FROM `static_skill_skillreq` WHERE `skillID` = ?");
-        setInt(1,skillID);
-        int objectUUID = (int) getUUID();
-        return (SkillReq) this.getObjectSingle(objectUUID);
+
+        ArrayList<SkillReq> skillReqsList = new ArrayList<>();
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `static_skill_skillreq` WHERE `runeID`=?")) {
+
+            preparedStatement.setInt(1, objectUUID);
+
+            ResultSet rs = preparedStatement.executeQuery();
+            skillReqsList = getObjectsFromRs(rs, 5);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+
+        return skillReqsList;
     }
+
 }

src/engine/db/handlers/dbVendorDialogHandler.java

@@ -12,20 +12,39 @@ package engine.db.handlers;
 import engine.Enum;
 import engine.gameManager.DbManager;
 import engine.objects.VendorDialog;
+import org.pmw.tinylog.Logger;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
 
 public class dbVendorDialogHandler extends dbHandlerBase {
 
-	public dbVendorDialogHandler() {
-		this.localClass = VendorDialog.class;
-		this.localObjectType = Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
-	}
+    public dbVendorDialogHandler() {
+        this.localClass = VendorDialog.class;
+        this.localObjectType = Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
+    }
 
-	public VendorDialog GET_VENDORDIALOG(final int objectUUID) {
-		VendorDialog vd = (VendorDialog) DbManager.getFromCache(Enum.GameObjectType.VendorDialog, objectUUID);
-		if (vd != null)
-			return vd;
-		prepareCallable("SELECT * FROM `static_npc_vendordialog` WHERE `ID`=?");
-		setInt(1, objectUUID);
-		return (VendorDialog) getObjectSingle(objectUUID);
-	}
+    public VendorDialog GET_VENDORDIALOG(final int objectUUID) {
+
+        VendorDialog vendorDialog = (VendorDialog) DbManager.getFromCache(Enum.GameObjectType.VendorDialog, objectUUID);
+
+        if (vendorDialog != null)
+            return vendorDialog;
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `static_npc_vendordialog` WHERE `ID`=?")) {
+
+            preparedStatement.setInt(1, objectUUID);
+
+            ResultSet rs = preparedStatement.executeQuery();
+            vendorDialog = (VendorDialog) getObjectFromRs(rs);
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+
+        return vendorDialog;
+    }
 }

src/engine/db/handlers/dbWarehouseHandler.java

@@ -19,7 +19,8 @@ import engine.server.MBServerStatics;
 import org.joda.time.DateTime;
 import org.pmw.tinylog.Logger;
 
-import java.net.UnknownHostException;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.ArrayList;
@@ -33,417 +34,523 @@ public class dbWarehouseHandler extends dbHandlerBase {
 		this.localClass = Warehouse.class;
 		this.localObjectType = engine.Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
 
-		if (columns.isEmpty()) {
-			createColumns();
+	}
+
+	public static void addObject(ArrayList<AbstractGameObject> list, ResultSet rs) throws SQLException {
+		String type = rs.getString("type");
+		switch (type) {
+			case "building":
+				Building building = new Building(rs);
+				DbManager.addToCache(building);
+				list.add(building);
+				break;
+			case "warehouse":
+				Warehouse warehouse = new Warehouse(rs);
+				DbManager.addToCache(warehouse);
+				list.add(warehouse);
+				break;
 		}
 	}
 
-	public Warehouse CREATE_WAREHOUSE(Warehouse wh) {
-		try {
-			wh = this.addWarehouse(wh);
-		} catch (Exception e) {
-			Logger.error(e);
-			wh = null;
-			
-		}
-		return wh;
-	}
+	public ArrayList<AbstractGameObject> CREATE_WAREHOUSE(int parentZoneID, int OwnerUUID, String name, int meshUUID,
+														  Vector3fImmutable location, float meshScale, int currentHP,
+														  ProtectionState protectionState, int currentGold, int rank,
+														  DateTime upgradeDate, int blueprintUUID, float w, float rotY) {
 
-	public ArrayList<AbstractGameObject> CREATE_WAREHOUSE( int parentZoneID, int OwnerUUID, String name, int meshUUID,
-			Vector3fImmutable location, float meshScale, int currentHP,
-			ProtectionState protectionState, int currentGold, int rank,
-			DateTime upgradeDate, int blueprintUUID, float w, float rotY) {
+		ArrayList<AbstractGameObject> warehouseList = new ArrayList<>();
 
-		prepareCallable("CALL `WAREHOUSE_CREATE`(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ? ,? ,? ,?, ?);");
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("CALL `WAREHOUSE_CREATE`(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ? ,? ,? ,?, ?);")) {
 
-		setInt(1, parentZoneID);
-		setInt(2, OwnerUUID);
-		setString(3, name);
-		setInt(4, meshUUID);
-		setFloat(5, location.x);
-		setFloat(6, location.y);
-		setFloat(7, location.z);
-		setFloat(8, meshScale);
-		setInt(9, currentHP);
-		setString(10, protectionState.name());
-		setInt(11, currentGold);
-		setInt(12, rank);
+			preparedStatement.setInt(1, parentZoneID);
+			preparedStatement.setInt(2, OwnerUUID);
+			preparedStatement.setString(3, name);
+			preparedStatement.setInt(4, meshUUID);
+			preparedStatement.setFloat(5, location.x);
+			preparedStatement.setFloat(6, location.y);
+			preparedStatement.setFloat(7, location.z);
+			preparedStatement.setFloat(8, meshScale);
+			preparedStatement.setInt(9, currentHP);
+			preparedStatement.setString(10, protectionState.name());
+			preparedStatement.setInt(11, currentGold);
+			preparedStatement.setInt(12, rank);
 
-		if (upgradeDate != null) {
-			setTimeStamp(13, upgradeDate.getMillis());
-		} else {
-			setNULL(13, java.sql.Types.DATE);
-		}
+			if (upgradeDate != null)
+				preparedStatement.setTimestamp(13, new java.sql.Timestamp(upgradeDate.getMillis()));
+			else
+				preparedStatement.setNull(13, java.sql.Types.DATE);
 
-		setInt(14, blueprintUUID);
-		setFloat(15, w);
-		setFloat(16, rotY);
+			preparedStatement.setInt(14, blueprintUUID);
+			preparedStatement.setFloat(15, w);
+			preparedStatement.setFloat(16, rotY);
 
-		ArrayList<AbstractGameObject> list = new ArrayList<>();
-		//System.out.println(this.cs.get().toString());
-		try {
-			boolean work = execute();
-			if (work) {
-				ResultSet rs = this.cs.get().getResultSet();
-				while (rs.next()) {
-					addObject(list, rs);
-				}
-				rs.close();
-			} else {
-				Logger.info("Warehouse Creation Failed: " + this.cs.get().toString());
-				return list; //city creation failure
-			}
-			while (this.cs.get().getMoreResults()) {
-				ResultSet rs = this.cs.get().getResultSet();
-				while (rs.next()) {
-					addObject(list, rs);
-				}
-				rs.close();
+			preparedStatement.execute();
+			ResultSet rs = preparedStatement.getResultSet();
+
+			while (rs.next())
+				addObject(warehouseList, rs);
+
+			while (preparedStatement.getMoreResults()) {
+				rs = preparedStatement.getResultSet();
+
+				while (rs.next())
+					addObject(warehouseList, rs);
 			}
 		} catch (SQLException e) {
-			Logger.info("Warehouse Creation Failed, SQLException: " + this.cs.get().toString() + e.toString());
-			return list; //city creation failure
-		} catch (UnknownHostException e) {
-			Logger.info("Warehouse Creation Failed, UnknownHostException: " + this.cs.get().toString());
-			return list; //city creation failure
-		} finally {
-			closeCallable();
-		}
-		return list;
-
-	}
-
-	//Don't call yet, not ready in DB. -
-	public boolean WAREHOUSE_ADD(Item item, Warehouse warehouse, ItemBase ib, int amount) {
-		if (item == null || warehouse == null || ib == null || !(dbWarehouseHandler.columns.containsKey(ib.getUUID()))) {
-			return false;
-		}
-		if ((item.getNumOfItems() - amount) < 0) {
-			return false;
-		}
-		if (!warehouse.getResources().containsKey(ib)) {
-			return false;
+			Logger.error(e);
 		}
 
-		prepareCallable("CALL `warehouse_ADD`(?,?,?,?,?,?,?);");
-		setLong(1, (long) warehouse.getObjectUUID());
-		setInt(2, warehouse.getResources().get(ib));
-		setLong(3, (long) item.getObjectUUID());
-		setInt(4, item.getNumOfItems());
-		setInt(5, amount);
-		setString(6, dbWarehouseHandler.columns.get(ib.getUUID()));
-		setInt(7, ib.getUUID());
-		String result = getResult();
-
-		return (result != null && result.equals("success"));
-	}
-
-	private Warehouse addWarehouse(Warehouse toAdd) {
-		prepareCallable("CALL `warehouse_CREATE`(?);");
-		setInt(1, toAdd.getUID());
-		int objectUUID = (int) getUUID();
-		if (objectUUID > 0) {
-			return GET_WAREHOUSE(objectUUID);
-		}
-		return null;
-	}
-
-	public Warehouse GET_WAREHOUSE(int objectUUID) {
-		Warehouse warehouse = (Warehouse) DbManager.getFromCache(GameObjectType.Warehouse, objectUUID);
-		if (warehouse != null)
-			return warehouse;
-		prepareCallable("SELECT * FROM `obj_warehouse` WHERE `UID` = ?");
-		setInt(1, objectUUID);
-		return (Warehouse) getObjectSingle(objectUUID);
+		return warehouseList;
 	}
 
 	public boolean updateLocks(final Warehouse wh, long locks) {
-		prepareCallable("UPDATE `obj_warehouse` SET `warehouse_locks`=? WHERE `UID` = ?");
-		setLong(1, locks);
-		setInt(2, wh.getUID());
-		return (executeUpdate() != 0);
+
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_warehouse` SET `warehouse_locks`=? WHERE `UID` = ?")) {
+
+			preparedStatement.setLong(1, locks);
+			preparedStatement.setInt(2, wh.getUID());
+
+			return (preparedStatement.executeUpdate() > 0);
+
+		} catch (SQLException e) {
+			Logger.error(e);
+		}
+		return false;
 	}
 
-	public boolean updateGold(final Warehouse wh, int amount ) {
-		prepareCallable("UPDATE `obj_warehouse` SET `warehouse_gold`=? WHERE `UID` = ?");
-		setInt(1, amount);
-		setInt(2, wh.getUID());
-		return (executeUpdate() != 0);
+	public boolean updateGold(final Warehouse wh, int amount) {
+
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_warehouse` SET `warehouse_gold`=? WHERE `UID` = ?")) {
+
+			preparedStatement.setInt(1, amount);
+			preparedStatement.setInt(2, wh.getUID());
+
+			return (preparedStatement.executeUpdate() > 0);
+
+		} catch (SQLException e) {
+			Logger.error(e);
+		}
+		return false;
 	}
 
 	public boolean updateStone(final Warehouse wh, int amount) {
-		prepareCallable("UPDATE `obj_warehouse` SET `warehouse_stone`=? WHERE `UID` = ?");
-		setInt(1, amount);
-		setInt(2, wh.getUID());
 
-		return (executeUpdate() != 0);
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_warehouse` SET `warehouse_stone`=? WHERE `UID` = ?")) {
+
+			preparedStatement.setInt(1, amount);
+			preparedStatement.setInt(2, wh.getUID());
+
+			return (preparedStatement.executeUpdate() > 0);
+
+		} catch (SQLException e) {
+			Logger.error(e);
+		}
+		return false;
 	}
 
 	public boolean updateTruesteel(final Warehouse wh, int amount) {
-		prepareCallable("UPDATE `obj_warehouse` SET `warehouse_truesteel`=? WHERE `UID` = ?");
-		setInt(1, amount);
-		setInt(2, wh.getUID());
 
-		return (executeUpdate() != 0);
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_warehouse` SET `warehouse_truesteel`=? WHERE `UID` = ?")) {
+
+			preparedStatement.setInt(1, amount);
+			preparedStatement.setInt(2, wh.getUID());
+
+			return (preparedStatement.executeUpdate() > 0);
+
+		} catch (SQLException e) {
+			Logger.error(e);
+		}
+		return false;
 	}
 
 	public boolean updateIron(final Warehouse wh, int amount) {
-		prepareCallable("UPDATE `obj_warehouse` SET `warehouse_iron`=? WHERE `UID` = ?");
-		setInt(1, amount);
-		setInt(2, wh.getUID());
 
-		return (executeUpdate() != 0);
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_warehouse` SET `warehouse_iron`=? WHERE `UID` = ?")) {
+
+			preparedStatement.setInt(1, amount);
+			preparedStatement.setInt(2, wh.getUID());
+
+			return (preparedStatement.executeUpdate() > 0);
+
+		} catch (SQLException e) {
+			Logger.error(e);
+		}
+		return false;
 	}
 
 	public boolean updateAdamant(final Warehouse wh, int amount) {
-		prepareCallable("UPDATE `obj_warehouse` SET `warehouse_adamant`=? WHERE `UID` = ?");
-		setInt(1, amount);
-		setInt(2, wh.getUID());
 
-		return (executeUpdate() != 0);
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_warehouse` SET `warehouse_adamant`=? WHERE `UID` = ?")) {
+
+			preparedStatement.setInt(1, amount);
+			preparedStatement.setInt(2, wh.getUID());
+
+			return (preparedStatement.executeUpdate() > 0);
+
+		} catch (SQLException e) {
+			Logger.error(e);
+		}
+		return false;
 	}
 
 	public boolean updateLumber(final Warehouse wh, int amount) {
-		prepareCallable("UPDATE `obj_warehouse` SET `warehouse_lumber`=? WHERE `UID` = ?");
-		setInt(1, amount);
-		setInt(2, wh.getUID());
 
-		return (executeUpdate() != 0);
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_warehouse` SET `warehouse_lumber`=? WHERE `UID` = ?")) {
+
+			preparedStatement.setInt(1, amount);
+			preparedStatement.setInt(2, wh.getUID());
+
+			return (preparedStatement.executeUpdate() > 0);
+
+		} catch (SQLException e) {
+			Logger.error(e);
+		}
+		return false;
 	}
 
 	public boolean updateOak(final Warehouse wh, int amount) {
-		prepareCallable("UPDATE `obj_warehouse` SET `warehouse_oak`=? WHERE `UID` = ?");
-		setInt(1, amount);
-		setInt(2, wh.getUID());
 
-		return (executeUpdate() != 0);
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_warehouse` SET `warehouse_oak`=? WHERE `UID` = ?")) {
+
+			preparedStatement.setInt(1, amount);
+			preparedStatement.setInt(2, wh.getUID());
+
+			return (preparedStatement.executeUpdate() > 0);
+
+		} catch (SQLException e) {
+			Logger.error(e);
+		}
+		return false;
 	}
 
 	public boolean updateBronzewood(final Warehouse wh, int amount) {
-		prepareCallable("UPDATE `obj_warehouse` SET `warehouse_bronzewood`=? WHERE `UID` = ?");
-		setInt(1, amount);
-		setInt(2, wh.getUID());
 
-		return (executeUpdate() != 0);
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_warehouse` SET `warehouse_bronzewood`=? WHERE `UID` = ?")) {
+
+			preparedStatement.setInt(1, amount);
+			preparedStatement.setInt(2, wh.getUID());
+
+			return (preparedStatement.executeUpdate() > 0);
+
+		} catch (SQLException e) {
+			Logger.error(e);
+		}
+		return false;
 	}
 
 	public boolean updateMandrake(final Warehouse wh, int amount) {
-		prepareCallable("UPDATE `obj_warehouse` SET `warehouse_mandrake`=? WHERE `UID` = ?");
-		setInt(1, amount);
-		setInt(2, wh.getUID());
 
-		return (executeUpdate() != 0);
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_warehouse` SET `warehouse_mandrake`=? WHERE `UID` = ?")) {
+
+			preparedStatement.setInt(1, amount);
+			preparedStatement.setInt(2, wh.getUID());
+
+			return (preparedStatement.executeUpdate() > 0);
+
+		} catch (SQLException e) {
+			Logger.error(e);
+		}
+		return false;
 	}
 
 	public boolean updateCoal(final Warehouse wh, int amount) {
-		prepareCallable("UPDATE `obj_warehouse` SET `warehouse_coal`=? WHERE `UID` = ?");
-		setInt(1, amount);
-		setInt(2, wh.getUID());
 
-		return (executeUpdate() != 0);
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_warehouse` SET `warehouse_coal`=? WHERE `UID` = ?")) {
+
+			preparedStatement.setInt(1, amount);
+			preparedStatement.setInt(2, wh.getUID());
+
+			return (preparedStatement.executeUpdate() > 0);
+
+		} catch (SQLException e) {
+			Logger.error(e);
+		}
+		return false;
 	}
 
 	public boolean updateAgate(final Warehouse wh, int amount) {
-		prepareCallable("UPDATE `obj_warehouse` SET `warehouse_agate`=? WHERE `UID` = ?");
-		setInt(1, amount);
-		setInt(2, wh.getUID());
 
-		return (executeUpdate() != 0);
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_warehouse` SET `warehouse_agate`=? WHERE `UID` = ?")) {
+
+			preparedStatement.setInt(1, amount);
+			preparedStatement.setInt(2, wh.getUID());
+
+			return (preparedStatement.executeUpdate() > 0);
+
+		} catch (SQLException e) {
+			Logger.error(e);
+		}
+		return false;
 	}
 
 	public boolean updateDiamond(final Warehouse wh, int amount) {
-		prepareCallable("UPDATE `obj_warehouse` SET `warehouse_diamond`=? WHERE `UID` = ?");
-		setInt(1, amount);
-		setInt(2, wh.getUID());
 
-		return (executeUpdate() != 0);
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_warehouse` SET `warehouse_diamond`=? WHERE `UID` = ?")) {
+
+			preparedStatement.setInt(1, amount);
+			preparedStatement.setInt(2, wh.getUID());
+
+			return (preparedStatement.executeUpdate() > 0);
+
+		} catch (SQLException e) {
+			Logger.error(e);
+		}
+		return false;
 	}
 
 	public boolean updateOnyx(final Warehouse wh, int amount) {
-		prepareCallable("UPDATE `obj_warehouse` SET `warehouse_onyx`=? WHERE `UID` = ?");
-		setInt(1, amount);
-		setInt(2, wh.getUID());
 
-		return (executeUpdate() != 0);
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_warehouse` SET `warehouse_onyx`=? WHERE `UID` = ?")) {
+
+			preparedStatement.setInt(1, amount);
+			preparedStatement.setInt(2, wh.getUID());
+
+			return (preparedStatement.executeUpdate() > 0);
+
+		} catch (SQLException e) {
+			Logger.error(e);
+		}
+		return false;
 	}
 
 	public boolean updateAzoth(final Warehouse wh, int amount) {
-		prepareCallable("UPDATE `obj_warehouse` SET `warehouse_azoth`=? WHERE `UID` = ?");
-		setInt(1, amount);
-		setInt(2, wh.getUID());
 
-		return (executeUpdate() != 0);
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_warehouse` SET `warehouse_azoth`=? WHERE `UID` = ?")) {
+
+			preparedStatement.setInt(1, amount);
+			preparedStatement.setInt(2, wh.getUID());
+
+			return (preparedStatement.executeUpdate() > 0);
+
+		} catch (SQLException e) {
+			Logger.error(e);
+		}
+		return false;
 	}
 
 	public boolean updateOrichalk(final Warehouse wh, int amount) {
-		prepareCallable("UPDATE `obj_warehouse` SET `warehouse_orichalk`=? WHERE `UID` = ?");
-		setInt(1, amount);
-		setInt(2, wh.getUID());
 
-		return (executeUpdate() != 0);
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_warehouse` SET `warehouse_orichalk`=? WHERE `UID` = ?")) {
+
+			preparedStatement.setInt(1, amount);
+			preparedStatement.setInt(2, wh.getUID());
+
+			return (preparedStatement.executeUpdate() > 0);
+
+		} catch (SQLException e) {
+			Logger.error(e);
+		}
+		return false;
 	}
 
 	public boolean updateAntimony(final Warehouse wh, int amount) {
-		prepareCallable("UPDATE `obj_warehouse` SET `warehouse_antimony`=? WHERE `UID` = ?");
-		setInt(1, amount);
-		setInt(2, wh.getUID());
 
-		return (executeUpdate() != 0);
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_warehouse` SET `warehouse_antimony`=? WHERE `UID` = ?")) {
+
+			preparedStatement.setInt(1, amount);
+			preparedStatement.setInt(2, wh.getUID());
+
+			return (preparedStatement.executeUpdate() > 0);
+
+		} catch (SQLException e) {
+			Logger.error(e);
+		}
+		return false;
 	}
 
 	public boolean updateSulfur(final Warehouse wh, int amount) {
-		prepareCallable("UPDATE `obj_warehouse` SET `warehouse_sulfur`=? WHERE `UID` = ?");
-		setInt(1, amount);
-		setInt(2, wh.getUID());
 
-		return (executeUpdate() != 0);
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_warehouse` SET `warehouse_sulfur`=? WHERE `UID` = ?")) {
+
+			preparedStatement.setInt(1, amount);
+			preparedStatement.setInt(2, wh.getUID());
+
+			return (preparedStatement.executeUpdate() > 0);
+
+		} catch (SQLException e) {
+			Logger.error(e);
+		}
+		return false;
 	}
 
 	public boolean updateQuicksilver(final Warehouse wh, int amount) {
-		prepareCallable("UPDATE `obj_warehouse` SET `warehouse_quicksilver`=? WHERE `UID` = ?");
-		setInt(1, amount);
-		setInt(2, wh.getUID());
 
-		return (executeUpdate() != 0);
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_warehouse` SET `warehouse_quicksilver`=? WHERE `UID` = ?")) {
+
+			preparedStatement.setInt(1, amount);
+			preparedStatement.setInt(2, wh.getUID());
+
+			return (preparedStatement.executeUpdate() > 0);
+
+		} catch (SQLException e) {
+			Logger.error(e);
+		}
+		return false;
 	}
 
 	public boolean updateGalvor(final Warehouse wh, int amount) {
-		prepareCallable("UPDATE `obj_warehouse` SET `warehouse_galvor`=? WHERE `UID` = ?");
-		setInt(1, amount);
-		setInt(2, wh.getUID());
 
-		return (executeUpdate() != 0);
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_warehouse` SET `warehouse_galvor`=? WHERE `UID` = ?")) {
+
+			preparedStatement.setInt(1, amount);
+			preparedStatement.setInt(2, wh.getUID());
+
+			return (preparedStatement.executeUpdate() > 0);
+
+		} catch (SQLException e) {
+			Logger.error(e);
+		}
+		return false;
 	}
 
-	public boolean updateWormwood(final Warehouse wh, int amount ) {
-		prepareCallable("UPDATE `obj_warehouse` SET `warehouse_wormwood`=? WHERE `UID` = ?");
-		setInt(1, amount);
-		setInt(2, wh.getUID());
+	public boolean updateWormwood(final Warehouse wh, int amount) {
 
-		return (executeUpdate() != 0);
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_warehouse` SET `warehouse_wormwood`=? WHERE `UID` = ?")) {
+
+			preparedStatement.setInt(1, amount);
+			preparedStatement.setInt(2, wh.getUID());
+
+			return (preparedStatement.executeUpdate() > 0);
+
+		} catch (SQLException e) {
+			Logger.error(e);
+		}
+		return false;
 	}
 
 	public boolean updateObsidian(final Warehouse wh, int amount) {
-		prepareCallable("UPDATE `obj_warehouse` SET `warehouse_obsidian`=? WHERE `UID` = ?");
-		setInt(1, amount);
-		setInt(2, wh.getUID());
 
-		return (executeUpdate() != 0);
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_warehouse` SET `warehouse_obsidian`=? WHERE `UID` = ?")) {
+
+			preparedStatement.setInt(1, amount);
+			preparedStatement.setInt(2, wh.getUID());
+
+			return (preparedStatement.executeUpdate() > 0);
+
+		} catch (SQLException e) {
+			Logger.error(e);
+		}
+		return false;
 	}
 
 	public boolean updateBloodstone(final Warehouse wh, int amount) {
-		prepareCallable("UPDATE `obj_warehouse` SET `warehouse_bloodstone`=? WHERE `UID` = ?");
-		setInt(1, amount);
-		setInt(2, wh.getUID());
 
-		return (executeUpdate() != 0);
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_warehouse` SET `warehouse_bloodstone`=? WHERE `UID` = ?")) {
+
+			preparedStatement.setInt(1, amount);
+			preparedStatement.setInt(2, wh.getUID());
+
+			return (preparedStatement.executeUpdate() > 0);
+
+		} catch (SQLException e) {
+			Logger.error(e);
+		}
+		return false;
 	}
 
 	public boolean updateMithril(final Warehouse wh, int amount) {
-		prepareCallable("UPDATE `obj_warehouse` SET `warehouse_mithril`=? WHERE `UID` = ?");
-		setInt(1, amount);
-		setInt(2, wh.getUID());
 
-		return (executeUpdate() != 0);
-	}
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_warehouse` SET `warehouse_mithril`=? WHERE `UID` = ?")) {
 
-	private static void createColumns() {
-		columns.put(1580000, "warehouse_stone");
-		columns.put(1580001, "warehouse_truesteel");
-		columns.put(1580002, "warehouse_iron");
-		columns.put(1580003, "warehouse_adamant");
-		columns.put(1580004, "warehouse_lumber");
-		columns.put(1580005, "warehouse_oak");
-		columns.put(1580006, "warehouse_bronzewood");
-		columns.put(1580007, "warehouse_mandrake");
-		columns.put(1580008, "warehouse_coal");
-		columns.put(1580009, "warehouse_agate");
-		columns.put(1580010, "warehouse_diamond");
-		columns.put(1580011, "warehouse_onyx");
-		columns.put(1580012, "warehouse_azoth");
-		columns.put(1580013, "warehouse_orichalk");
-		columns.put(1580014, "warehouse_antimony");
-		columns.put(1580015, "warehouse_sulfur");
-		columns.put(1580016, "warehouse_quicksilver");
-		columns.put(1580017, "warehouse_galvor");
-		columns.put(1580018, "warehouse_wormwood");
-		columns.put(1580019, "warehouse_obsidian");
-		columns.put(1580020, "warehouse_bloodstone");
-		columns.put(1580021, "warehouse_mithril");
-		columns.put(7, "warehouse_gold");
-	}
+			preparedStatement.setInt(1, amount);
+			preparedStatement.setInt(2, wh.getUID());
 
-	public boolean CREATE_TRANSACTION(int warehouseBuildingID, GameObjectType targetType, int targetUUID, TransactionType transactionType,Resource resource, int amount,DateTime date){
-		Transaction transactions = null;
-		prepareCallable("INSERT INTO `dyn_warehouse_transactions` (`warehouseUID`, `targetType`,`targetUID`, `type`,`resource`,`amount`,`date` ) VALUES (?,?,?,?,?,?,?)");
-		setLong(1, warehouseBuildingID);
-		setString(2, targetType.name());
-		setLong(3, targetUUID);
-		setString(4, transactionType.name());
-		setString(5, resource.name());
-		setInt(6,amount);
-		setTimeStamp(7,date.getMillis());
-		return (executeUpdate() != 0);
-	}
+			return (preparedStatement.executeUpdate() > 0);
 
-
-
-	public static void addObject(ArrayList<AbstractGameObject> list, ResultSet rs) throws SQLException, UnknownHostException {
-		String type = rs.getString("type");
-		switch (type) {
-		case "building":
-			Building building = new Building(rs);
-			DbManager.addToCache(building);
-			list.add(building);
-			break;
-		case "warehouse":
-			Warehouse warehouse = new Warehouse(rs);
-			DbManager.addToCache(warehouse);
-			list.add(warehouse);
-			break;
+		} catch (SQLException e) {
+			Logger.error(e);
 		}
+		return false;
+	}
+
+	public boolean CREATE_TRANSACTION(int warehouseBuildingID, GameObjectType targetType, int targetUUID, TransactionType transactionType, Resource resource, int amount, DateTime date) {
+
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("INSERT INTO `dyn_warehouse_transactions` (`warehouseUID`, `targetType`,`targetUID`, `type`,`resource`,`amount`,`date` ) VALUES (?,?,?,?,?,?,?)")) {
+
+			preparedStatement.setInt(1, amount);
+			preparedStatement.setLong(1, warehouseBuildingID);
+			preparedStatement.setString(2, targetType.name());
+			preparedStatement.setLong(3, targetUUID);
+			preparedStatement.setString(4, transactionType.name());
+			preparedStatement.setString(5, resource.name());
+			preparedStatement.setInt(6, amount);
+			preparedStatement.setTimestamp(7, new java.sql.Timestamp(date.getMillis()));
+
+			return (preparedStatement.executeUpdate() > 0);
+
+		} catch (SQLException e) {
+			Logger.error(e);
+		}
+		return false;
 	}
 
 	public ArrayList<Transaction> GET_TRANSACTIONS_FOR_WAREHOUSE(final int warehouseUUID) {
-		ArrayList<Transaction> transactionsList = new ArrayList<>();
-		prepareCallable("SELECT * FROM dyn_warehouse_transactions WHERE `warehouseUID` = ?;");
-		setInt(1, warehouseUUID);
-		try {
-			ResultSet rs = executeQuery();
 
-			//shrines cached in rs for easy cache on creation.
+		ArrayList<Transaction> transactionsList = new ArrayList<>();
+
+
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM dyn_warehouse_transactions WHERE `warehouseUID` = ?;")) {
+
+			preparedStatement.setInt(1, warehouseUUID);
+
+			ResultSet rs = preparedStatement.executeQuery();
+
 			while (rs.next()) {
 				Transaction transactions = new Transaction(rs);
 				transactionsList.add(transactions);
 			}
 
 		} catch (SQLException e) {
-			Logger.error( e.getErrorCode() + ' ' + e.getMessage(), e);
-		} finally {
-			closeCallable();
+			Logger.error(e);
 		}
+
 		return transactionsList;
 	}
 
 	public void LOAD_ALL_WAREHOUSES() {
 
-		Warehouse thisWarehouse;
+		Warehouse warehouse;
 
-		prepareCallable("SELECT `obj_warehouse`.*, `object`.`parent`, `object`.`type` FROM `object` LEFT JOIN `obj_warehouse` ON `object`.`UID` = `obj_warehouse`.`UID` WHERE `object`.`type` = 'warehouse';");
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("SELECT `obj_warehouse`.*, `object`.`parent`, `object`.`type` FROM `object` LEFT JOIN `obj_warehouse` ON `object`.`UID` = `obj_warehouse`.`UID` WHERE `object`.`type` = 'warehouse';")) {
+
+
+			ResultSet rs = preparedStatement.executeQuery();
 
-		try {
-			ResultSet rs = executeQuery();
 			while (rs.next()) {
-				thisWarehouse = new Warehouse(rs);
-				thisWarehouse.runAfterLoad();
-				thisWarehouse.loadAllTransactions();
+				warehouse = new Warehouse(rs);
+				warehouse.runAfterLoad();
+				warehouse.loadAllTransactions();
 			}
 
 		} catch (SQLException e) {
-			Logger.error(e.getErrorCode() + ' ' + e.getMessage(), e);
-		} finally {
-			closeCallable();
+			Logger.error(e);
 		}
-
 	}
 }

src/engine/db/handlers/dbZoneHandler.java

@@ -11,9 +11,15 @@ package engine.db.handlers;
 
 import engine.Enum;
 import engine.gameManager.DbManager;
+import engine.gameManager.ZoneManager;
+import engine.math.Vector2f;
 import engine.objects.Zone;
+import org.pmw.tinylog.Logger;
 
+import java.sql.Connection;
+import java.sql.PreparedStatement;
 import java.sql.ResultSet;
+import java.sql.SQLException;
 import java.util.ArrayList;
 
 public class dbZoneHandler extends dbHandlerBase {
@@ -46,48 +52,79 @@ public class dbZoneHandler extends dbHandlerBase {
 
 	public Zone GET_BY_UID(long ID) {
 
-		Zone zone = (Zone) DbManager.getFromCache(Enum.GameObjectType.Zone, (int)ID);
+		Zone zone = (Zone) DbManager.getFromCache(Enum.GameObjectType.Zone, (int) ID);
+
 		if (zone != null)
 			return zone;
-		prepareCallable("SELECT `obj_zone`.*, `object`.`parent` FROM `object` INNER JOIN `obj_zone` ON `obj_zone`.`UID` = `object`.`UID` WHERE `object`.`UID` = ?;");
-		setLong(1, ID);
-		return (Zone) getObjectSingle((int) ID);
+
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("SELECT `obj_zone`.*, `object`.`parent` FROM `object` INNER JOIN `obj_zone` ON `obj_zone`.`UID` = `object`.`UID` WHERE `object`.`UID` = ?;")) {
+
+			preparedStatement.setLong(1, ID);
+
+			ResultSet rs = preparedStatement.executeQuery();
+			zone = (Zone) getObjectFromRs(rs);
+
+		} catch (SQLException e) {
+			Logger.error(e);
+		}
+
+		return zone;
 	}
 
 	public ArrayList<Zone> GET_MAP_NODES(final int objectUUID) {
-		prepareCallable("SELECT `obj_zone`.*, `object`.`parent` FROM `object` INNER JOIN `obj_zone` ON `obj_zone`.`UID` = `object`.`UID` WHERE `object`.`parent` = ?;");
-		setLong(1, (long) objectUUID);
-		return getObjectList();
+
+		ArrayList<Zone> zoneList = new ArrayList<>();
+
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("SELECT `obj_zone`.*, `object`.`parent` FROM `object` INNER JOIN `obj_zone` ON `obj_zone`.`UID` = `object`.`UID` WHERE `object`.`parent` = ?;")) {
+
+			preparedStatement.setLong(1, objectUUID);
+
+			ResultSet rs = preparedStatement.executeQuery();
+			zoneList = getObjectsFromRs(rs, 2000);
+
+		} catch (SQLException e) {
+			Logger.error(e);
+		}
+
+		return zoneList;
 	}
 
-	public ResultSet GET_ZONE_EXTENTS(final int loadNum) {
-		prepareCallable("SELECT * FROM `static_zone_size` WHERE `loadNum`=?;");
-		setInt(1, loadNum);
-		return executeQuery();
-	}
+	public void LOAD_ZONE_EXTENTS() {
 
-	public String SET_PROPERTY(final Zone z, String name, Object new_value) {
-		prepareCallable("CALL zone_SETPROP(?,?,?)");
-		setLong(1, (long) z.getObjectUUID());
-		setString(2, name);
-		setString(3, String.valueOf(new_value));
-		return getResult();
-	}
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `static_zone_size`;")) {
 
-	public String SET_PROPERTY(final Zone z, String name, Object new_value, Object old_value) {
-		prepareCallable("CALL zone_GETSETPROP(?,?,?,?)");
-		setLong(1, (long) z.getObjectUUID());
-		setString(2, name);
-		setString(3, String.valueOf(new_value));
-		setString(4, String.valueOf(old_value));
-		return getResult();
+			ResultSet rs = preparedStatement.executeQuery();
+
+			while (rs.next()) {
+				Vector2f zoneSize = new Vector2f();
+				int loadNum = rs.getInt("loadNum");
+				zoneSize.x = rs.getFloat("xRadius");
+				zoneSize.y = rs.getFloat("zRadius");
+				ZoneManager._zone_size_data.put(loadNum, zoneSize);
+			}
+
+		} catch (SQLException e) {
+			Logger.error(e);
+		}
 	}
 
 	public boolean DELETE_ZONE(final Zone zone) {
 
-		prepareCallable("DELETE FROM `object` WHERE `UID` = ? AND `type` = 'zone'");
-		setInt(1, zone.getObjectUUID());
-		return (executeUpdate() != 0);
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement preparedStatement = connection.prepareStatement("DELETE FROM `object` WHERE `UID` = ? AND `type` = 'zone'")) {
+
+			preparedStatement.setInt(1, zone.getObjectUUID());
+
+			return (preparedStatement.executeUpdate() > 0);
+
+		} catch (SQLException e) {
+			Logger.error(e);
+		}
+
+		return false;
 	}
 
 }

src/engine/devcmd/cmds/GuildListCmd.java

@@ -1,105 +0,0 @@
-// • ▌ ▄ ·.  ▄▄▄·  ▄▄ • ▪   ▄▄· ▄▄▄▄·  ▄▄▄·  ▐▄▄▄  ▄▄▄ .
-// ·██ ▐███▪▐█ ▀█ ▐█ ▀ ▪██ ▐█ ▌▪▐█ ▀█▪▐█ ▀█ •█▌ ▐█▐▌·
-// ▐█ ▌▐▌▐█·▄█▀▀█ ▄█ ▀█▄▐█·██ ▄▄▐█▀▀█▄▄█▀▀█ ▐█▐ ▐▌▐▀▀▀
-// ██ ██▌▐█▌▐█ ▪▐▌▐█▄▪▐█▐█▌▐███▌██▄▪▐█▐█ ▪▐▌██▐ █▌▐█▄▄▌
-// ▀▀  █▪▀▀▀ ▀  ▀ ·▀▀▀▀ ▀▀▀·▀▀▀ ·▀▀▀▀  ▀  ▀ ▀▀  █▪ ▀▀▀
-//      Magicbane Emulator Project © 2013 - 2022
-//                www.magicbane.com
-
-
-package engine.devcmd.cmds;
-
-import engine.devcmd.AbstractDevCmd;
-import engine.gameManager.DbManager;
-import engine.objects.AbstractGameObject;
-import engine.objects.PlayerCharacter;
-
-
-/**
- * @author 
- * Summary: Lists UID, Name and GL UID of either
- *          Player or NPC sovereign guilds
- */
- 
-public class GuildListCmd extends AbstractDevCmd {
-
-    // Instance variables
-    
-    private int _guildType; // 0 = Player : 1 = NPC sovereign guilds
-    private String outputStr = null;
-    
-	public GuildListCmd() {
-        super("guildlist");
-    }
-
-        
-        // AbstractDevCmd Overridden methods
-        
-	@Override
-	protected void _doCmd(PlayerCharacter pc, String[] args,
-			AbstractGameObject target) {
-
-            if(validateUserInput(args) == false) {
-                this.sendUsage(pc);
-		 return;
-            }
-            
-            parseUserInput(args);
-         
-         // Execute stored procedure
-            
-            outputStr = DbManager.GuildQueries.GET_GUILD_LIST(_guildType);
-            
-         // Send results to user
-
-            throwbackInfo(pc, outputStr);
-
-        }
-
-	@Override
-	protected String _getHelpString() {
-        return "Lists guild info for sovereign guilds";
-	}
-
-	@Override
-	protected String _getUsageString() {
-        return "/guildlist npc|player";
-	}
-
-        // Class methods
-        
-        private static boolean validateUserInput(String[] userInput) {
-
-        int stringIndex;
-        String commandSet = "npcplayer";
-        
-        // incorrect number of arguments test
-        
-        if (userInput.length != 1)
-         return false;    
-
-        // Test of game object type argument
-        
-        stringIndex = commandSet.indexOf(userInput[0].toLowerCase());
-
-            return stringIndex != -1;
-        }
-        
-        private void parseUserInput(String[] userInput) {
-        
-        // Build mask from user input
-          
-            switch (userInput[0].toLowerCase()) {
-                case "npc":
-                 _guildType = 1;
-                    break;
-                case "player":
-                  _guildType = 0;
-                    break;
-                default:
-                    break;
-            }
-            
-        }
-        
-}

src/engine/devcmd/cmds/RenameMobCmd.java

@@ -1,101 +0,0 @@
-// • ▌ ▄ ·.  ▄▄▄·  ▄▄ • ▪   ▄▄· ▄▄▄▄·  ▄▄▄·  ▐▄▄▄  ▄▄▄ .
-// ·██ ▐███▪▐█ ▀█ ▐█ ▀ ▪██ ▐█ ▌▪▐█ ▀█▪▐█ ▀█ •█▌ ▐█▐▌·
-// ▐█ ▌▐▌▐█·▄█▀▀█ ▄█ ▀█▄▐█·██ ▄▄▐█▀▀█▄▄█▀▀█ ▐█▐ ▐▌▐▀▀▀
-// ██ ██▌▐█▌▐█ ▪▐▌▐█▄▪▐█▐█▌▐███▌██▄▪▐█▐█ ▪▐▌██▐ █▌▐█▄▄▌
-// ▀▀  █▪▀▀▀ ▀  ▀ ·▀▀▀▀ ▀▀▀·▀▀▀ ·▀▀▀▀  ▀  ▀ ▀▀  █▪ ▀▀▀
-//      Magicbane Emulator Project © 2013 - 2022
-//                www.magicbane.com
-
-
-package engine.devcmd.cmds;
-
-import engine.devcmd.AbstractDevCmd;
-import engine.gameManager.ChatManager;
-import engine.objects.AbstractGameObject;
-import engine.objects.MobBase;
-import engine.objects.NPC;
-import engine.objects.PlayerCharacter;
-
-/**
- *
- * @author Eighty
- *
- */
-public class RenameMobCmd extends AbstractDevCmd {
-
-	public RenameMobCmd() {
-        super("renamemob");
-    }
-
-	@Override
-	protected void _doCmd(PlayerCharacter pcSender, String[] args,
-			AbstractGameObject target) {
-		if (args.length < 1) {
-			this.sendUsage(pcSender);
-			return;
-		}
-		int loadID = 0;
-		String name = "";
-		NPC npc;
-		if (target != null && target instanceof NPC)
-			npc = (NPC) target;
-		else
-			npc = getTargetAsNPC(pcSender);
-		if (npc != null) {
-			for (int i = 0; i < args.length; i++) {
-				name += args[i];
-				if (i + 1 < args.length)
-					name += " ";
-			}
-			npc.setName(name);
-			npc.updateDatabase();
-			ChatManager.chatSayInfo(
-					pcSender,
-					"NPC with ID " + npc.getObjectUUID() + " renamed to "
-							+ npc.getFirstName());
-		} else {
-			try {
-				loadID = Integer.parseInt(args[0]);
-				if (args.length > 1) {
-					for (int i = 1; i < args.length; i++) {
-						name += args[i];
-						if (i + 1 < args.length)
-							name += " ";
-					}
-				}
-			} catch (Exception e) {
-				throwbackError(pcSender,
-						"Invalid renameMob Command. Need mob ID specified.");
-				return; // NaN
-			}
-			MobBase mob = MobBase.getMobBase(loadID);
-			if (mob == null) {
-				throwbackError(pcSender,
-						"Invalid renameMob Command. Mob ID specified is not valid.");
-				return;
-			}
-			if (!MobBase.renameMobBase(mob.getObjectUUID(), name)) {
-				throwbackError(pcSender,
-						"renameMob SQL Error. Failed to rename mob.");
-				return;
-			}
-			mob = MobBase.getMobBase(mob.getObjectUUID(), true); // force refresh
-																// from db
-			ChatManager.chatSayInfo(
-					pcSender,
-					"MobBase with ID " + mob.getObjectUUID() + " renamed to "
-							+ mob.getFirstName());
-		}
-	}
-
-	@Override
-	protected String _getUsageString() {
-        return "' /renamemob [ID] newName'";
-	}
-
-	@Override
-	protected String _getHelpString() {
-        return "Changes a mobs old name to a new name";
-	}
-
-}

src/engine/gameManager/DbManager.java

@@ -8,11 +8,12 @@
 
 package engine.gameManager;
 
+import com.zaxxer.hikari.HikariConfig;
+import com.zaxxer.hikari.HikariDataSource;
 import engine.Enum;
 import engine.Enum.GameObjectType;
 import engine.db.handlers.*;
 import engine.objects.*;
-import engine.pooling.ConnectionPool;
 import engine.server.MBServerStatics;
 import engine.util.Hasher;
 import org.pmw.tinylog.Logger;
@@ -26,28 +27,14 @@ import java.util.concurrent.ConcurrentHashMap;
 public enum DbManager {
 	DBMANAGER;
 
-	private static ConnectionPool connPool;
+	private static HikariDataSource connectionPool = null;
+
 	public static Hasher hasher;
 
 	//Local Object Caching
 
 	private static final EnumMap<GameObjectType, ConcurrentHashMap<Integer, AbstractGameObject>> objectCache = new EnumMap<>(GameObjectType.class);
 
-	public static boolean configureDatabaseLayer() {
-
-		boolean worked = true;
-
-		try {
-			DbManager.connPool = new ConnectionPool();
-			DbManager.connPool.fill(10);
-			DBMANAGER.hasher = new Hasher();
-		} catch (Exception e ) {
-			e.printStackTrace();
-			worked = false;
-		}
-		return worked;
-	}
-
 	public static AbstractGameObject getObject(GameObjectType objectType, int objectUUID) {
 
 		AbstractGameObject outObject = null;
@@ -87,9 +74,6 @@ public enum DbManager {
 		return outObject;
 	}
 
-	public static int getPoolSize(){
-		return connPool.getPoolSize();
-	}
 
 	public static boolean inCache(GameObjectType gameObjectType, int uuid) {
 
@@ -227,7 +211,7 @@ public enum DbManager {
 	}
 
 	public static PreparedStatement prepareStatement(String sql) throws SQLException {
-		return getConn().prepareStatement(sql, 1);
+		return getConnection().prepareStatement(sql, 1);
 	}
 
 	// Omg refactor this out, somebody!
@@ -259,15 +243,12 @@ public enum DbManager {
 	 * @return the conn
 	 */
 	//XXX I think we have a severe resource leak here! No one is putting the connections back!
-	public static Connection getConn() {
-		Connection conn = DbManager.connPool.get();
+	public static Connection getConnection() {
 		try {
-			if (!conn.isClosed())
-				DbManager.connPool.put(conn);
+			return DbManager.connectionPool.getConnection();
 		} catch (SQLException e) {
-			Logger.error( e.toString());
+			throw new RuntimeException(e);
 		}
-		return conn;
 	}
 
 	public static final dbAccountHandler AccountQueries = new dbAccountHandler();
@@ -312,4 +293,36 @@ public enum DbManager {
 	public static final dbHeightMapHandler HeightMapQueries = new dbHeightMapHandler();
 
 	public static final dbRunegateHandler RunegateQueries = new dbRunegateHandler();
+
+	public static void configureConnectionPool() {
+
+		HikariConfig config = new HikariConfig();
+
+		int connectionCount = (Runtime.getRuntime().availableProcessors() * 2) + 1;
+		config.setMaximumPoolSize(connectionCount);
+
+		config.setJdbcUrl("jdbc:mysql://" + ConfigManager.MB_DATABASE_ADDRESS.getValue() +
+				":" + ConfigManager.MB_DATABASE_PORT.getValue() + "/" +
+				ConfigManager.MB_DATABASE_NAME.getValue());
+		config.setUsername(ConfigManager.MB_DATABASE_USER.getValue());
+		config.setPassword(ConfigManager.MB_DATABASE_PASS.getValue());
+
+		// Must be set lower than SQL server connection lifetime!
+
+		config.addDataSourceProperty("maxLifetime", "3600000");
+
+		config.addDataSourceProperty("characterEncoding", "utf8");
+
+		config.addDataSourceProperty("useServerPrepStmts", "true");
+		config.addDataSourceProperty("cachePrepStmts", "true");
+		config.addDataSourceProperty("prepStmtCacheSize", "500");
+		config.addDataSourceProperty("prepStmtCacheSqlLimit", "2048");
+
+		config.addDataSourceProperty("leakDetectionThreshold", "5000");
+		config.addDataSourceProperty("cacheServerConfiguration", "true");
+
+		connectionPool = new HikariDataSource(config); // setup the connection pool
+
+		Logger.info("Database configured with " + connectionCount + " connections");
+	}
 }

src/engine/gameManager/DevCmdManager.java

@@ -93,7 +93,6 @@ public enum DevCmdManager {
 		DevCmdManager.registerDevCmd(new GetBankCmd());
 		DevCmdManager.registerDevCmd(new GetVaultCmd());
 		DevCmdManager.registerDevCmd(new CombatMessageCmd());
-		DevCmdManager.registerDevCmd(new RenameMobCmd());
 		DevCmdManager.registerDevCmd(new RenameCmd());
 		DevCmdManager.registerDevCmd(new CreateItemCmd());
 		DevCmdManager.registerDevCmd(new GetMemoryCmd());
@@ -112,7 +111,6 @@ public enum DevCmdManager {
 		DevCmdManager.registerDevCmd(new DecachePlayerCmd());
 		DevCmdManager.registerDevCmd(new AuditMobsCmd());
 		DevCmdManager.registerDevCmd(new ChangeNameCmd());
-		DevCmdManager.registerDevCmd(new GuildListCmd());
 		DevCmdManager.registerDevCmd(new SetGuildCmd());
 		DevCmdManager.registerDevCmd(new SetOwnerCmd());
 		DevCmdManager.registerDevCmd(new NetDebugCmd());

src/engine/gameManager/PowersManager.java

@@ -11,6 +11,8 @@ package engine.gameManager;
 import engine.Enum.*;
 import engine.InterestManagement.HeightMap;
 import engine.InterestManagement.WorldGrid;
+import engine.db.handlers.dbEffectsBaseHandler;
+import engine.db.handlers.dbSkillReqHandler;
 import engine.job.AbstractJob;
 import engine.job.AbstractScheduleJob;
 import engine.job.JobContainer;
@@ -99,7 +101,7 @@ public enum PowersManager {
 	public static void InitializeLoginPowers() {
 
 		// get all PowersBase
-		ArrayList<PowersBase> pbList = PowersBase.getAllPowersBase();
+		ArrayList<PowersBase> pbList = dbSkillReqHandler.getAllPowersBase();
 
 		for (PowersBase pb : pbList) {
 			if (pb.getToken() != 0)
@@ -111,7 +113,7 @@ public enum PowersManager {
 	public static void InitializePowers() {
 
 		// Add EffectsBase
-		ArrayList<EffectsBase> ebList = EffectsBase.getAllEffectsBase();
+		ArrayList<EffectsBase> ebList = dbEffectsBaseHandler.getAllEffectsBase();
 
 		for (EffectsBase eb : ebList) {
 			PowersManager.effectsBaseByToken.put(eb.getToken(), eb);
@@ -123,7 +125,7 @@ public enum PowersManager {
 		EffectsBase.getFailConditions(PowersManager.effectsBaseByIDString);
 
 		// Add Modifiers to Effects
-		AbstractEffectModifier.getAllEffectModifiers();
+		dbEffectsBaseHandler.cacheAllEffectModifiers();
 
 		// Add Source Types to Effects
 		PowersManager.addAllSourceTypes();
@@ -136,7 +138,7 @@ public enum PowersManager {
 	//	AbstractPowerAction.loadValidItemFlags(PowersManager.powerActionsByIDString);
 
 		// get all PowersBase
-		ArrayList<PowersBase> pbList = PowersBase.getAllPowersBase();
+		ArrayList<PowersBase> pbList = dbSkillReqHandler.getAllPowersBase();
 		for (PowersBase pb : pbList) {
 			if (pb.getToken() != 0) {
 				PowersManager.powersBaseByIDString.put(pb.getIDString(), pb);
@@ -147,7 +149,7 @@ public enum PowersManager {
 		// Add Power Prereqs
 		PowerPrereq.getAllPowerPrereqs(PowersManager.powersBaseByIDString);
 		// Add Fail Conditions
-		PowersBase.getFailConditions(PowersManager.powersBaseByIDString);
+		dbSkillReqHandler.getFailConditions(PowersManager.powersBaseByIDString);
 		// Add Actions Base
 		ActionsBase.getActionsBase(PowersManager.powersBaseByIDString,
 				PowersManager.powerActionsByIDString);

src/engine/gameManager/SimulationManager.java

@@ -16,6 +16,10 @@ import engine.objects.PlayerCharacter;
 import engine.objects.Runegate;
 import org.pmw.tinylog.Logger;
 
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
 import java.time.Duration;
 import java.time.Instant;
 import java.util.Collection;
@@ -40,7 +44,7 @@ public enum SimulationManager {
 			+ RUNEGATE_PULSE;
 	private long _updatePulseTime = System.currentTimeMillis() + UPDATE_PULSE;
 	private long _flightPulseTime = System.currentTimeMillis() + FlIGHT_PULSE;
-	
+
 	public static Duration executionTime = Duration.ofNanos(1);
 	public static Duration executionMax = Duration.ofNanos(1);
 
@@ -49,15 +53,26 @@ public enum SimulationManager {
 		// don't allow instantiation.
 	}
 
-    public static String getPopulationString() {
-        String outString;
-        String newLine = System.getProperty("line.separator");
-        outString = "[LUA_POPULATION()]" + newLine;
-        outString += DbManager.CSSessionQueries.GET_POPULATION_STRING();
-        return outString;
-    }
+	public static String getPopulationString() {
 
-    /*
+		String popString = "";
+
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement getPopString = connection.prepareStatement("CALL GET_POPULATION_STRING()");) {
+
+			ResultSet rs = getPopString.executeQuery();
+
+			if (rs.next())
+				popString = rs.getString("popstring");
+
+		} catch (SQLException e) {
+			Logger.error(e.toString());
+		}
+
+		return popString;
+	}
+
+	/*
 	 * Update the simulation. *** Important: Whatever you do in here, do it damn
 	 * quick!
 	 */

src/engine/gameManager/ZoneManager.java

@@ -9,6 +9,8 @@
 package engine.gameManager;
 
 import engine.Enum;
+import engine.db.archive.CityRecord;
+import engine.db.archive.DataWarehouse;
 import engine.math.Bounds;
 import engine.math.Vector2f;
 import engine.math.Vector3f;
@@ -22,10 +24,7 @@ import org.pmw.tinylog.Logger;
 import java.time.Instant;
 import java.time.LocalDateTime;
 import java.time.ZoneId;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Set;
+import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ThreadLocalRandom;
 
@@ -37,17 +36,18 @@ public enum ZoneManager {
 
     ZONEMANAGER;
 
-    public static Instant hotZoneLastUpdate;
-    /* Instance variables */
-    private static Zone seaFloor = null;
-    public static Zone hotZone = null;
-    public static int hotZoneCycle = 0;  // Used with HOTZONE_DURATION from config.
+    public static final Set<Zone> macroZones = Collections.newSetFromMap(new ConcurrentHashMap<>());
     private static final ConcurrentHashMap<Integer, Zone> zonesByID = new ConcurrentHashMap<>(MBServerStatics.CHM_INIT_CAP, MBServerStatics.CHM_LOAD);
     private static final ConcurrentHashMap<Integer, Zone> zonesByUUID = new ConcurrentHashMap<>(MBServerStatics.CHM_INIT_CAP, MBServerStatics.CHM_LOAD);
     private static final ConcurrentHashMap<String, Zone> zonesByName = new ConcurrentHashMap<>(MBServerStatics.CHM_INIT_CAP, MBServerStatics.CHM_LOAD);
-    public static final Set<Zone> macroZones = Collections.newSetFromMap(new ConcurrentHashMap<>());
     private static final Set<Zone> npcCityZones = Collections.newSetFromMap(new ConcurrentHashMap<>());
     private static final Set<Zone> playerCityZones = Collections.newSetFromMap(new ConcurrentHashMap<>());
+    public static Instant hotZoneLastUpdate;
+    public static Zone hotZone = null;
+    public static int hotZoneCycle = 0;  // Used with HOTZONE_DURATION from config.
+    public static HashMap<Integer, Vector2f> _zone_size_data = new HashMap<>();
+    /* Instance variables */
+    private static Zone seaFloor = null;
 
     // Find all zones coordinates fit into, starting with Sea Floor
 
@@ -168,14 +168,14 @@ public enum ZoneManager {
         return (Bounds.collide(loc, ZoneManager.hotZone.getBounds()) == true);
     }
 
-    public static void setSeaFloor(final Zone value) {
-        ZoneManager.seaFloor = value;
-    }
-
     public static Zone getSeaFloor() {
         return ZoneManager.seaFloor;
     }
 
+    public static void setSeaFloor(final Zone value) {
+        ZoneManager.seaFloor = value;
+    }
+
     public static final void populateWorldZones(final Zone zone) {
 
         int loadNum = zone.getLoadNum();
@@ -423,4 +423,31 @@ public enum ZoneManager {
         treeBounds.release();
         return validLocation;
     }
+
+    public static void loadCities(Zone zone) {
+
+        ArrayList<City> cities = DbManager.CityQueries.GET_CITIES_BY_ZONE(zone.getObjectUUID());
+
+        for (City city : cities) {
+
+            city.setParent(zone);
+            city.setObjectTypeMask(MBServerStatics.MASK_CITY);
+            city.setLoc(city.getLoc()); // huh?
+
+//not player city, must be npc city..
+
+            if (!zone.isPlayerCity())
+                zone.setNPCCity(true);
+
+            if ((ConfigManager.serverType.equals(Enum.ServerType.WORLDSERVER)) && (city.getHash() == null)) {
+
+                city.setHash();
+
+                if (DataWarehouse.recordExists(Enum.DataRecordType.CITY, city.getObjectUUID()) == false) {
+                    CityRecord cityRecord = CityRecord.borrow(city, Enum.RecordEventType.CREATE);
+                    DataWarehouse.pushToWarehouse(cityRecord);
+                }
+            }
+        }
+    }
 }

src/engine/objects/Boon.java

@@ -55,7 +55,7 @@ public class Boon  {
 	
 	public static void HandleBoonListsForItemBase(int itemBaseID){
 		ArrayList<Boon> boons = null;
-		boons = DbManager.BoonQueries.GET_BOON_AMOUNTS_FOR_ITEMBASEUUID(itemBaseID);
+		boons = DbManager.BoonQueries.GET_BOON_AMOUNTS_FOR_ITEMBASE(itemBaseID);
 		if (boons != null)
 			GetBoonsForItemBase.put(itemBaseID, boons);
 	}

src/engine/objects/City.java

@@ -34,7 +34,6 @@ import engine.workthreads.DestroyCityThread;
 import engine.workthreads.TransferCityThread;
 import org.pmw.tinylog.Logger;
 
-import java.net.UnknownHostException;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.time.LocalDateTime;
@@ -87,7 +86,7 @@ public class City extends AbstractWorldObject {
 
 	// Players who have entered the city (used for adding and removing affects)
 
-	private final HashSet<Integer> _playerMemory = new HashSet<>();
+	public final HashSet<Integer> _playerMemory = new HashSet<>();
 
 	public volatile boolean protectionEnforced = true;
 	private String hash;
@@ -98,9 +97,9 @@ public class City extends AbstractWorldObject {
 	 * ResultSet Constructor
 	 */
 
-	public City(ResultSet rs) throws SQLException, UnknownHostException {
+	public City(ResultSet rs) throws SQLException {
 		super(rs);
-		try{
+		try {
 			this.cityName = rs.getString("name");
 			this.motto = rs.getString("motto");
 			this.isNpc = rs.getByte("isNpc");
@@ -746,33 +745,6 @@ public class City extends AbstractWorldObject {
 		return open;
 	}
 
-	public static void loadCities(Zone zone) {
-
-		ArrayList<City> cities = DbManager.CityQueries.GET_CITIES_BY_ZONE(zone.getObjectUUID());
-
-		for (City city : cities) {
-
-			city.setParent(zone);
-			city.setObjectTypeMask(MBServerStatics.MASK_CITY);
-            city.setLoc(city.location);
-            
-            //not player city, must be npc city..
-            if (!zone.isPlayerCity())
-            	zone.setNPCCity(true);
-            
-			if ((ConfigManager.serverType.equals(ServerType.WORLDSERVER)) && (city.hash == null)) {
-
-				city.setHash();
-
-				if (DataWarehouse.recordExists(Enum.DataRecordType.CITY, city.getObjectUUID()) == false) {
-					CityRecord cityRecord = CityRecord.borrow(city, Enum.RecordEventType.CREATE);
-					DataWarehouse.pushToWarehouse(cityRecord);
-				}
-			}
-		}
-	}
-
-
 
 	@Override
 	public void updateDatabase() {

src/engine/objects/Contract.java

@@ -138,8 +138,8 @@ public class Contract extends AbstractGameObject {
 
 	 //Specify if trainer, merchant, banker, etc via classID
 	 private void setBools() {
-		 DbManager.ContractQueries.GET_GENERIC_INVENTORY(this);
-		 DbManager.ContractQueries.GET_SELL_LISTS(this);
+		 DbManager.ContractQueries.LOAD_CONTRACT_INVENTORY(this);
+		 DbManager.ContractQueries.LOAD_SELL_LIST_FOR_CONTRACT(this);
 
 		 this.isTrainer = this.classID > 2499 && this.classID < 3050 || this.classID == 2028;
 

src/engine/objects/Item.java

@@ -210,14 +210,20 @@ public class Item extends AbstractWorldObject {
 		this.durabilityCurrent = rs.getShort("item_durabilityCurrent");
 		this.durabilityMax = rs.getShort("item_durabilityMax");
 
-		String ot = DbManager.ItemQueries.GET_OWNER(this.ownerID);
+		DbObjectType ownerType;
+		ownerType = DbManager.BuildingQueries.GET_UID_ENUM(this.ownerID);
 
-		if (ot.equals("character"))
-			this.ownerType = OwnerType.PlayerCharacter;
-		else if (ot.equals("npc"))
-			this.ownerType = OwnerType.Npc;
-		else if (ot.equals("account"))
-			this.ownerType = OwnerType.Account;
+		switch (ownerType) {
+			case CHARACTER:
+				this.ownerType = OwnerType.PlayerCharacter;
+				break;
+			case NPC:
+				this.ownerType = OwnerType.Npc;
+				break;
+			case ACCOUNT:
+				this.ownerType = OwnerType.Account;
+				break;
+		}
 
 		this.canDestroy = true;
 
@@ -1062,7 +1068,6 @@ public float getBonusPercent(ModType modType, SourceType sourceType) {
 			this.magicValue =  this.getItemBase().getBaseValue() + calcMagicValue();
 			return;
 		}
-		
 
 		ConcurrentHashMap<String, Integer> enchantList = DbManager.EnchantmentQueries.GET_ENCHANTMENTS_FOR_ITEM(this.getObjectUUID());
 

src/engine/objects/Mob.java

@@ -99,6 +99,7 @@ public class Mob extends AbstractIntelligenceAgent {
     private DeferredPowerJob weaponPower;
     private DateTime upgradeDateTime = null;
     private boolean lootSync = false;
+    public City guardedCity;
 
     /**
      * No Id Constructor
@@ -806,6 +807,7 @@ public class Mob extends AbstractIntelligenceAgent {
         mob.npcOwner = guardCaptain;
         mob.spawnTime = (int)(-2.500 * guardCaptain.building.getRank() + 22.5) * 60;
         mob.BehaviourType = Enum.MobBehaviourType.GuardMinion;
+        mob.guardedCity = guardCaptain.guardedCity;
         mob.parentZone = parent;
         parent.zoneMobSet.add(mob);
         return mob;
@@ -1990,6 +1992,7 @@ public class Mob extends AbstractIntelligenceAgent {
                 else {
                     this.BehaviourType = MobBehaviourType.GuardCaptain;
                     this.spawnTime = 900;
+                    this.guardedCity = ZoneManager.getCityAtLocation(this.bindLoc);
                 }
 
             this.deathTime = 0;

src/engine/objects/MobBase.java

@@ -206,20 +206,8 @@ public class MobBase extends AbstractGameObject {
 		return this.spawnTime;
 	}
 
-	/*
-	 * Database
-	 */
 	public static MobBase getMobBase(int id) {
-		return MobBase.getMobBase(id, false);
-	}
-
-	public static MobBase getMobBase(int id, boolean forceDB) {
-		return DbManager.MobBaseQueries.GET_MOBBASE(id, forceDB);
-	}
-
-
-	public static boolean renameMobBase(int ID, String newName) {
-		return DbManager.MobBaseQueries.RENAME_MOBBASE(ID, newName);
+		return DbManager.MobBaseQueries.GET_MOBBASE(id);
 	}
 
 	@Override

src/engine/objects/Realm.java

@@ -22,7 +22,6 @@ import engine.server.MBServerStatics;
 import org.pmw.tinylog.Logger;
 
 import java.awt.*;
-import java.net.UnknownHostException;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.time.LocalDateTime;
@@ -72,7 +71,7 @@ public class Realm {
 	/**
 	 * ResultSet Constructor
 	 */
-	public Realm(ResultSet rs) throws SQLException, UnknownHostException {
+	public Realm(ResultSet rs) throws SQLException {
 
 		this.mapColor = new Color(Integer.parseInt(rs.getString("realmColor"), 16));
 		this.mapR = (float) (mapColor.getRed() * 0.00392156863);

src/engine/objects/Zone.java

@@ -30,19 +30,25 @@ import java.util.concurrent.ConcurrentHashMap;
 
 public class Zone extends AbstractGameObject {
 
+	public final Set<Building> zoneBuildingSet = Collections.newSetFromMap(new ConcurrentHashMap<>());
+	public final Set<NPC> zoneNPCSet = Collections.newSetFromMap(new ConcurrentHashMap<>());
+	public final Set<Mob> zoneMobSet = Collections.newSetFromMap(new ConcurrentHashMap<>());
 	private final int playerCityID;
 	private final String zoneName;
 	private final float xCoord;
 	private final float zCoord;
 	private final float yCoord;
-	public float absX = 0.0f;
-	public float absY = 0.0f;
-	public float absZ = 0.0f;
 	private final int loadNum;
 	private final byte safeZone;
 	private final String Icon1;
 	private final String Icon2;
 	private final String Icon3;
+	public float absX = 0.0f;
+	public float absY = 0.0f;
+	public float absZ = 0.0f;
+	public int minLvl;
+	public int maxLvl;
+	public boolean hasBeenHotzone = false;
 	private ArrayList<Zone> nodes = null;
 	private int parentZoneID;
 	private Zone parent = null;
@@ -50,16 +56,9 @@ public class Zone extends AbstractGameObject {
 	private boolean isNPCCity = false;
 	private boolean isPlayerCity = false;
 	private String hash;
-	public int minLvl;
-	public int maxLvl;
-
 	private float worldAltitude = 0;
-
 	private float seaLevel = 0;
-	public final Set<Building> zoneBuildingSet = Collections.newSetFromMap(new ConcurrentHashMap<>());
-	public final Set<NPC> zoneNPCSet = Collections.newSetFromMap(new ConcurrentHashMap<>());
-	public final Set<Mob> zoneMobSet = Collections.newSetFromMap(new ConcurrentHashMap<>());
-	public boolean hasBeenHotzone = false;
+
 	/**
 	 * ResultSet Constructor
 	 */
@@ -87,7 +86,7 @@ public class Zone extends AbstractGameObject {
 
 		this.setParent(parentZone);
 
-		if (this.minLvl == 0 && parentZone != null){
+		if (this.minLvl == 0 && parentZone != null) {
 			this.minLvl = parentZone.minLvl;
 			this.maxLvl = parentZone.maxLvl;
 		}
@@ -99,8 +98,61 @@ public class Zone extends AbstractGameObject {
 
 		if (hash == null)
 			setHash();
-		
 
+
+	}
+
+	public static void serializeForClientMsg(Zone zone, ByteBufferWriter writer) {
+
+		if (zone.loadNum == 0 && zone.playerCityID == 0)
+			Logger.warn("Warning! WorldServerMap with ID " + zone.getObjectUUID() + " has a loadnum of 0 (player city) and no city linked. This will probably crash the client!");
+
+		// Player City Terraform values serialized here.
+
+		if (zone.playerCityID > 0) {
+			writer.put((byte) 1); // Player City - True
+			writer.putFloat(Enum.CityBoundsType.ZONE.extents);
+			writer.putFloat(Enum.CityBoundsType.ZONE.extents);
+		} else
+			writer.put((byte) 0); // Player City - False
+
+		writer.putFloat(zone.xCoord);
+		writer.putFloat(zone.zCoord);
+		writer.putFloat(zone.yCoord);
+
+		writer.putInt(0);
+		writer.putInt(0);
+		writer.putInt(zone.loadNum);
+
+		if (zone.playerCityID > 0) {
+			City k = City.getCity(zone.playerCityID);
+
+			if (k != null) {
+				writer.putInt(k.getObjectType().ordinal());
+				writer.putInt(k.getObjectUUID());
+			} else
+				writer.putLong(0x0);
+		} else {
+			writer.putInt(zone.getObjectType().ordinal());
+			writer.putInt(zone.getObjectUUID());
+		}
+		writer.putInt(zone.nodes.size());
+
+		City city = City.getCity(zone.playerCityID);
+
+		if (city != null)
+			writer.putString(city.getCityName());
+		else
+			writer.putString(zone.zoneName);
+		writer.put(zone.safeZone);
+		writer.putString(zone.Icon1);
+		writer.putString(zone.Icon2);
+		writer.putString(zone.Icon3);
+		writer.put((byte) 0); // Pad
+
+		for (Zone child : zone.nodes) {
+			Zone.serializeForClientMsg(child, writer);
+		}
 	}
 
 	/* Method sets a default value for player cities
@@ -123,38 +175,18 @@ public class Zone extends AbstractGameObject {
 			return;
 		}
 
-		// All other zones have bounding boxes loaded from database
-		ResultSet rs = DbManager.ZoneQueries.GET_ZONE_EXTENTS(this.loadNum);
-		boolean loaded = false;
+		Vector2f zoneSize = ZoneManager._zone_size_data.get(this.loadNum);
 
-		if (rs != null)
-			try {
-				if (rs.next()) {
-					halfExtentX = rs.getFloat("xRadius");
-					halfExtentY = rs.getFloat("zRadius");
-					this.bounds.setBounds(new Vector2f(this.absX, this.absZ), new Vector2f(halfExtentX, halfExtentY), 0.0f);
-					loaded = true;
-				}
-
-			} catch (SQLException e) {
-				Logger.error("SQLException: " + e.getMessage());
-			}
-
-		if (!loaded) {
-
-			// Default to Citygrid size on error
+		// Default to player zone size on error? Maybe log this
 
+		if (zoneSize != null)
+			this.bounds.setBounds(new Vector2f(this.absX, this.absZ), zoneSize, 0.0f);
+		else
 			bounds.setBounds(new Vector2f(this.absX, this.absZ), new Vector2f(Enum.CityBoundsType.ZONE.extents, Enum.CityBoundsType.ZONE.extents), 0.0f);
-		}
 
 	}
 
-	/*
-	 * Getters
-	 */
 	public int getPlayerCityUUID() {
-		if (this.playerCityID == 0)
-			return 0;
 		return this.playerCityID;
 	}
 
@@ -178,10 +210,6 @@ public class Zone extends AbstractGameObject {
 		return loadNum;
 	}
 
-	public int getLoadNumClient() {
-		return loadNum;
-	}
-
 	public byte getSafeZone() {
 		return safeZone;
 	}
@@ -190,45 +218,9 @@ public class Zone extends AbstractGameObject {
 		return Icon1;
 	}
 
-	public String getIcon2() {
-		return Icon2;
-	}
+	public void generateWorldAltitude() {
 
-	public String getIcon3() {
-		return Icon3;
-	}
-
-	public void setParent(final Zone value) {
-
-		this.parent = value;
-		this.parentZoneID = (this.parent != null) ? this.parent.getObjectUUID() : 0;
-
-		if (this.parent != null) {
-			this.absX = this.xCoord + parent.absX;
-			this.absY = this.yCoord + parent.absY;
-			this.absZ = this.zCoord + parent.absZ;
-
-			if (this.minLvl == 0 || this.maxLvl == 0){
-				this.minLvl = this.parent.minLvl;
-				this.maxLvl = this.parent.maxLvl;
-			}
-		} else {  //only the Sea Floor zone does not have a parent
-			this.absX = this.xCoord;
-			this.absY = MBServerStatics.SEA_FLOOR_ALTITUDE;
-			this.absZ = this.zCoord;
-		}
-
-		// Zone AABB is set here as it's coordinate space is world requiring a parent.
-		this.setBounds();
-
-		if (this.getHeightMap() != null && this.getHeightMap().getSeaLevel() != 0)
-			this.seaLevel = this.getHeightMap().getSeaLevel();
-
-	}
-
-	public void generateWorldAltitude(){
-
-		if (ZoneManager.getSeaFloor().getObjectUUID() == this.getObjectUUID()){
+		if (ZoneManager.getSeaFloor().getObjectUUID() == this.getObjectUUID()) {
 			this.worldAltitude = MBServerStatics.SEA_FLOOR_ALTITUDE;
 			return;
 		}
@@ -240,9 +232,9 @@ public class Zone extends AbstractGameObject {
 
 		//seafloor only zone with null parent;
 
-		while(parentZone != ZoneManager.getSeaFloor()){
+		while (parentZone != ZoneManager.getSeaFloor()) {
 
-			if(parentZone.getHeightMap() != null){
+			if (parentZone.getHeightMap() != null) {
 
 				Vector2f zoneLoc = ZoneManager.worldToZoneSpace(currentZone.getLoc(), parentZone);
 				altitude += parentZone.getHeightMap().getInterpolatedTerrainHeight(zoneLoc);
@@ -258,14 +250,14 @@ public class Zone extends AbstractGameObject {
 		if (ZoneManager.getSeaFloor().equals(this))
 			this.seaLevel = 0;
 		else if
-		(this.getHeightMap() != null && this.getHeightMap().getSeaLevel() == 0){
-            this.seaLevel = this.parent.seaLevel;
+		(this.getHeightMap() != null && this.getHeightMap().getSeaLevel() == 0) {
+			this.seaLevel = this.parent.seaLevel;
 
-		}else if (this.getHeightMap() != null){
+		} else if (this.getHeightMap() != null) {
 			this.seaLevel = this.worldAltitude + this.getHeightMap().getSeaLevel();
-		}else {
-            this.seaLevel = this.parent.seaLevel;
-        }
+		} else {
+			this.seaLevel = this.parent.seaLevel;
+		}
 
 	}
 
@@ -273,6 +265,34 @@ public class Zone extends AbstractGameObject {
 		return this.parent;
 	}
 
+	public void setParent(final Zone value) {
+
+		this.parent = value;
+		this.parentZoneID = (this.parent != null) ? this.parent.getObjectUUID() : 0;
+
+		if (this.parent != null) {
+			this.absX = this.xCoord + parent.absX;
+			this.absY = this.yCoord + parent.absY;
+			this.absZ = this.zCoord + parent.absZ;
+
+			if (this.minLvl == 0 || this.maxLvl == 0) {
+				this.minLvl = this.parent.minLvl;
+				this.maxLvl = this.parent.maxLvl;
+			}
+		} else {  //only the Sea Floor zone does not have a parent
+			this.absX = this.xCoord;
+			this.absY = MBServerStatics.SEA_FLOOR_ALTITUDE;
+			this.absZ = this.zCoord;
+		}
+
+		// Zone AABB is set here as it's coordinate space is world requiring a parent.
+		this.setBounds();
+
+		if (this.getHeightMap() != null && this.getHeightMap().getSeaLevel() != 0)
+			this.seaLevel = this.getHeightMap().getSeaLevel();
+
+	}
+
 	public float getAbsX() {
 		return this.absX;
 	}
@@ -302,14 +322,14 @@ public class Zone extends AbstractGameObject {
 		return this.isNPCCity;
 	}
 
-	public boolean isPlayerCity() {
-		return this.isPlayerCity;
-	}
-
 	public void setNPCCity(boolean value) {
 		this.isNPCCity = value;
 	}
 
+	public boolean isPlayerCity() {
+		return this.isPlayerCity;
+	}
+
 	public void setPlayerCity(boolean value) {
 		this.isPlayerCity = value;
 	}
@@ -336,71 +356,12 @@ public class Zone extends AbstractGameObject {
 		return nodes;
 	}
 
-	public void addNode(Zone child) {
-		this.nodes.add(child);
-	}
-
-	public void removeNode(Zone child) {
-		this.nodes.remove(child);
-	}
-
 	/*
 	 * Serializing
 	 */
 
-	
-	public static void serializeForClientMsg(Zone zone,ByteBufferWriter writer) {
-
-		if (zone.loadNum == 0 && zone.playerCityID == 0)
-			Logger.warn( "Warning! WorldServerMap with ID " + zone.getObjectUUID() + " has a loadnum of 0 (player city) and no city linked. This will probably crash the client!");
-
-		// Player City Terraform values serialized here.
-
-		if (zone.playerCityID > 0) {
-			writer.put((byte) 1); // Player City - True
-			writer.putFloat(Enum.CityBoundsType.ZONE.extents);
-			writer.putFloat(Enum.CityBoundsType.ZONE.extents);
-		} else
-			writer.put((byte) 0); // Player City - False
-
-		writer.putFloat(zone.xCoord);
-		writer.putFloat(zone.zCoord);
-		writer.putFloat(zone.yCoord);
-
-		writer.putInt(0);
-		writer.putInt(0);
-		writer.putInt(zone.loadNum);
-
-		if (zone.playerCityID > 0) {
-			City k = City.getCity(zone.playerCityID);
-
-			if (k != null) {
-				writer.putInt(k.getObjectType().ordinal());
-				writer.putInt(k.getObjectUUID());
-			}
-			else
-				writer.putLong(0x0);
-		} else {
-			writer.putInt(zone.getObjectType().ordinal());
-			writer.putInt(zone.getObjectUUID());
-		}
-		writer.putInt(zone.nodes.size());
-
-		City city = City.getCity(zone.playerCityID);
-
-		if (city != null)
-			writer.putString(city.getCityName());
-		else
-			writer.putString(zone.zoneName);
-		writer.put(zone.safeZone);
-		writer.putString(zone.Icon1);
-		writer.putString(zone.Icon2);
-		writer.putString(zone.Icon3);
-		writer.put((byte) 0); // Pad
-
-		for (Zone child : zone.nodes) {
-			Zone.serializeForClientMsg(child,writer);
-		}
+	public void addNode(Zone child) {
+		this.nodes.add(child);
 	}
 
 	@Override
@@ -408,60 +369,6 @@ public class Zone extends AbstractGameObject {
 		// TODO Auto-generated method stub
 	}
 
-	public Zone findRuinedCityZone(float centerX, float centerY, float centerZ){
-		Bounds cityBounds;
-		cityBounds = Bounds.borrow();
-		Zone RuinedZone = null;
-		cityBounds.setBounds(new Vector2f(centerX, centerZ), new Vector2f(Enum.CityBoundsType.ZONE.extents, Enum.CityBoundsType.ZONE.extents), 0.0f);
-		Zone currentZone = ZoneManager.findSmallestZone(new Vector3fImmutable(centerX, centerY, centerZ));
-		if (currentZone != null)
-			if (this.getObjectUUID() == currentZone.getObjectUUID()){
-
-				if (currentZone.getPlayerCityUUID() != 0){
-					//null player city? skip..
-					if (City.GetCityFromCache(currentZone.getPlayerCityUUID()) == null)
-						RuinedZone = null;
-					else	//no tol? skip...
-						if (City.GetCityFromCache(currentZone.getPlayerCityUUID()).getTOL() == null)
-							RuinedZone = null;
-						else
-							if (City.GetCityFromCache(currentZone.getPlayerCityUUID()).getTOL().getRank() == -1)
-								RuinedZone = currentZone;
-					//Dead tree? skip.
-					cityBounds.release();
-					return RuinedZone;
-				}
-			}
-
-		for (Zone zone : this.getNodes()) {
-
-			if (zone == this)
-				continue;
-
-			if (zone.isContinent() && zone.getPlayerCityUUID() == 0)
-				continue;
-
-			if (zone.getPlayerCityUUID() != 0){
-				//null player city? skip..
-				if (City.GetCityFromCache(zone.getPlayerCityUUID()) == null)
-					continue;
-				//no tol? skip...
-				if (City.GetCityFromCache(zone.getPlayerCityUUID()).getTOL() == null)
-					continue;
-
-				//Dead tree? skip.
-				if (Bounds.collide(zone.bounds, cityBounds, 0.0f)){
-					if (City.GetCityFromCache(zone.getPlayerCityUUID()).getTOL().getRank() == -1){
-						RuinedZone = zone;
-						break;
-					}
-				}
-			}
-		}
-		cityBounds.release();
-		return RuinedZone;
-	}
-
 	public boolean isContinent() {
 
 		if (this.equals(ZoneManager.getSeaFloor()))
@@ -500,7 +407,7 @@ public class Zone extends AbstractGameObject {
 	// Return heightmap for this Zone.
 
 	public HeightMap getHeightMap() {
-		
+
 		if (this.isPlayerCity)
 			return HeightMap.PlayerCityHeightMap;
 

src/engine/powers/EffectsBase.java

@@ -182,98 +182,6 @@ public class EffectsBase {
 			this.isSuffix = true;
 		// getFailConditions();
 	}
-	
-	
-	public static EffectsBase createNoDbEffectsBase(EffectsBase copyEffect, int newToken, String IDString){
-		EffectsBase cachedEffectsBase = new EffectsBase(copyEffect,newToken,IDString);
-		
-		if (cachedEffectsBase == null)
-			return null;
-		
-		//add to Lists.
-		PowersManager.effectsBaseByIDString.put(cachedEffectsBase.IDString, cachedEffectsBase);
-		PowersManager.effectsBaseByToken.put(cachedEffectsBase.token, cachedEffectsBase);
-		
-		return cachedEffectsBase;
-	}
-
-
-
-	public static ArrayList<EffectsBase> getAllEffectsBase() {
-		PreparedStatementShared ps = null;
-		ArrayList<EffectsBase> out = new ArrayList<>();
-		try {
-			ps = new PreparedStatementShared("SELECT * FROM static_power_effectbase ORDER BY `IDString` DESC");
-			ResultSet rs = ps.executeQuery();
-			while (rs.next()) {
-				EffectsBase toAdd = new EffectsBase(rs);
-				out.add(toAdd);
-			}
-			rs.close();
-		} catch (Exception e) {
-			Logger.error(e);
-		} finally {
-			ps.release();
-		}
-		//testHash(out);
-		return out;
-	}
-	
-	public static ArrayList<EffectsBase> getAllLiveEffectsBase() {
-		PreparedStatementShared ps = null;
-		ArrayList<EffectsBase> out = new ArrayList<>();
-		try {
-			ps = new PreparedStatementShared("SELECT * FROM static_power_effectbase_24 ORDER BY `IDString` DESC");
-			ResultSet rs = ps.executeQuery();
-			while (rs.next()) {
-				EffectsBase toAdd = new EffectsBase(rs);
-				out.add(toAdd);
-			}
-			rs.close();
-		} catch (Exception e) {
-			Logger.error(e);
-		} finally {
-			ps.release();
-		}
-		//testHash(out);
-		return out;
-	}
-
-	//private static void testHash(ArrayList<EffectsBase> effs) {
-	//	int valid = 0, invalid = 0;
-	//	for (EffectsBase eff : effs) {
-	//		String ids = eff.getIDString();
-	//		int tok = eff.getToken();
-	//		if (ids.length() != 8 || ids.startsWith("PRE-") || ids.startsWith("SUF-") || ids.endsWith("X") || !ids.substring(3,4).equals("-"))
-	//			continue;
-	//
-	////		if ((tok > 1 || tok < 0) && ids.length() == 8) {
-	//			int out = Hash(ids);
-	//			if (out != tok) {
-	//				System.out.println(ids + ": " + Integer.toHexString(out) + "(" + out + ")");
-	//				invalid++;
-	//			} else
-	//				valid++;
-	////		}
-	//	}
-	//	System.out.println("valid: " + valid + ", invalid: " + invalid);
-	//}
-
-	//private static int Hash(String IDString) {
-	//	char[] val = IDString.toCharArray();
-	//	int out = 360;
-	//	out ^= val[0];
-	//	out ^= (val[1] << 5);
-	//	out ^= (val[2] << 10);
-	//	out ^= (val[4] << 23);
-	//	out ^= (val[5] << 19);
-	//	out ^= (val[6] << 15);
-	//	out ^= (val[7] << 26);
-	//	out ^= (val[7] >> 6);
-	//	out ^= 17;
-	//	return out;
-	//}
-
 
 	public static void getFailConditions(HashMap<String, EffectsBase> effects) {
 		PreparedStatementShared ps = null;

src/engine/powers/PowersBase.java

@@ -11,13 +11,11 @@ package engine.powers;
 
 import engine.Enum.PowerCategoryType;
 import engine.Enum.PowerTargetType;
-import engine.objects.PreparedStatementShared;
 import org.pmw.tinylog.Logger;
 
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.ArrayList;
-import java.util.HashMap;
 
 public class PowersBase {
 
@@ -340,57 +338,6 @@ public class PowersBase {
 			this.monsterTypeRestrictions.add(ct);
 	}
 
-	public static ArrayList<PowersBase> getAllPowersBase() {
-		PreparedStatementShared ps = null;
-		ArrayList<PowersBase> out = new ArrayList<>();
-		try {
-			ps = new PreparedStatementShared("SELECT * FROM static_power_powerbase");
-			ResultSet rs = ps.executeQuery();
-			while (rs.next()) {
-				PowersBase toAdd = new PowersBase(rs);
-				out.add(toAdd);
-			}
-			rs.close();
-		} catch (Exception e) {
-			Logger.error( e.toString());
-		} finally {
-			ps.release();
-		}
-		return out;
-	}
-	
-
-	public static void getFailConditions(HashMap<String, PowersBase> powers) {
-		PreparedStatementShared ps = null;
-		try {
-			ps = new PreparedStatementShared("SELECT IDString, type FROM static_power_failcondition where powerOrEffect = 'Power'");
-			ResultSet rs = ps.executeQuery();
-			String type, IDString; PowersBase pb;
-			while (rs.next()) {
-				type = rs.getString("type");
-				IDString = rs.getString("IDString");
-				pb = powers.get(IDString);
-				if (pb != null) {
-					switch (type) {
-					case "CastSpell":
-						pb.cancelOnCastSpell = true;
-						break;
-					case "TakeDamage":
-						pb.cancelOnTakeDamage = true;
-						break;
-					}
-				}else{
-					Logger.error("null power for Grief " + IDString);
-				}
-			}
-			rs.close();
-		} catch (Exception e) {
-			Logger.error( e.toString());
-		} finally {
-			ps.release();
-		}
-	}
-	
 
 	public String getName() {
 		return this.name;

src/engine/powers/effectmodifiers/AbstractEffectModifier.java

@@ -11,17 +11,15 @@ package engine.powers.effectmodifiers;
 
 import engine.Enum.ModType;
 import engine.Enum.SourceType;
-import engine.gameManager.DbManager;
-import engine.gameManager.PowersManager;
 import engine.jobs.AbstractEffectJob;
-import engine.objects.*;
+import engine.objects.AbstractCharacter;
+import engine.objects.AbstractWorldObject;
+import engine.objects.Building;
+import engine.objects.Item;
 import engine.powers.EffectsBase;
-import org.pmw.tinylog.Logger;
 
 import java.sql.ResultSet;
 import java.sql.SQLException;
-import java.util.ArrayList;
-import java.util.HashSet;
 
 
 public abstract class AbstractEffectModifier {
@@ -30,7 +28,7 @@ public abstract class AbstractEffectModifier {
 	protected int UUID;
 	protected String IDString;
 	protected String effectType;
-	protected float minMod;
+	public float minMod;
 	protected float maxMod;
 	protected float percentMod;
 	protected float ramp;
@@ -60,257 +58,6 @@ public abstract class AbstractEffectModifier {
 		this.string2 = rs.getString("string2");
 	}
 
-	public static ArrayList<AbstractEffectModifier> getAllEffectModifiers() {
-		PreparedStatementShared ps = null;
-		ArrayList<AbstractEffectModifier> out = new ArrayList<>();
-		try {
-			ps = new PreparedStatementShared("SELECT * FROM static_power_effectmod");
-			ResultSet rs = ps.executeQuery();
-		 String IDString;
-			AbstractEffectModifier aem = null;
-			while (rs.next()) {
-				IDString = rs.getString("IDString");
-				int token = DbManager.hasher.SBStringHash(IDString);
-
-				EffectsBase eb = PowersManager.getEffectByIDString(IDString);
-
-				ModType modifier = ModType.GetModType(rs.getString("modType"));
-
-				//combine item prefix and suffix effect modifiers
-				switch (modifier){
-				case AdjustAboveDmgCap:
-					aem = new AdjustAboveDmgCapEffectModifier(rs);
-					break;
-				case Ambidexterity:
-					aem = new AmbidexterityEffectModifier(rs);
-					break;
-				case AnimOverride:
-					break;
-				case ArmorPiercing:
-					aem = new ArmorPiercingEffectModifier(rs);
-					break;
-				case AttackDelay:
-					aem = new AttackDelayEffectModifier(rs);
-					break;
-				case Attr:
-					aem = new AttributeEffectModifier(rs);
-					break;
-				case BlackMantle:
-					aem = new BlackMantleEffectModifier(rs);
-					break;
-				case BladeTrails:
-					aem = new BladeTrailsEffectModifier(rs);
-  					break;
-				case Block:
-					aem = new BlockEffectModifier(rs);
-					break;
-				case BlockedPowerType:
-					aem = new BlockedPowerTypeEffectModifier(rs);
-					break;
-				case CannotAttack:
-					aem = new CannotAttackEffectModifier(rs);
-					break;
-				case CannotCast:
-					aem = new CannotCastEffectModifier(rs);
-					break;
-				case CannotMove:
-					aem = new CannotMoveEffectModifier(rs);
-					break;
-				case CannotTrack:
-					aem = new CannotTrackEffectModifier(rs);
-					break;
-				case Charmed:
-					aem = new CharmedEffectModifier(rs);
-					break;
-				case ConstrainedAmbidexterity:
-					aem = new ConstrainedAmbidexterityEffectModifier(rs);
-					break;
-				case DamageCap:
-					aem = new DamageCapEffectModifier(rs);
-					break;
-				case DamageShield:
-					aem = new DamageShieldEffectModifier(rs);
-					break;
-				case DCV:
-					aem = new DCVEffectModifier(rs);
-					break;
-				case Dodge:
-					aem = new DodgeEffectModifier(rs);
-					break;
-				case DR:
-					aem = new DREffectModifier(rs);
-					break;
-				case Durability:
-					aem = new DurabilityEffectModifier(rs);
-					break;
-				case ExclusiveDamageCap:
-					aem = new ExclusiveDamageCapEffectModifier(rs);
-					break;
-				case Fade:
-					aem = new FadeEffectModifier(rs);
-					break;
-				case Fly:
-					aem = new FlyEffectModifier(rs);
-					break;
-				case Health:
-					aem = new HealthEffectModifier(rs);
-					break;
-				case HealthFull:
-					aem = new HealthFullEffectModifier(rs);
-					break;
-				case HealthRecoverRate:
-					aem = new HealthRecoverRateEffectModifier(rs);
-					break;
-				case IgnoreDamageCap:
-					aem = new IgnoreDamageCapEffectModifier(rs);
-					break;
-				case IgnorePassiveDefense:
-					aem = new IgnorePassiveDefenseEffectModifier(rs);
-					break;
-				case ImmuneTo:
-					aem = new ImmuneToEffectModifier(rs);
-					break;
-				case ImmuneToAttack:
-					aem = new ImmuneToAttackEffectModifier(rs);
-					break;
-				case ImmuneToPowers:
-					aem = new ImmuneToPowersEffectModifier(rs);
-					break;
-				case Invisible:
-					aem = new InvisibleEffectModifier(rs);
-					break;
-				case ItemName:
-					aem = new ItemNameEffectModifier(rs);
-					if ((((ItemNameEffectModifier)aem).name.isEmpty()))
-							break;
-					if (eb != null)
-						eb.setName((((ItemNameEffectModifier)aem).name));
-					break;
-				case Mana:
-					aem = new ManaEffectModifier(rs);
-					break;
-				case ManaFull:
-					aem = new ManaFullEffectModifier(rs);
-					break;
-				case ManaRecoverRate:
-					aem = new ManaRecoverRateEffectModifier(rs);
-					break;
-				case MaxDamage:
-					aem = new MaxDamageEffectModifier(rs);
-					break;
-				case MeleeDamageModifier:
-					aem = new MeleeDamageEffectModifier(rs);
-					break;
-				case MinDamage:
-					aem = new MinDamageEffectModifier(rs);
-					break;
-				case NoMod:
-					aem = new NoModEffectModifier(rs);
-					break;
-				case OCV:
-					aem = new OCVEffectModifier(rs);
-					break;
-				case Parry:
-					aem = new ParryEffectModifier(rs);
-					break;
-				case PassiveDefense:
-					aem = new PassiveDefenseEffectModifier(rs);
-				case PowerCost:
-					aem = new PowerCostEffectModifier(rs);
-					break;
-				case PowerCostHealth:
-					aem = new PowerCostHealthEffectModifier(rs);
-					break;
-				case PowerDamageModifier:
-					aem = new PowerDamageEffectModifier(rs);
-					break;
-				case ProtectionFrom:
-					aem = new ProtectionFromEffectModifier(rs);
-					break;
-				case Resistance:
-					aem = new ResistanceEffectModifier(rs);
-					break;
-				case ScaleHeight:
-					aem = new ScaleHeightEffectModifier(rs);
-					break;
-				case ScaleWidth:
-					aem = new ScaleWidthEffectModifier(rs);
-					break;
-				case ScanRange:
-					aem = new ScanRangeEffectModifier(rs);
-					break;
-				case SeeInvisible:
-					aem = new SeeInvisibleEffectModifier(rs);
-					break;
-				case Silenced:
-					aem = new SilencedEffectModifier(rs);
-					break;
-				case Skill:
-					aem = new SkillEffectModifier(rs);
-					break;
-				case Slay:
-					aem = new SlayEffectModifier(rs);
-					break;
-				case Speed:
-					aem = new SpeedEffectModifier(rs);
-					break;
-				case SpireBlock:
-					aem = new SpireBlockEffectModifier(rs);
-					break;
-				case Stamina:
-					aem = new StaminaEffectModifier(rs);
-					break;
-				case StaminaFull:
-					aem = new StaminaFullEffectModifier(rs);
-					break;
-				case StaminaRecoverRate:
-					aem = new StaminaRecoverRateEffectModifier(rs);
-					break;
-				case Stunned:
-					aem = new StunnedEffectModifier(rs);
-					break;
-				case Value:
-					aem = new ValueEffectModifier(rs);
-					if (eb != null){
-						ValueEffectModifier valueEffect = (ValueEffectModifier)aem;
-						eb.setValue(valueEffect.minMod);
-					}
-					break;
-				case WeaponProc:
-					aem = new WeaponProcEffectModifier(rs);
-					break;
-				case WeaponRange:
-					aem = new WeaponRangeEffectModifier(rs);
-					break;
-				case WeaponSpeed:
-					aem = new WeaponSpeedEffectModifier(rs);
-					break;
-			
-			}
-
-			if (aem != null){
-			
-		
-				if (EffectsBase.modifiersMap.containsKey(eb.getIDString()) == false)
-					EffectsBase.modifiersMap.put(eb.getIDString(), new HashSet<>());
-				EffectsBase.modifiersMap.get(eb.getIDString()).add(aem);
-				
-			}
-			}
-			rs.close();
-		} catch (Exception e) {
-			Logger.error( e);
-		} finally {
-			ps.release();
-		}
-		return out;
-	}
-
-
-
-
-
-
 
 	public int getUUID() {
 		return this.UUID;

src/engine/powers/effectmodifiers/ItemNameEffectModifier.java

@@ -21,7 +21,7 @@ import java.sql.SQLException;
 
 public class ItemNameEffectModifier extends AbstractEffectModifier {
 
-	String name = "";
+	public String name = "";
 
 	public ItemNameEffectModifier(ResultSet rs) throws SQLException {
 		super(rs);

src/engine/server/login/LoginServer.java

@@ -9,8 +9,6 @@
 
 package engine.server.login;
 
-import com.zaxxer.hikari.HikariConfig;
-import com.zaxxer.hikari.HikariDataSource;
 import engine.Enum;
 import engine.gameManager.*;
 import engine.job.JobScheduler;
@@ -52,7 +50,6 @@ public class LoginServer {
     // Instance variables
 
     private VersionInfoMsg versionInfoMessage;
-    public static HikariDataSource connectionPool = null;
     public static int population = 0;
     public static boolean worldServerRunning = false;
     public static boolean loginServerRunning = false;
@@ -119,16 +116,20 @@ public class LoginServer {
             // Invalidate cache for players driven by forum
             // and stored procedure forum_link_pass()
 
-            try {
-
                 // Run cache routine right away if requested.
 
                 File cacheFile = new File("cacheInvalid");
 
 
                 if (cacheFile.exists() == true) {
+
                     nextCacheTime = LocalDateTime.now();
-                    Files.deleteIfExists(Paths.get("cacheInvalid"));
+
+                    try {
+                        Files.deleteIfExists(Paths.get("cacheInvalid"));
+                    } catch (IOException e) {
+                        throw new RuntimeException(e);
+                    }
                 }
 
                 if (LocalDateTime.now().isAfter(nextCacheTime)) {
@@ -148,10 +149,7 @@ public class LoginServer {
                 }
 
                 ThreadUtils.sleep(100);
-            } catch (Exception e) {
-                Logger.error(e);
-                e.printStackTrace();
-            }
+
         }
     }
 
@@ -172,9 +170,6 @@ public class LoginServer {
         this.versionInfoMessage = new VersionInfoMsg(ConfigManager.MB_MAJOR_VER.getValue(),
                 ConfigManager.MB_MINOR_VER.getValue());
 
-        Logger.info("Initializing Database Pool");
-        initDatabasePool();
-
         Logger.info("Initializing Database layer");
         initDatabaseLayer();
 
@@ -229,12 +224,12 @@ public class LoginServer {
         // Try starting a GOM <-> DB connection.
         try {
 
-            Logger.info("Configuring GameObjectManager to use Database: '"
+            Logger.info("Configuring Magicbane to use Database: '"
                     + ConfigManager.MB_DATABASE_NAME.getValue() + "' on "
                     + ConfigManager.MB_DATABASE_ADDRESS.getValue() + ':'
                     + ConfigManager.MB_DATABASE_PORT.getValue());
 
-            DbManager.configureDatabaseLayer();
+            DbManager.configureConnectionPool();
 
         } catch (Exception e) {
             Logger.error(e.getMessage());
@@ -365,33 +360,12 @@ public class LoginServer {
 
     }
 
-    private void initDatabasePool() {
-
-        HikariConfig config = new HikariConfig();
-
-        config.setMaximumPoolSize(33); // (16 cores 1 spindle)
-
-        config.setJdbcUrl("jdbc:mysql://" + ConfigManager.MB_DATABASE_ADDRESS.getValue() +
-                ":" + ConfigManager.MB_DATABASE_PORT.getValue() + "/" +
-                      ConfigManager.MB_DATABASE_NAME.getValue());
-        config.setUsername(ConfigManager.MB_DATABASE_USER.getValue());
-        config.setPassword(ConfigManager.MB_DATABASE_PASS.getValue());
-        config.addDataSourceProperty("characterEncoding", "utf8");
-        config.addDataSourceProperty("cachePrepStmts", "true");
-        config.addDataSourceProperty("prepStmtCacheSize", "250");
-        config.addDataSourceProperty("prepStmtCacheSqlLimit", "2048");
-
-        connectionPool = new HikariDataSource(config); // setup the connection pool
-
-        Logger.info("local database connection configured");
-    }
-
     public void invalidateCacheList() {
 
         int objectUUID;
         String objectType;
 
-        try (Connection connection = connectionPool.getConnection();
+        try (Connection connection = DbManager.getConnection();
              PreparedStatement statement = connection.prepareStatement("SELECT * FROM `login_cachelist`");
              ResultSet rs = statement.executeQuery()) {
 
@@ -400,7 +374,7 @@ public class LoginServer {
                 objectUUID = rs.getInt("UID");
                 objectType = rs.getString("type");
 
-                Logger.info("INVALIDATED : " +  objectType + " UUID: " + objectUUID);
+                Logger.info("INVALIDATED : " + objectType + " UUID: " + objectUUID);
 
                 switch (objectType) {
 
@@ -424,7 +398,7 @@ public class LoginServer {
 
         // clear the db table
 
-        try (Connection connection = connectionPool.getConnection();
+        try (Connection connection = DbManager.getConnection();
              PreparedStatement statement = connection.prepareStatement("DELETE FROM `login_cachelist`")) {
 
             statement.execute();
@@ -447,7 +421,7 @@ public class LoginServer {
 
         // query data warehouse for unresolved bane with this character
 
-        try (Connection connection = connectionPool.getConnection();
+        try (Connection connection = DbManager.getConnection();
              PreparedStatement statement = buildQueryActiveBaneStatement(connection, playerCharacter);
              ResultSet rs = statement.executeQuery()) {
 

src/engine/server/login/LoginServerMsgHandler.java

@@ -449,9 +449,9 @@ public class LoginServerMsgHandler implements NetMsgHandler {
         Account account = session.getAccount();
         account.setLastCharIDUsed(gameServerIPRequestMessage.getCharacterUUID());
 
-        GameServerIPResponseMsg gsiprm = new GameServerIPResponseMsg();
+        GameServerIPResponseMsg gameServerIPResponseMsg = new GameServerIPResponseMsg();
 
-        if (!conn.sendMsg(gsiprm)) {
+        if (!conn.sendMsg(gameServerIPResponseMsg)) {
             Logger.error("Failed to send message");
             this.KickToLogin(MBServerStatics.LOGINERROR_UNABLE_TO_LOGIN, "Unable to send GameServerIPResponseMsg to client.", conn);
         }

src/engine/server/world/WorldServer.java

@@ -305,9 +305,12 @@ public class WorldServer {
 		PowersManager.LoadAllMobPowers();
 
 		//load item enchantment values
+		Logger.info("Loading item enchants");
 		DbManager.LootQueries.LOAD_ENCHANT_VALUES();
 
-		//initialize realms
+		Logger.info("Loading zone extent cache");
+		DbManager.ZoneQueries.LOAD_ZONE_EXTENTS();
+
 		Logger.info("Loading Realms");
 		Realm.loadAllRealms();
 
@@ -471,7 +474,7 @@ public class WorldServer {
 					+  ConfigManager.MB_DATABASE_ADDRESS.getValue() + ':'
 					+  ConfigManager.MB_DATABASE_PORT.getValue());
 
-			DbManager.configureDatabaseLayer();
+			DbManager.configureConnectionPool();
 
 		} catch (Exception e) {
 			Logger.error(e.getMessage());
@@ -572,7 +575,7 @@ public class WorldServer {
 
 				//Handle cities
 
-				City.loadCities(zone);
+				ZoneManager.loadCities(zone);
 				ZoneManager.populateWorldZones(zone);
 
 			} catch (Exception e) {

src/engine/workthreads/HourlyJobThread.java

@@ -284,7 +284,6 @@ public class HourlyJobThread implements Runnable {
         Logger.info(WorldServer.getUptimeString());
         Logger.info(SimulationManager.getPopulationString());
         Logger.info(MessageDispatcher.getNetstatString());
-        Logger.info("Connection Pool Size: " + DbManager.getPoolSize());
         Logger.info(PurgeOprhans.recordsDeleted.toString() + "orphaned items deleted");
     }
 }

src/engine/workthreads/PurgeOprhans.java

@@ -8,7 +8,7 @@
 
 package engine.workthreads;
 
-import engine.db.archive.DataWarehouse;
+import engine.gameManager.DbManager;
 import org.pmw.tinylog.Logger;
 
 import java.sql.Connection;
@@ -46,7 +46,7 @@ public class PurgeOprhans implements Runnable {
         // Member variable declaration
 
         try (
-                Connection connection = DataWarehouse.connectionPool.getConnection();
+                Connection connection = DbManager.getConnection();
                 PreparedStatement statement = connection.prepareStatement("SELECT * from `object` where `type` = 'item' AND `parent` IS NULL", ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE);
                 ResultSet rs = statement.executeQuery()) {
 

src/engine/workthreads/WarehousePushThread.java

@@ -18,6 +18,7 @@ package engine.workthreads;
 import engine.Enum;
 import engine.db.archive.*;
 import engine.gameManager.ConfigManager;
+import engine.gameManager.DbManager;
 import org.pmw.tinylog.Logger;
 
 import java.sql.*;
@@ -153,9 +154,9 @@ public class WarehousePushThread implements Runnable {
 
 	public static boolean pushMineRecords() {
 
-		try (Connection localConnection = DataWarehouse.connectionPool.getConnection();
-				PreparedStatement statement = MineRecord.buildMineQueryStatement(localConnection);
-				ResultSet rs = statement.executeQuery()) {
+		try (Connection localConnection = DbManager.getConnection();
+			 PreparedStatement statement = MineRecord.buildMineQueryStatement(localConnection);
+			 ResultSet rs = statement.executeQuery()) {
 
 			while (rs.next()) {
 				pushMineRecord(rs);
@@ -164,7 +165,7 @@ public class WarehousePushThread implements Runnable {
 
 			return true;
 		} catch (SQLException e) {
-			Logger.error( "Error with local DB connection: " + e.toString());
+			Logger.error("Error with local DB connection: " + e.toString());
 			e.printStackTrace();
 			return false;
 		}
@@ -172,9 +173,9 @@ public class WarehousePushThread implements Runnable {
 
 	public static boolean pushCharacterRecords() {
 
-		try (Connection localConnection = DataWarehouse.connectionPool.getConnection();
-				PreparedStatement statement = CharacterRecord.buildCharacterQueryStatement(localConnection);
-				ResultSet rs = statement.executeQuery()) {
+		try (Connection localConnection = DbManager.getConnection();
+			 PreparedStatement statement = CharacterRecord.buildCharacterQueryStatement(localConnection);
+			 ResultSet rs = statement.executeQuery()) {
 
 			while (rs.next()) {
 				pushCharacterRecord(rs);
@@ -183,7 +184,7 @@ public class WarehousePushThread implements Runnable {
 
 			return true;
 		} catch (SQLException e) {
-			Logger.error( "Error with local DB connection: " + e.toString());
+			Logger.error("Error with local DB connection: " + e.toString());
 			e.printStackTrace();
 			return false;
 		}
@@ -191,9 +192,9 @@ public class WarehousePushThread implements Runnable {
 
 	private static boolean pushGuildRecords() {
 
-		try (Connection localConnection = DataWarehouse.connectionPool.getConnection();
-				PreparedStatement statement = GuildRecord.buildGuildQueryStatement(localConnection);
-				ResultSet rs = statement.executeQuery()) {
+		try (Connection localConnection = DbManager.getConnection();
+			 PreparedStatement statement = GuildRecord.buildGuildQueryStatement(localConnection);
+			 ResultSet rs = statement.executeQuery()) {
 
 			while (rs.next()) {
 				pushGuildRecord(rs);
@@ -238,9 +239,9 @@ public class WarehousePushThread implements Runnable {
 
 	private static boolean pushBaneRecords() {
 
-		try (Connection localConnection = DataWarehouse.connectionPool.getConnection();
-				PreparedStatement statement = BaneRecord.buildBaneQueryStatement(localConnection);
-				ResultSet rs = statement.executeQuery()) {
+		try (Connection localConnection = DbManager.getConnection();
+			 PreparedStatement statement = BaneRecord.buildBaneQueryStatement(localConnection);
+			 ResultSet rs = statement.executeQuery()) {
 
 			while (rs.next()) {
 				pushBaneRecord(rs);
@@ -271,9 +272,9 @@ public class WarehousePushThread implements Runnable {
 
 	private static boolean pushCityRecords() {
 
-		try (Connection localConnection = DataWarehouse.connectionPool.getConnection();
-				PreparedStatement statement = CityRecord.buildCityQueryStatement(localConnection);
-				ResultSet rs = statement.executeQuery()) {
+		try (Connection localConnection = DbManager.getConnection();
+			 PreparedStatement statement = CityRecord.buildCityQueryStatement(localConnection);
+			 ResultSet rs = statement.executeQuery()) {
 
 			while (rs.next()) {
 				pushCityRecord(rs);
@@ -282,7 +283,7 @@ public class WarehousePushThread implements Runnable {
 
 			return true;
 		} catch (SQLException e) {
-			Logger.error( "Error with local DB connection: " + e.toString());
+			Logger.error("Error with local DB connection: " + e.toString());
 			e.printStackTrace();
 			return false;
 		}
@@ -290,9 +291,9 @@ public class WarehousePushThread implements Runnable {
 
 	private static boolean pushPvpRecords() {
 
-		try (Connection localConnection = DataWarehouse.connectionPool.getConnection();
-				PreparedStatement statement = PvpRecord.buildPvpQueryStatement(localConnection);
-				ResultSet rs = statement.executeQuery()) {
+		try (Connection localConnection = DbManager.getConnection();
+			 PreparedStatement statement = PvpRecord.buildPvpQueryStatement(localConnection);
+			 ResultSet rs = statement.executeQuery()) {
 
 			while (rs.next()) {
 
@@ -323,9 +324,9 @@ public class WarehousePushThread implements Runnable {
 
 	private static boolean pushRealmRecords() {
 
-		try (Connection localConnection = DataWarehouse.connectionPool.getConnection();
-				PreparedStatement statement = RealmRecord.buildRealmQueryStatement(localConnection);
-				ResultSet rs = statement.executeQuery()) {
+		try (Connection localConnection = DbManager.getConnection();
+			 PreparedStatement statement = RealmRecord.buildRealmQueryStatement(localConnection);
+			 ResultSet rs = statement.executeQuery()) {
 
 			while (rs.next()) {
 
@@ -335,7 +336,7 @@ public class WarehousePushThread implements Runnable {
 
 			return true;
 		} catch (SQLException e) {
-			Logger.error( "Error with local DB connection: " + e.toString());
+			Logger.error("Error with local DB connection: " + e.toString());
 			e.printStackTrace();
 			return false;
 		}
@@ -392,9 +393,9 @@ public class WarehousePushThread implements Runnable {
 
 		queryString = "SELECT * FROM `warehouse_index`";
 
-		try (Connection localConnection = DataWarehouse.connectionPool.getConnection();
-				CallableStatement statement = localConnection.prepareCall(queryString);
-				ResultSet rs = statement.executeQuery()) {
+		try (Connection localConnection = DbManager.getConnection();
+			 CallableStatement statement = localConnection.prepareCall(queryString);
+			 ResultSet rs = statement.executeQuery()) {
 
 			while (rs.next()) {
 				charIndex = rs.getInt("charIndex");
@@ -417,14 +418,14 @@ public class WarehousePushThread implements Runnable {
 
 	private static boolean updateWarehouseIndex() {
 
-		try (Connection connection = DataWarehouse.connectionPool.getConnection();
-				PreparedStatement statement = WarehousePushThread.buildIndexUpdateStatement(connection)) {
+		try (Connection connection = DbManager.getConnection();
+			 PreparedStatement statement = WarehousePushThread.buildIndexUpdateStatement(connection)) {
 
 			statement.execute();
 			return true;
 
 		} catch (SQLException e) {
-			Logger.error( e.toString());
+			Logger.error(e.toString());
 			return false;
 		}
 	}