MagicBane
/
Server
92
0
Fork 3
Code Issues 7 Pull Requests Projects Releases Wiki Activity
Public Repository for the Magicbane Shadowbane Emulator
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2229 Commits
37 Branches
0 Tags
15 MiB
 
Tree: 13bf6e6f5a
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '13bf6e6f5a'
${ noResults }
Server/src/engine/objects/Warehouse.java

822 lines
31 KiB
Raw Blame History

// • ▌ ▄ ·. ▄▄▄· ▄▄ • ▪ ▄▄· ▄▄▄▄· ▄▄▄· ▐▄▄▄ ▄▄▄ .
// ·██ ▐███▪▐█ ▀█ ▐█ ▀ ▪██ ▐█ ▌▪▐█ ▀█▪▐█ ▀█ •█▌ ▐█▐▌·
// ▐█ ▌▐▌▐█·▄█▀▀█ ▄█ ▀█▄▐█·██ ▄▄▐█▀▀█▄▄█▀▀█ ▐█▐ ▐▌▐▀▀▀
// ██ ██▌▐█▌▐█ ▪▐▌▐█▄▪▐█▐█▌▐███▌██▄▪▐█▐█ ▪▐▌██▐ █▌▐█▄▄▌
// ▀▀ █▪▀▀▀ ▀ ▀ ·▀▀▀▀ ▀▀▀·▀▀▀ ·▀▀▀▀ ▀ ▀ ▀▀ █▪ ▀▀▀
// Magicbane Emulator Project © 2013 - 2022
// www.magicbane.com
package engine.objects;
import ch.claude_martin.enumbitset.EnumBitSet;
import engine.Enum;
import engine.gameManager.BuildingManager;
import engine.gameManager.ChatManager;
import engine.gameManager.DbManager;
import engine.net.Dispatch;
import engine.net.DispatchMessage;
import engine.net.client.ClientConnection;
import engine.net.client.msg.*;
import engine.server.MBServerStatics;
import org.joda.time.DateTime;
import org.pmw.tinylog.Logger;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.EnumSet;
import java.util.concurrent.ConcurrentHashMap;
public class Warehouse extends AbstractWorldObject {
public static ConcurrentHashMap<Integer, Warehouse> warehouseByBuildingUUID = new ConcurrentHashMap<>();
public EnumBitSet<Enum.ResourceType> lockedResourceTypes;
public int UID;
public int buildingUID;
public ArrayList<Transaction> transactions = new ArrayList<>();
public ConcurrentHashMap<Enum.ResourceType, Integer> resources = new ConcurrentHashMap<>();
/**
* ResultSet Constructor
*/
public Warehouse(ResultSet rs) throws SQLException {
super(rs);
this.UID = rs.getInt("UID");
this.resources.put(Enum.ResourceType.STONE, rs.getInt("warehouse_stone"));
this.resources.put(Enum.ResourceType.TRUESTEEL, rs.getInt("warehouse_truesteel"));
this.resources.put(Enum.ResourceType.IRON, rs.getInt("warehouse_iron"));
this.resources.put(Enum.ResourceType.ADAMANT, rs.getInt("warehouse_adamant"));
this.resources.put(Enum.ResourceType.LUMBER, rs.getInt("warehouse_lumber"));
this.resources.put(Enum.ResourceType.OAK, rs.getInt("warehouse_oak"));
this.resources.put(Enum.ResourceType.BRONZEWOOD, rs.getInt("warehouse_bronzewood"));
this.resources.put(Enum.ResourceType.MANDRAKE, rs.getInt("warehouse_mandrake"));
this.resources.put(Enum.ResourceType.COAL, rs.getInt("warehouse_coal"));
this.resources.put(Enum.ResourceType.AGATE, rs.getInt("warehouse_agate"));
this.resources.put(Enum.ResourceType.DIAMOND, rs.getInt("warehouse_diamond"));
this.resources.put(Enum.ResourceType.ONYX, rs.getInt("warehouse_onyx"));
this.resources.put(Enum.ResourceType.AZOTH, rs.getInt("warehouse_azoth"));
this.resources.put(Enum.ResourceType.ORICHALK, rs.getInt("warehouse_orichalk"));
this.resources.put(Enum.ResourceType.ANTIMONY, rs.getInt("warehouse_antimony"));
this.resources.put(Enum.ResourceType.SULFUR, rs.getInt("warehouse_sulfur"));
this.resources.put(Enum.ResourceType.QUICKSILVER, rs.getInt("warehouse_quicksilver"));
this.resources.put(Enum.ResourceType.GALVOR, rs.getInt("warehouse_galvor"));
this.resources.put(Enum.ResourceType.WORMWOOD, rs.getInt("warehouse_wormwood"));
this.resources.put(Enum.ResourceType.OBSIDIAN, rs.getInt("warehouse_obsidian"));
this.resources.put(Enum.ResourceType.BLOODSTONE, rs.getInt("warehouse_bloodstone"));
this.resources.put(Enum.ResourceType.MITHRIL, rs.getInt("warehouse_mithril"));
this.resources.put(Enum.ResourceType.GOLD, rs.getInt("warehouse_gold"));
this.lockedResourceTypes = EnumBitSet.asEnumBitSet(rs.getLong("warehouse_locks"), Enum.ResourceType.class);
this.buildingUID = rs.getInt("parent");
warehouseByBuildingUUID.put(this.buildingUID, this);
}
public static void warehouseDeposit(MerchantMsg msg, PlayerCharacter player, NPC npc) {
Building warehouseBuilding;
Warehouse warehouse;
int depositAmount;
Dispatch dispatch;
Item resource = Item.getFromCache(msg.getItemID());
if (resource == null)
return;
depositAmount = msg.getAmount();
CharacterItemManager itemMan = player.getCharItemManager();
if (!itemMan.doesCharOwnThisItem(resource.getObjectUUID()))
return;
warehouseBuilding = npc.getBuilding();
if (warehouseBuilding == null)
return;
warehouse = warehouseByBuildingUUID.get(warehouseBuilding.getObjectUUID());
if (warehouse == null)
return;
if (!deposit(player, resource, depositAmount, true, true,warehouse)) {
return;
}
ViewResourcesMessage vrm = new ViewResourcesMessage(player);
vrm.setGuild(player.getGuild());
vrm.setWarehouseBuilding(warehouseBuilding);
vrm.configure();
dispatch = Dispatch.borrow(player, vrm);
DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY);
}
public static void warehouseWithdraw(MerchantMsg msg, PlayerCharacter player, NPC npc) {
int withdrawAmount;
Building warehouseBuilding;
Warehouse warehouse;
Dispatch dispatch;
withdrawAmount = msg.getAmount();
warehouseBuilding = npc.getBuilding();
if (warehouseBuilding == null)
return;
if (player.getGuild() != warehouseBuilding.getGuild() || !GuildStatusController.isInnerCouncil(player.getGuildStatus()))
return;
warehouse = warehouseByBuildingUUID.get(warehouseBuilding.getObjectUUID());
if (warehouse == null)
return;
Enum.ResourceType resourceType = Enum.ResourceType.hashLookup.get(msg.getHashID());
if (isResourceLocked(warehouse, resourceType)) {
ChatManager.chatSystemInfo(player, "You cannot withdrawl a locked resource.");
return;
}
if (!withdraw(warehouse, player, resourceType, withdrawAmount, true, true)) {
ChatManager.chatGuildError(player, "Failed to withdrawl " + resourceType.name() + '.');
Logger.debug(player.getName() + " Failed to withdrawl =" + resourceType.name() + " from Warehouse With ID = " + warehouseBuilding.getObjectUUID());
return;
}
ViewResourcesMessage vrm = new ViewResourcesMessage(player);
vrm.setGuild(player.getGuild());
vrm.setWarehouseBuilding(warehouseBuilding);
vrm.configure();
dispatch = Dispatch.borrow(player, vrm);
DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY);
}
public static void warehouseLock(MerchantMsg msg, PlayerCharacter player, NPC npc) {
Building warehouse;
int hashID;
Dispatch dispatch;
hashID = msg.getHashID();
warehouse = npc.getBuilding();
if (warehouse == null)
return;
if (player.getGuild() != warehouse.getGuild() || !GuildStatusController.isInnerCouncil(player.getGuildStatus()))
return;
Warehouse wh = warehouseByBuildingUUID.get(warehouse.getObjectUUID());
if (wh == null)
return;
Enum.ResourceType resourceType = Enum.ResourceType.hashLookup.get(hashID);
if (isResourceLocked(wh, resourceType)) {
boolean worked;
EnumBitSet<Enum.ResourceType> bitSet = EnumBitSet.asEnumBitSet(wh.lockedResourceTypes.toLong(), Enum.ResourceType.class);
bitSet.remove(resourceType);
worked = DbManager.WarehouseQueries.updateLocks(wh, bitSet.toLong());
if (worked) {
wh.lockedResourceTypes.remove(resourceType);
ViewResourcesMessage vrm = new ViewResourcesMessage(player);
vrm.setGuild(player.getGuild());
vrm.setWarehouseBuilding(warehouse);
vrm.configure();
dispatch = Dispatch.borrow(player, vrm);
DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY);
}
return;
}
EnumBitSet<Enum.ResourceType> bitSet = EnumBitSet.asEnumBitSet(wh.lockedResourceTypes.toLong(), Enum.ResourceType.class);
bitSet.add(resourceType);
if (!DbManager.WarehouseQueries.updateLocks(wh, bitSet.toLong()))
return;
wh.lockedResourceTypes.add(resourceType);
ViewResourcesMessage vrm = new ViewResourcesMessage(player);
vrm.setGuild(player.getGuild());
vrm.setWarehouseBuilding(warehouse);
vrm.configure();
dispatch = Dispatch.borrow(player, vrm);
DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY);
}
public static synchronized boolean deposit(PlayerCharacter pc, Item resource, int amount, boolean removeFromInventory, boolean transaction, Warehouse warehouse) {
ClientConnection origin = pc.getClientConnection();
if (origin == null)
return false;
if (amount < 0) {
Logger.info(pc.getFirstName() + " Attempting to Dupe!!!!!!");
return false;
}
Enum.ResourceType resourceType = Enum.ResourceType.resourceLookup.get(resource.templateID);
if (warehouse.resources.get(resourceType) == null)
return false;
CharacterItemManager itemMan = pc.getCharItemManager();
if (itemMan == null)
return false;
if (itemMan.getGoldTrading() > 0) {
ErrorPopupMsg.sendErrorPopup(pc, 195);
return false;
}
if (!itemMan.doesCharOwnThisItem(resource.getObjectUUID()))
return false;
if (!resource.validForInventory(origin, pc, itemMan))
return false;
if (resource.getNumOfItems() < amount)
return false;
int oldAmount = warehouse.resources.get(resourceType);
int newAmount = oldAmount + amount;
if (newAmount > Enum.ResourceType.resourceLookup.get(resource.templateID).deposit_limit) {
//ChatManager.chatSystemInfo(pc, "The Warehouse is at it's maximum for this type of resource.");
return false;
}
if (removeFromInventory) {
if (resourceType.equals(Enum.ResourceType.GOLD)) {
if (itemMan.getGoldInventory().getNumOfItems() - amount < 0)
return false;
if (itemMan.getGoldInventory().getNumOfItems() - amount > MBServerStatics.PLAYER_GOLD_LIMIT)
return false;
if (!itemMan.modifyInventoryGold(-amount)) {
//ChatManager.chatSystemError(pc, "You do not have this Gold.");
return false;
}
UpdateGoldMsg ugm = new UpdateGoldMsg(pc);
ugm.configure();
Dispatch dispatch = Dispatch.borrow(pc, ugm);
DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY);
itemMan.updateInventory();
} else {
itemMan.delete(resource);
itemMan.updateInventory();
}
}
itemMan.updateInventory();
if (!DepositApproved(resourceType, amount, warehouse))
return false;
warehouse.resources.put(resourceType, newAmount);
if (resource.template.item_type.equals(Enum.ItemType.GOLD))
resourceType = Enum.ResourceType.GOLD;
else
resourceType = Enum.ResourceType.valueOf(ItemTemplate.itemTemplates.get(resource.getTemplateID()).item_base_name.toUpperCase());
if (transaction)
AddTransactionToWarehouse(warehouse, pc.getObjectType(), pc.getObjectUUID(), Enum.TransactionType.DEPOSIT, resourceType, amount);
return true;
}
public static synchronized boolean depositFromMine(Mine mine, Enum.ResourceType resourceType, int amount, Warehouse warehouse) {
int oldAmount = warehouse.resources.get(resourceType);
int newAmount = oldAmount + amount;
if (newAmount > resourceType.deposit_limit)
return false;
if (!DepositApproved(resourceType, amount, warehouse))
return false;
warehouse.resources.put(resourceType, newAmount);
if (mine != null)
AddTransactionToWarehouse(warehouse, Enum.GameObjectType.Building, mine.getBuildingID(), Enum.TransactionType.MINE, resourceType, amount);
return true;
}
public static boolean DepositApproved(Enum.ResourceType resourceType, int amount, Warehouse warehouse) {
if (warehouse.resources.get(resourceType) == null)
return false;
int oldAmount = warehouse.resources.get(resourceType);
int newAmount = oldAmount + amount;
if (newAmount > resourceType.deposit_limit)
return false;
boolean worked = false;
switch (resourceType) {
case GOLD:
worked = DbManager.WarehouseQueries.updateGold(warehouse, newAmount);
break;
case STONE:
worked = DbManager.WarehouseQueries.updateStone(warehouse, newAmount);
break;
case TRUESTEEL:
worked = DbManager.WarehouseQueries.updateTruesteel(warehouse, newAmount);
break;
case IRON:
worked = DbManager.WarehouseQueries.updateIron(warehouse, newAmount);
break;
case ADAMANT:
worked = DbManager.WarehouseQueries.updateAdamant(warehouse, newAmount);
break;
case LUMBER:
worked = DbManager.WarehouseQueries.updateLumber(warehouse, newAmount);
break;
case OAK:
worked = DbManager.WarehouseQueries.updateOak(warehouse, newAmount);
break;
case BRONZEWOOD:
worked = DbManager.WarehouseQueries.updateBronzewood(warehouse, newAmount);
break;
case MANDRAKE:
worked = DbManager.WarehouseQueries.updateMandrake(warehouse, newAmount);
break;
case COAL:
worked = DbManager.WarehouseQueries.updateCoal(warehouse, newAmount);
break;
case AGATE:
worked = DbManager.WarehouseQueries.updateAgate(warehouse, newAmount);
break;
case DIAMOND:
worked = DbManager.WarehouseQueries.updateDiamond(warehouse, newAmount);
break;
case ONYX:
worked = DbManager.WarehouseQueries.updateOnyx(warehouse, newAmount);
break;
case AZOTH:
worked = DbManager.WarehouseQueries.updateAzoth(warehouse, newAmount);
break;
case ORICHALK:
worked = DbManager.WarehouseQueries.updateOrichalk(warehouse, newAmount);
break;
case ANTIMONY:
worked = DbManager.WarehouseQueries.updateAntimony(warehouse, newAmount);
break;
case SULFUR:
worked = DbManager.WarehouseQueries.updateSulfur(warehouse, newAmount);
break;
case QUICKSILVER:
worked = DbManager.WarehouseQueries.updateQuicksilver(warehouse, newAmount);
break;
case GALVOR:
worked = DbManager.WarehouseQueries.updateGalvor(warehouse, newAmount);
break;
case WORMWOOD:
worked = DbManager.WarehouseQueries.updateWormwood(warehouse, newAmount);
break;
case OBSIDIAN:
worked = DbManager.WarehouseQueries.updateObsidian(warehouse, newAmount);
break;
case BLOODSTONE:
worked = DbManager.WarehouseQueries.updateBloodstone(warehouse, newAmount);
break;
case MITHRIL:
worked = DbManager.WarehouseQueries.updateMithril(warehouse, newAmount);
break;
}
return worked;
}
public static synchronized void depositRealmTaxes(PlayerCharacter taxer, Enum.ResourceType resourceType, int amount, Warehouse warehouse) {
if (!DepositApproved(resourceType, amount, warehouse))
return;
int oldAmount = warehouse.resources.get(resourceType);
int newAmount = oldAmount + amount;
warehouse.resources.put(resourceType, newAmount);
AddTransactionToWarehouse(warehouse, taxer.getObjectType(), taxer.getObjectUUID(), Enum.TransactionType.TAXRESOURCEDEPOSIT, resourceType, amount);
}
public static synchronized void depositProfitTax(Enum.ResourceType resourceType, int amount, Building building, Warehouse warehouse) {
if (warehouse.resources.get(resourceType) == null)
return;
int oldAmount = warehouse.resources.get(resourceType);
int newAmount = oldAmount + amount;
if (newAmount > resourceType.deposit_limit)
return;
if (!DepositApproved(resourceType, amount, warehouse))
return;
warehouse.resources.put(resourceType, newAmount);
if (building != null)
AddTransactionToWarehouse(warehouse, Enum.GameObjectType.Building, building.getObjectUUID(), Enum.TransactionType.DEPOSIT, resourceType, amount);
}
public static boolean WithdrawApproved(Enum.ResourceType resourceType, int amount, Warehouse warehouse) {
if (warehouse.resources.get(resourceType) == null)
return false;
if (amount <= 0)
return false;
int oldAmount = warehouse.resources.get(resourceType);
if (oldAmount < amount)
return false;
int newAmount = oldAmount - amount;
boolean worked = false;
switch (resourceType) {
case GOLD:
worked = DbManager.WarehouseQueries.updateGold(warehouse, newAmount);
break;
case STONE:
worked = DbManager.WarehouseQueries.updateStone(warehouse, newAmount);
break;
case TRUESTEEL:
worked = DbManager.WarehouseQueries.updateTruesteel(warehouse, newAmount);
break;
case IRON:
worked = DbManager.WarehouseQueries.updateIron(warehouse, newAmount);
break;
case ADAMANT:
worked = DbManager.WarehouseQueries.updateAdamant(warehouse, newAmount);
break;
case LUMBER:
worked = DbManager.WarehouseQueries.updateLumber(warehouse, newAmount);
break;
case OAK:
worked = DbManager.WarehouseQueries.updateOak(warehouse, newAmount);
break;
case BRONZEWOOD:
worked = DbManager.WarehouseQueries.updateBronzewood(warehouse, newAmount);
break;
case MANDRAKE:
worked = DbManager.WarehouseQueries.updateMandrake(warehouse, newAmount);
break;
case COAL:
worked = DbManager.WarehouseQueries.updateCoal(warehouse, newAmount);
break;
case AGATE:
worked = DbManager.WarehouseQueries.updateAgate(warehouse, newAmount);
break;
case DIAMOND:
worked = DbManager.WarehouseQueries.updateDiamond(warehouse, newAmount);
break;
case ONYX:
worked = DbManager.WarehouseQueries.updateOnyx(warehouse, newAmount);
break;
case AZOTH:
worked = DbManager.WarehouseQueries.updateAzoth(warehouse, newAmount);
break;
case ORICHALK:
worked = DbManager.WarehouseQueries.updateOrichalk(warehouse, newAmount);
break;
case ANTIMONY:
worked = DbManager.WarehouseQueries.updateAntimony(warehouse, newAmount);
break;
case SULFUR:
worked = DbManager.WarehouseQueries.updateSulfur(warehouse, newAmount);
break;
case QUICKSILVER:
worked = DbManager.WarehouseQueries.updateQuicksilver(warehouse, newAmount);
break;
case GALVOR:
worked = DbManager.WarehouseQueries.updateGalvor(warehouse, newAmount);
break;
case WORMWOOD:
worked = DbManager.WarehouseQueries.updateWormwood(warehouse, newAmount);
break;
case OBSIDIAN:
worked = DbManager.WarehouseQueries.updateObsidian(warehouse, newAmount);
break;
case BLOODSTONE:
worked = DbManager.WarehouseQueries.updateBloodstone(warehouse, newAmount);
break;
case MITHRIL:
worked = DbManager.WarehouseQueries.updateMithril(warehouse, newAmount);
break;
}
return worked;
}
public static synchronized boolean withdraw(Warehouse warehouse, NPC npc, Enum.ResourceType resourceType, int amount, boolean transaction) {
int oldAmount = warehouse.resources.get(resourceType);
int newAmount = oldAmount - amount;
if (!WithdrawApproved(resourceType, amount, warehouse))
return false;
warehouse.resources.put(resourceType, newAmount);
if (transaction)
AddTransactionToWarehouse(warehouse, npc.getObjectType(), npc.getObjectUUID(), Enum.TransactionType.WITHDRAWL, resourceType, amount);
return true;
}
public static synchronized void transferResources(Warehouse warehouse, PlayerCharacter taxer, TaxResourcesMsg msg, ArrayList<Enum.ResourceType> realmResources, float taxPercent) {
for (Enum.ResourceType resourceType : realmResources) {
if (warehouse.resources.get(resourceType) == null)
return;
int amount = (int) (warehouse.resources.get(resourceType) * taxPercent);
if (amount <= 0) {
msg.getResources().put(resourceType.hash, 0);
continue;
}
int oldAmount = warehouse.resources.get(resourceType);
if (oldAmount < amount)
amount = oldAmount;
int newAmount = oldAmount - amount;
if (newAmount < amount)
continue;
if (!WithdrawApproved(resourceType, amount, warehouse)) {
msg.getResources().put(resourceType.hash, 0);
continue;
}
msg.getResources().put(resourceType.hash, amount);
warehouse.resources.put(resourceType, newAmount);
depositRealmTaxes(taxer, resourceType, amount, warehouse);
Enum.ResourceType resource;
AddTransactionToWarehouse(warehouse, taxer.getObjectType(), taxer.getObjectUUID(), Enum.TransactionType.TAXRESOURCE, resourceType, amount);
}
}
public static synchronized boolean withdraw(Warehouse warehouse, PlayerCharacter pc, Enum.ResourceType resourceType, int amount, boolean addToInventory, boolean transaction) {
if (pc == null)
return false;
ItemTemplate template = ItemTemplate.itemTemplates.get(resourceType.templateID);
if (warehouse.resources.get(resourceType) == null)
return false;
if (amount <= 0)
return false;
CharacterItemManager itemMan = pc.getCharItemManager();
if (itemMan == null)
return false;
if (addToInventory)
if (!itemMan.hasRoomInventory(template.item_wt * amount)) {
ChatManager.chatSystemInfo(pc, "You can not carry any more of that item.");
return false;
}
if (addToInventory && resourceType.equals(Enum.ResourceType.GOLD)) {
if (pc.getCharItemManager().getGoldInventory().getNumOfItems() + amount > MBServerStatics.PLAYER_GOLD_LIMIT)
return false;
if (pc.getCharItemManager().getGoldInventory().getNumOfItems() + amount < 0)
return false;
}
int oldAmount = warehouse.resources.get(resourceType);
if (oldAmount < amount)
return false;
int newAmount = oldAmount - amount;
if (!WithdrawApproved(resourceType, amount, warehouse))
return false;
warehouse.resources.put(resourceType, newAmount);
if (addToInventory) {
if (resourceType.equals(Enum.ResourceType.GOLD)) {
itemMan.addGoldToInventory(amount, false);
UpdateGoldMsg ugm = new UpdateGoldMsg(pc);
ugm.configure();
Dispatch dispatch = Dispatch.borrow(pc, ugm);
DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY);
itemMan.updateInventory();
} else {
boolean itemWorked = false;
Item item = new Item(resourceType.templateID);
item.ownerID = pc.getObjectUUID();
item.ownerType = Enum.OwnerType.PlayerCharacter;
item.containerType = Enum.ItemContainerType.INVENTORY;
item.numberOfItems = amount;
try {
item = DbManager.ItemQueries.PERSIST(item);
itemWorked = true;
} catch (Exception e) {
Logger.error(e);
}
if (itemWorked) {
itemMan.addItemToInventory(item);
itemMan.updateInventory();
}
}
}
if (transaction)
AddTransactionToWarehouse(warehouse, pc.getObjectType(), pc.getObjectUUID(), Enum.TransactionType.WITHDRAWL, resourceType, amount);
return true;
}
public static synchronized boolean loot(Warehouse warehouse, PlayerCharacter pc, Enum.ResourceType resourceType, int amount, boolean addToInventory) {
if (pc == null)
return false;
ItemTemplate template = ItemTemplate.itemTemplates.get(resourceType);
if (template == null)
return false;
if (warehouse.resources.get(resourceType) == null)
return false;
if (amount <= 0)
return false;
CharacterItemManager itemMan = pc.getCharItemManager();
if (itemMan == null)
return false;
if (!itemMan.hasRoomInventory(template.item_wt)) {
ChatManager.chatSystemInfo(pc, "You can not carry any more of that item.");
return false;
}
int oldAmount = warehouse.resources.get(resourceType);
if (oldAmount < amount)
return false;
int newAmount = oldAmount - amount;
warehouse.resources.put(resourceType, newAmount);
if (addToInventory) {
if (resourceType.equals(Enum.ResourceType.GOLD)) {
itemMan.addGoldToInventory(amount, false);
UpdateGoldMsg ugm = new UpdateGoldMsg(pc);
ugm.configure();
Dispatch dispatch = Dispatch.borrow(pc, ugm);
DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY);
itemMan.updateInventory();
} else {
boolean itemWorked = false;
Item item = new Item(resourceType.templateID);
item.ownerID = pc.getObjectUUID();
item.ownerType = Enum.OwnerType.PlayerCharacter;
item.containerType = Enum.ItemContainerType.INVENTORY;
item.numberOfItems = amount;
try {
item = DbManager.ItemQueries.PERSIST(item);
itemWorked = true;
} catch (Exception e) {
Logger.error(e);
}
if (itemWorked) {
itemMan.addItemToInventory(item);
itemMan.updateInventory();
}
}
}
return true;
}
public static boolean isEmpty(Warehouse warehouse) {
int amount = 0;
for (Enum.ResourceType resourceType : EnumSet.allOf(Enum.ResourceType.class)) {
amount += warehouse.resources.get(resourceType);
if (amount > 0)
return false;
}
return true;
}
public static void loadAllTransactions(Warehouse warehouse) {
warehouse.transactions = DbManager.WarehouseQueries.GET_TRANSACTIONS_FOR_WAREHOUSE(warehouse.buildingUID);
}
public static void AddTransactionToWarehouse(Warehouse warehouse, Enum.GameObjectType targetType, int targetUUID, Enum.TransactionType transactionType, Enum.ResourceType resource, int amount) {
if (!DbManager.WarehouseQueries.CREATE_TRANSACTION(warehouse.buildingUID, targetType, targetUUID, transactionType, resource, amount, DateTime.now()))
return;
Transaction transaction = new Transaction(warehouse.buildingUID, targetType, targetUUID, transactionType, resource, amount, DateTime.now());
warehouse.transactions.add(transaction);
}
public static boolean isAboveCap(Warehouse warehouse, Enum.ResourceType resourceType, int deposit) {
int newAmount = warehouse.resources.get(resourceType) + deposit;
return newAmount > resourceType.deposit_limit;
}
public static boolean isResourceLocked(Warehouse warehouse, Enum.ResourceType resourceType) {
return resourceType.elementOf(warehouse.lockedResourceTypes);
}
@Override
public void updateDatabase() {
// TODO Auto-generated method stub
}
@Override
public void runAfterLoad() {
try {
Building warehouseBuilding = BuildingManager.getBuilding(this.buildingUID);
Logger.info("configuring warehouse " + UID + " for city " + warehouseBuilding.getCity().getCityName() + " structure UUID " + this.buildingUID);
//Building is gone, but Warehouse still in DB?? Should never happen, sanity check anyway.
if (warehouseBuilding == null) {
Logger.error("Failed to load Building for Warehouse");
return;
}
Zone cityZone = warehouseBuilding.getParentZone();
if (cityZone == null) {
Logger.error("Failed to load Zone for Warehouse with UUID " + this.getObjectUUID());
return;
}
City city = City.getCity(cityZone.playerCityUUID);
if (city == null) {
Logger.error("Failed to load City for Warehouse with UUID " + this.getObjectUUID());
return;
}
warehouseByBuildingUUID.put(this.buildingUID, this);
city.setWarehouseBuildingID(this.buildingUID);
} catch (Exception E) {
Logger.info(this.getObjectUUID() + " failed");
}
}
}