forked from MagicBane/Server
1029 lines
42 KiB
Java
1029 lines
42 KiB
Java
// • ▌ ▄ ·. ▄▄▄· ▄▄ • ▪ ▄▄· ▄▄▄▄· ▄▄▄· ▐▄▄▄ ▄▄▄ .
|
|
// ·██ ▐███▪▐█ ▀█ ▐█ ▀ ▪██ ▐█ ▌▪▐█ ▀█▪▐█ ▀█ •█▌ ▐█▐▌·
|
|
// ▐█ ▌▐▌▐█·▄█▀▀█ ▄█ ▀█▄▐█·██ ▄▄▐█▀▀█▄▄█▀▀█ ▐█▐ ▐▌▐▀▀▀
|
|
// ██ ██▌▐█▌▐█ ▪▐▌▐█▄▪▐█▐█▌▐███▌██▄▪▐█▐█ ▪▐▌██▐ █▌▐█▄▄▌
|
|
// ▀▀ █▪▀▀▀ ▀ ▀ ·▀▀▀▀ ▀▀▀·▀▀▀ ·▀▀▀▀ ▀ ▀ ▀▀ █▪ ▀▀▀
|
|
// Magicbane Emulator Project © 2013 - 2022
|
|
// www.magicbane.com
|
|
|
|
|
|
package engine.objects;
|
|
|
|
import engine.Enum;
|
|
import engine.Enum.ItemContainerType;
|
|
import engine.Enum.ItemType;
|
|
import engine.Enum.OwnerType;
|
|
import engine.gameManager.*;
|
|
import engine.loot.ModTableEntry;
|
|
import engine.loot.ModTypeTableEntry;
|
|
import engine.net.ItemProductionManager;
|
|
import engine.net.ItemQueue;
|
|
import engine.net.client.ClientConnection;
|
|
import engine.net.client.msg.ErrorPopupMsg;
|
|
import engine.powers.EffectsBase;
|
|
import engine.server.MBServerStatics;
|
|
import org.joda.time.DateTime;
|
|
import org.pmw.tinylog.Logger;
|
|
|
|
import java.util.concurrent.ConcurrentHashMap;
|
|
import java.util.concurrent.ThreadLocalRandom;
|
|
|
|
public class ItemFactory {
|
|
|
|
public static void fillInventory(PlayerCharacter pc, int templateID, int count) {
|
|
|
|
if (pc == null)
|
|
return;
|
|
|
|
int max = 20;
|
|
CharacterItemManager itemManager = pc.charItemManager;
|
|
|
|
ItemTemplate template = ItemTemplate.templates.get(templateID);
|
|
|
|
if (count > max)
|
|
count = max;
|
|
|
|
ClientConnection cc = pc.getClientConnection();
|
|
|
|
if (itemManager == null || template == null || cc == null)
|
|
return;
|
|
|
|
boolean worked;
|
|
|
|
for (int i = 0; i < count; i++) {
|
|
worked = false;
|
|
|
|
if (!itemManager.hasRoomInventory(template.item_wt)) {
|
|
if (pc != null)
|
|
ChatManager.chatSystemInfo(pc, "You can not carry any more of that item.");
|
|
break;
|
|
}
|
|
|
|
Item item = new Item(templateID);
|
|
item.ownerID = pc.getObjectUUID();
|
|
item.ownerType = OwnerType.PlayerCharacter;
|
|
item.containerType = ItemContainerType.INVENTORY;
|
|
|
|
try {
|
|
item = DbManager.ItemQueries.PERSIST(item);
|
|
worked = true;
|
|
} catch (Exception e) {
|
|
Logger.error(e);
|
|
}
|
|
if (worked) {
|
|
itemManager.addItemToInventory(item);
|
|
}
|
|
}
|
|
itemManager.updateInventory();
|
|
}
|
|
|
|
public static Item fillForge(NPC npc, PlayerCharacter pc, int itemsToRoll, int templateID, int pToken, int sToken, String customName) {
|
|
|
|
String prefixString = "";
|
|
String suffixString = "";
|
|
if (npc == null)
|
|
return null;
|
|
|
|
boolean useWarehouse = false;
|
|
|
|
ItemTemplate template = ItemTemplate.templates.get(templateID);
|
|
|
|
if (template == null)
|
|
return null;
|
|
|
|
Building forge = npc.getBuilding();
|
|
|
|
if (forge == null)
|
|
return null;
|
|
|
|
if (!npc.charItemManager.hasRoomInventory(template.item_wt)) {
|
|
if (pc != null)
|
|
ErrorPopupMsg.sendErrorPopup(pc, 21);
|
|
return null;
|
|
}
|
|
|
|
Zone zone = npc.getBuilding().getParentZone();
|
|
|
|
if (zone == null)
|
|
return null;
|
|
|
|
City city = City.getCity(zone.playerCityUUID);
|
|
|
|
if (city == null)
|
|
return null;
|
|
|
|
MobLoot ml = null;
|
|
city.transactionLock.writeLock().lock();
|
|
|
|
try {
|
|
Warehouse cityWarehouse = city.warehouse;
|
|
|
|
if (cityWarehouse != null && forge.assetIsProtected())
|
|
useWarehouse = true;
|
|
// ROLL BANE SCROLL.
|
|
|
|
if (templateID > 910010 && templateID < 910019) {
|
|
ConcurrentHashMap<Enum.ResourceType, Integer> resources = cityWarehouse.resources;
|
|
|
|
|
|
int buildingWithdraw = BuildingManager.GetWithdrawAmountForRolling(forge, template.item_value);
|
|
int overdraft = BuildingManager.GetOverdraft(forge, template.item_value);
|
|
|
|
if (overdraft > 0 && !useWarehouse) {
|
|
if (pc != null)
|
|
ErrorPopupMsg.sendErrorMsg(pc, "Not enough gold in building strongbox." + " " + template.item_base_name);
|
|
return null;
|
|
}
|
|
|
|
if (overdraft > 0 && Warehouse.isResourceLocked(cityWarehouse, Enum.ResourceType.GOLD)) {
|
|
if (pc != null)
|
|
ErrorPopupMsg.sendErrorMsg(pc, "Warehouse gold is barred! Overdraft cannot be withdrawn from warehouse." + " " + template.item_base_name);
|
|
return null;
|
|
}
|
|
|
|
if (overdraft > resources.get(ItemBase.GOLD_ITEM_BASE)) {
|
|
if (pc != null)
|
|
ErrorPopupMsg.sendErrorMsg(pc, "Not enough Gold in Warehouse for overdraft." + " " + template.item_base_name);
|
|
return null;
|
|
}
|
|
|
|
if (!forge.transferGold(-buildingWithdraw, false)) {
|
|
overdraft += buildingWithdraw;
|
|
|
|
if (!useWarehouse) {
|
|
ErrorPopupMsg.sendErrorMsg(pc, "Building does not have enough gold to produce this item." + template.item_base_name);
|
|
return null;
|
|
} else {
|
|
if (overdraft > resources.get(ItemBase.GOLD_ITEM_BASE)) {
|
|
ErrorPopupMsg.sendErrorMsg(pc, "Not enough Gold in Warehouse to produce this item." + template.item_base_name);
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (overdraft > 0)
|
|
if (!Warehouse.withdraw(cityWarehouse, npc, Enum.ResourceType.GOLD, overdraft, true)) {
|
|
Logger.error("Warehouse for city " + cityWarehouse.city.getName() + " Failed to Create Item." + template.item_base_name);
|
|
return null;
|
|
}
|
|
|
|
ml = new MobLoot(npc, template, false);
|
|
|
|
ml.containerType = Enum.ItemContainerType.FORGE;
|
|
ml.setValue(0);
|
|
ml.loadEnchantments();
|
|
|
|
float time;
|
|
float rank = npc.getBuilding().getRank() - 1;
|
|
float rate = (float) (2.5 * rank);
|
|
time = (20 - rate);
|
|
time *= MBServerStatics.ONE_MINUTE;
|
|
|
|
if (ml.templateID > 910010 && ml.templateID < 910019) {
|
|
rank = ml.getTemplateID() - 910010;
|
|
time = rank * 60 * 60 * 3 * 1000;
|
|
|
|
}
|
|
|
|
// No job is submitted, as object's upgradetime field
|
|
// is used to determin whether or not an object has
|
|
// compelted rolling. The game object exists previously
|
|
// to this, not when 'compelte' is pressed.
|
|
long upgradeTime = System.currentTimeMillis() + (long) (time * Float.parseFloat(ConfigManager.MB_PRODUCTION_RATE.getValue()));
|
|
|
|
DateTime dateTime = new DateTime();
|
|
dateTime = dateTime.withMillis(upgradeTime);
|
|
ml.setDateToUpgrade(upgradeTime);
|
|
|
|
npc.addItemToForge(ml);
|
|
|
|
int playerID = 0;
|
|
|
|
if (pc != null)
|
|
playerID = pc.getObjectUUID();
|
|
DbManager.NPCQueries.ADD_TO_PRODUCTION_LIST(ml.getObjectUUID(), npc.getObjectUUID(), ml.getTemplateID(), dateTime, "", "", "", false, playerID);
|
|
ProducedItem pi = new ProducedItem(ml.getObjectUUID(), npc.getObjectUUID(), ml.getTemplateID(), dateTime, false, "", "", "", playerID);
|
|
pi.setProducedItemID(ml.getObjectUUID());
|
|
pi.setAmount(itemsToRoll);
|
|
pi.setRandom(false);
|
|
|
|
ItemQueue produced = ItemQueue.borrow(pi, (long) (time * Float.parseFloat(ConfigManager.MB_PRODUCTION_RATE.getValue())));
|
|
ItemProductionManager.send(produced);
|
|
|
|
return ml;
|
|
}
|
|
|
|
int galvorAmount = 0;
|
|
int wormwoodAmount = 0;
|
|
int prefixCost = 0;
|
|
int suffixCost = 0;
|
|
|
|
if (template.item_type.equals(ItemType.WEAPON) && template.item_skill_required.isEmpty() == false &&
|
|
template.item_skill_required.values().iterator().next() == 110) {
|
|
switch (template.item_skill_used) {
|
|
case "Bow":
|
|
case "Crossbow":
|
|
case "Spear":
|
|
case "Pole Arm":
|
|
case "Staff":
|
|
wormwoodAmount = 20;
|
|
break;
|
|
case "Axe":
|
|
case "Dagger":
|
|
case "Sword":
|
|
case "Hammer":
|
|
case "Unarmed Combat":
|
|
|
|
if (ItemTemplate.isTwoHanded(template))
|
|
galvorAmount = 20;
|
|
else
|
|
galvorAmount = 10;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (galvorAmount > 0 || wormwoodAmount > 0)
|
|
if (!useWarehouse) {
|
|
if (pc != null)
|
|
ErrorPopupMsg.sendErrorMsg(pc, "This item requires resources to roll! Please make sure the forge is protected to access the warehouse." + template.item_base_name);
|
|
return null;
|
|
|
|
}
|
|
|
|
if (galvorAmount > 0) {
|
|
if (Warehouse.isResourceLocked(cityWarehouse, Enum.ResourceType.GALVOR)) {
|
|
if (pc != null)
|
|
ErrorPopupMsg.sendErrorMsg(pc, "Galvor is locked." + template.item_base_name);
|
|
return null;
|
|
}
|
|
|
|
if (cityWarehouse.resources.get(Enum.ResourceType.GALVOR) < galvorAmount) {
|
|
if (pc != null)
|
|
ErrorPopupMsg.sendErrorMsg(pc, "Not enough Galvor in warehouse to roll this item." + template.item_base_name);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
if (wormwoodAmount > 0) {
|
|
if (Warehouse.isResourceLocked(cityWarehouse, Enum.ResourceType.WORMWOOD)) {
|
|
if (pc != null)
|
|
ErrorPopupMsg.sendErrorMsg(pc, "Wormwood is locked." + template.item_base_name);
|
|
return null;
|
|
}
|
|
|
|
if (cityWarehouse.resources.get(Enum.ResourceType.WORMWOOD) < wormwoodAmount) {
|
|
if (pc != null)
|
|
ErrorPopupMsg.sendErrorMsg(pc, "Not enough Wormwood in warehouse to roll this item." + template.item_base_name);
|
|
return null;
|
|
}
|
|
}
|
|
ConcurrentHashMap<Enum.ResourceType, Integer> suffixResourceCosts = null;
|
|
ConcurrentHashMap<Enum.ResourceType, Integer> prefixResourceCosts = null;
|
|
|
|
EffectsBase prefix = null;
|
|
|
|
if (pToken != 0) {
|
|
|
|
if (!useWarehouse) {
|
|
if (pc != null)
|
|
ErrorPopupMsg.sendErrorMsg(pc, "Forge cannot access warehouse! Check to make sure forge is protected." + template.item_base_name);
|
|
return null;
|
|
}
|
|
prefix = PowersManager.getEffectByToken(pToken);
|
|
if (prefix == null)
|
|
return null;
|
|
EffectsBase prefixValue = PowersManager.getEffectByIDString(prefix.getIDString() + 'A');
|
|
if (prefixValue == null)
|
|
return null;
|
|
|
|
int baseCost = template.item_value;
|
|
int effectCost = (int) prefixValue.getValue();
|
|
int total = baseCost * 10 + effectCost;
|
|
|
|
prefixCost = effectCost;
|
|
int overdraft = BuildingManager.GetOverdraft(forge, total);
|
|
|
|
if (overdraft > 0 && !useWarehouse) {
|
|
if (pc != null)
|
|
ErrorPopupMsg.sendErrorMsg(pc, "Not enough gold in building strongbox." + template.item_base_name);
|
|
return null;
|
|
}
|
|
|
|
if (overdraft > 0 && Warehouse.isResourceLocked(cityWarehouse, Enum.ResourceType.GOLD)) {
|
|
if (pc != null)
|
|
ErrorPopupMsg.sendErrorMsg(pc, "Warehouse gold is barred! Overdraft cannot be withdrawn from warehouse." + template.item_base_name);
|
|
return null;
|
|
}
|
|
|
|
if (overdraft > cityWarehouse.resources.get(Enum.ResourceType.GOLD)) {
|
|
if (pc != null)
|
|
ErrorPopupMsg.sendErrorMsg(pc, "Not enough Gold in Warehouse for overdraft." + template.item_base_name);
|
|
return null;
|
|
}
|
|
prefixResourceCosts = prefix.getResourcesForEffect();
|
|
|
|
for (Enum.ResourceType ibResources : prefixResourceCosts.keySet()) {
|
|
int warehouseAmount = cityWarehouse.resources.get(ibResources);
|
|
int creationAmount = prefixResourceCosts.get(ibResources);
|
|
|
|
if (warehouseAmount < creationAmount)
|
|
return null;
|
|
}
|
|
}
|
|
EffectsBase suffix = null;
|
|
|
|
if (sToken != 0) {
|
|
|
|
if (!useWarehouse) {
|
|
if (pc != null)
|
|
ErrorPopupMsg.sendErrorMsg(pc, "Forge cannot access warehouse! Check to make sure forge is protected." + template.item_base_name);
|
|
return null;
|
|
}
|
|
suffix = PowersManager.getEffectByToken(sToken);
|
|
if (suffix == null)
|
|
return null;
|
|
EffectsBase suffixValue = PowersManager.getEffectByIDString(suffix.getIDString() + 'A');
|
|
if (suffixValue == null)
|
|
return null;
|
|
suffixResourceCosts = suffix.getResourcesForEffect();
|
|
int baseCost = template.item_value;
|
|
int effectCost = (int) suffixValue.getValue();
|
|
suffixCost = effectCost;
|
|
int total = baseCost * 10 + effectCost;
|
|
|
|
|
|
// int buildingWithdraw = Building.GetWithdrawAmountForRolling(forge, total);
|
|
int overdraft = BuildingManager.GetOverdraft(forge, total);
|
|
|
|
if (overdraft > 0 && !useWarehouse) {
|
|
if (pc != null)
|
|
ErrorPopupMsg.sendErrorMsg(pc, "Not enough gold in building strongbox." + template.item_base_name);
|
|
return null;
|
|
}
|
|
|
|
if (overdraft > 0 && Warehouse.isResourceLocked(cityWarehouse, Enum.ResourceType.GOLD)) {
|
|
if (pc != null)
|
|
ErrorPopupMsg.sendErrorMsg(pc, "Warehouse gold is barred! Overdraft cannot be withdrawn from warehouse." + template.item_base_name);
|
|
return null;
|
|
}
|
|
|
|
if (overdraft > cityWarehouse.resources.get(ItemBase.GOLD_ITEM_BASE)) {
|
|
if (pc != null)
|
|
ErrorPopupMsg.sendErrorMsg(pc, "Not enough Gold in Warehouse for overdraft." + template.item_base_name);
|
|
return null;
|
|
}
|
|
|
|
|
|
for (Enum.ResourceType ibResources : suffixResourceCosts.keySet()) {
|
|
int warehouseAmount = cityWarehouse.resources.get(ibResources);
|
|
int creationAmount = suffixResourceCosts.get(ibResources);
|
|
|
|
if (warehouseAmount < creationAmount)
|
|
return null;
|
|
}
|
|
}
|
|
|
|
//Check if Total suffix and prefix costs + itemCost can be withdrawn.
|
|
|
|
int costToCreate = suffixCost + prefixCost + template.item_value;
|
|
int buildingWithdraw = BuildingManager.GetWithdrawAmountForRolling(forge, costToCreate);
|
|
|
|
int overdraft = BuildingManager.GetOverdraft(forge, costToCreate);
|
|
|
|
if (overdraft > 0 && !useWarehouse) {
|
|
if (pc != null)
|
|
ErrorPopupMsg.sendErrorMsg(pc, "Not enough gold in building strongbox." + template.item_base_name);
|
|
return null;
|
|
}
|
|
|
|
if (overdraft > 0 && useWarehouse && Warehouse.isResourceLocked(cityWarehouse, Enum.ResourceType.GOLD)) {
|
|
if (pc != null)
|
|
ErrorPopupMsg.sendErrorMsg(pc, "Warehouse gold is barred! Overdraft cannot be withdrawn from warehouse." + template.item_base_name);
|
|
return null;
|
|
}
|
|
|
|
if (useWarehouse && overdraft > cityWarehouse.resources.get(Enum.ResourceType.GOLD)) {
|
|
if (pc != null)
|
|
ErrorPopupMsg.sendErrorMsg(pc, "Not enough Gold in Warehouse for overdraft." + template.item_base_name);
|
|
return null;
|
|
}
|
|
|
|
// if (pc != null){
|
|
// ChatManager.chatGuildInfo(pc.getGuild(), "Building withdraw = " + buildingWithdraw);
|
|
// ChatManager.chatGuildInfo(pc.getGuild(), "Warehouse overdraft withdraw = " + overdraft);
|
|
//
|
|
// ChatManager.chatGuildInfo(pc.getGuild(), "total withdraw = " + (overdraft + buildingWithdraw));
|
|
// }
|
|
|
|
if (!forge.transferGold(-buildingWithdraw, false)) {
|
|
overdraft += buildingWithdraw;
|
|
|
|
if (!useWarehouse) {
|
|
ErrorPopupMsg.sendErrorMsg(pc, "Building does not have enough gold to produce this item." + template.item_base_name);
|
|
return null;
|
|
} else {
|
|
if (overdraft > cityWarehouse.resources.get(ItemBase.GOLD_ITEM_BASE)) {
|
|
ErrorPopupMsg.sendErrorMsg(pc, "Not enough Gold in Warehouse to produce this item." + template.item_base_name);
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (overdraft > 0 && useWarehouse)
|
|
if (!Warehouse.withdraw(cityWarehouse, npc, Enum.ResourceType.GOLD, overdraft, true)) {
|
|
Logger.error("Warehouse for city " + cityWarehouse.city.getName() + " Failed to Create Item." + template.item_base_name);
|
|
return null;
|
|
}
|
|
|
|
|
|
if (prefix != null) {
|
|
|
|
if (!useWarehouse) {
|
|
ErrorPopupMsg.sendErrorMsg(pc, "Cannot Resource Roll without access to the warehouse! Make sure the forge is currently protected." + template.item_base_name);
|
|
return null;
|
|
}
|
|
|
|
|
|
for (Enum.ResourceType ibResources : prefixResourceCosts.keySet()) {
|
|
|
|
int creationAmount = prefixResourceCosts.get(ibResources);
|
|
|
|
if (Warehouse.isResourceLocked(cityWarehouse, ibResources) == true)
|
|
return null;
|
|
|
|
int oldAmount = cityWarehouse.resources.get(ibResources);
|
|
int amount = creationAmount;
|
|
|
|
if (oldAmount < amount)
|
|
amount = oldAmount;
|
|
|
|
if (!Warehouse.withdraw(cityWarehouse, npc, ibResources, amount, true)) {
|
|
//ChatManager.chatGuildError(pc, "Failed to create Item");
|
|
Logger.error("Warehouse for city " + cityWarehouse.city.getName() + " Failed to Create Item." + template.item_base_name);
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (suffix != null) {
|
|
|
|
for (Enum.ResourceType ibResources : suffixResourceCosts.keySet()) {
|
|
int creationAmount = suffixResourceCosts.get(ibResources);
|
|
|
|
if (Warehouse.isResourceLocked(cityWarehouse, ibResources) == true) {
|
|
ChatManager.chatSystemError(pc, "Resource is locked!" + template.item_base_name);
|
|
return null;
|
|
}
|
|
|
|
int oldAmount = cityWarehouse.resources.get(ibResources);
|
|
int amount = creationAmount;
|
|
|
|
if (oldAmount < amount)
|
|
amount = oldAmount;
|
|
|
|
if (!Warehouse.withdraw(cityWarehouse, npc, ibResources, amount, true)) {
|
|
//ChatManager.chatGuildError(pc, "Failed to create Item");
|
|
Logger.error("Warehouse for city " + cityWarehouse.city.getName() + " Failed to Create Item." + template.item_base_name);
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (prefix == null && suffix == null) {
|
|
|
|
int baseCost = template.item_value;
|
|
int total = (int) (baseCost + baseCost * (float) .10);
|
|
|
|
buildingWithdraw = BuildingManager.GetWithdrawAmountForRolling(forge, total);
|
|
|
|
overdraft = BuildingManager.GetOverdraft(forge, total);
|
|
|
|
if (overdraft > 0 && !useWarehouse) {
|
|
|
|
if (pc != null)
|
|
ErrorPopupMsg.sendErrorMsg(pc, "Not enough gold in building strongbox." + template.item_base_name);
|
|
return null;
|
|
}
|
|
|
|
if (overdraft > 0 && Warehouse.isResourceLocked(cityWarehouse, Enum.ResourceType.GOLD)) {
|
|
|
|
if (pc != null)
|
|
ErrorPopupMsg.sendErrorMsg(pc, "Warehouse gold is barred! Overdraft cannot be withdrawn from warehouse." + template.item_base_name);
|
|
return null;
|
|
}
|
|
|
|
if (useWarehouse && overdraft > cityWarehouse.resources.get(Enum.ResourceType.GOLD)) {
|
|
|
|
if (pc != null)
|
|
ErrorPopupMsg.sendErrorMsg(pc, "Not enough Gold in Warehouse for overdraft." + template.item_base_name);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
if (!forge.transferGold(-buildingWithdraw, false)) {
|
|
overdraft += buildingWithdraw;
|
|
|
|
if (!useWarehouse) {
|
|
ErrorPopupMsg.sendErrorMsg(pc, "Building does not have enough gold to produce this item." + template.item_base_name);
|
|
return null;
|
|
} else {
|
|
if (overdraft > cityWarehouse.resources.get(Enum.ResourceType.GOLD)) {
|
|
ErrorPopupMsg.sendErrorMsg(pc, "Not enough Gold in Warehouse to produce this item." + template.item_base_name);
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (overdraft > 0)
|
|
if (!Warehouse.withdraw(cityWarehouse, npc, Enum.ResourceType.GOLD, overdraft, true)) {
|
|
//ChatManager.chatGuildError(pc, "Failed to create Item");
|
|
Logger.error("Warehouse for city " + cityWarehouse.city.getName() + " Failed to Create Item." + template.item_base_name);
|
|
return null;
|
|
}
|
|
|
|
// ChatManager.chatGuildInfo(pc, "Gold Cost = " + total);
|
|
|
|
if (galvorAmount > 0) {
|
|
if (!Warehouse.withdraw(cityWarehouse, npc, Enum.ResourceType.GALVOR, galvorAmount, true)) {
|
|
ErrorPopupMsg.sendErrorMsg(pc, "Failed to withdraw Galvor from warehouse!" + template.item_base_name);
|
|
Logger.error("Warehouse for city " + cityWarehouse.city.getName() + "Failed to Withdrawl ");
|
|
return null;
|
|
}
|
|
}
|
|
|
|
if (wormwoodAmount > 0) {
|
|
if (!Warehouse.withdraw(cityWarehouse, npc, Enum.ResourceType.WORMWOOD, wormwoodAmount, true)) {
|
|
ErrorPopupMsg.sendErrorMsg(pc, "Failed to withdraw Wormwood from warehouse!" + template.item_base_name);
|
|
Logger.error("Warehouse for city " + cityWarehouse.city.getName() + "Failed to Withdrawl ");
|
|
return null;
|
|
}
|
|
}
|
|
|
|
ml = new MobLoot(npc, template, false);
|
|
|
|
ml.containerType = Enum.ItemContainerType.FORGE;
|
|
|
|
if (customName.isEmpty() == false)
|
|
ml.name = customName;
|
|
|
|
if (prefix != null) {
|
|
ml.addPermanentEnchantment(prefix.getIDString(), 0, 0, true);
|
|
ml.setPrefix(prefix.getIDString());
|
|
prefixString = prefix.getIDString();
|
|
}
|
|
|
|
if (suffix != null) {
|
|
ml.addPermanentEnchantment(suffix.getIDString(), 0, 0, false);
|
|
ml.setSuffix(suffix.getIDString());
|
|
suffixString = suffix.getIDString();
|
|
}
|
|
|
|
ml.loadEnchantments();
|
|
//set value to 0 so magicvalue can be recalculated in getValue.
|
|
ml.setValue(0);
|
|
|
|
float time;
|
|
float rank = npc.getBuilding().getRank() - 1;
|
|
float rate = (float) (2.5 * rank);
|
|
time = (20 - rate);
|
|
time *= MBServerStatics.ONE_MINUTE;
|
|
|
|
if (ml.getItemBase().getUUID() > 910010 && ml.getItemBase().getUUID() < 910019) {
|
|
rank = ml.getTemplateID() - 910010;
|
|
time = rank * 60 * 60 * 3 * 1000;
|
|
}
|
|
|
|
|
|
// No job is submitted, as object's upgradetime field
|
|
// is used to determin whether or not an object has
|
|
// compelted rolling. The game object exists previously
|
|
// to this, not when 'compelte' is pressed.
|
|
long upgradeTime = System.currentTimeMillis() + (long) (time * Float.parseFloat(ConfigManager.MB_PRODUCTION_RATE.getValue()));
|
|
|
|
DateTime dateTime = new DateTime();
|
|
dateTime = dateTime.withMillis(upgradeTime);
|
|
ml.setDateToUpgrade(upgradeTime);
|
|
|
|
npc.addItemToForge(ml);
|
|
int playerID = 0;
|
|
|
|
if (pc != null)
|
|
playerID = pc.getObjectUUID();
|
|
|
|
DbManager.NPCQueries.ADD_TO_PRODUCTION_LIST(ml.getObjectUUID(), npc.getObjectUUID(), ml.getTemplateID(), dateTime, prefixString, suffixString, ml.name, false, playerID);
|
|
ProducedItem pi = new ProducedItem(npc.getRolling().size(), npc.getObjectUUID(), ml.getTemplateID(), dateTime, false, prefixString, suffixString, ml.name, playerID);
|
|
pi.setProducedItemID(ml.getObjectUUID());
|
|
pi.setAmount(itemsToRoll);
|
|
|
|
ItemQueue produced = ItemQueue.borrow(pi, (long) (time * Float.parseFloat(ConfigManager.MB_PRODUCTION_RATE.getValue())));
|
|
ItemProductionManager.send(produced);
|
|
} catch (Exception e) {
|
|
Logger.error(e);
|
|
} finally {
|
|
city.transactionLock.writeLock().unlock();
|
|
}
|
|
|
|
|
|
// npc.addItemToForge(item);
|
|
return ml;
|
|
|
|
}
|
|
|
|
|
|
public static Item randomRoll(NPC vendor, PlayerCharacter playerCharacter, int itemsToRoll, int itemBaseID) {
|
|
byte itemModTable;
|
|
int prefixMod = 0;
|
|
int suffixMod = 0;
|
|
String prefix = "";
|
|
String suffix = "";
|
|
|
|
ModTableEntry prefixEntry = null;
|
|
ModTableEntry suffixEntry = null;
|
|
|
|
ItemBase ib = ItemBase.getItemBase(itemBaseID);
|
|
ItemTemplate template = ItemTemplate.templates.get(itemBaseID);
|
|
|
|
if (template == null)
|
|
return null;
|
|
|
|
if (!vendor.charItemManager.hasRoomInventory(template.item_wt)) {
|
|
|
|
if (playerCharacter != null)
|
|
ChatManager.chatSystemInfo(playerCharacter, vendor.getName() + " " + vendor.getContract().getName() + " Inventory is full.");
|
|
|
|
return null;
|
|
}
|
|
|
|
itemModTable = (byte) ib.getModTable();
|
|
|
|
if (!vendor.getItemModTable().contains(itemModTable)) {
|
|
|
|
if (playerCharacter != null)
|
|
ErrorPopupMsg.sendErrorPopup(playerCharacter, 59);
|
|
|
|
return null;
|
|
}
|
|
|
|
for (byte temp : vendor.getItemModTable()) {
|
|
|
|
if (itemModTable != temp)
|
|
continue;
|
|
|
|
prefixMod = vendor.getModTypeTable().get(vendor.getItemModTable().indexOf(temp));
|
|
suffixMod = vendor.getModSuffixTable().get(vendor.getItemModTable().indexOf(temp));
|
|
}
|
|
|
|
if (prefixMod == 0 && suffixMod == 0) {
|
|
Logger.info("Failed to find modTables for item " + template.item_base_name);
|
|
return null;
|
|
}
|
|
|
|
// Roll on the tables for this vendor
|
|
|
|
ModTypeTableEntry prefixTypeTable = ModTypeTableEntry.rollTable(prefixMod, ThreadLocalRandom.current().nextInt(1, 100 + 1));
|
|
ModTypeTableEntry suffixTypeTable = ModTypeTableEntry.rollTable(suffixMod, ThreadLocalRandom.current().nextInt(1, 100 + 1));
|
|
|
|
// Sanity check.
|
|
|
|
if (prefixTypeTable == null || suffixTypeTable == null)
|
|
return null;
|
|
|
|
int rollPrefix = ThreadLocalRandom.current().nextInt(1, 100 + 1);
|
|
|
|
if (rollPrefix < 80) {
|
|
|
|
int randomPrefix = LootManager.TableRoll(vendor.getLevel(), false);
|
|
prefixEntry = ModTableEntry.rollTable(prefixTypeTable.modTableID, randomPrefix);
|
|
|
|
if (prefixEntry != null)
|
|
prefix = prefixEntry.action;
|
|
|
|
}
|
|
|
|
int rollSuffix = ThreadLocalRandom.current().nextInt(1, 100 + 1);
|
|
|
|
// Always have at least one mod on a magic rolled item.
|
|
// Suffix will be our backup plan.
|
|
|
|
if (rollSuffix < 80 || prefixEntry == null) {
|
|
|
|
int randomSuffix = LootManager.TableRoll(vendor.getLevel(), false);
|
|
suffixEntry = ModTableEntry.rollTable(suffixTypeTable.modTableID, randomSuffix);
|
|
|
|
if (suffixEntry != null)
|
|
suffix = suffixEntry.action;
|
|
}
|
|
|
|
MobLoot toRoll = ItemFactory.produceRandomRoll(vendor, playerCharacter, prefix, suffix, itemBaseID);
|
|
|
|
if (toRoll == null)
|
|
return null;
|
|
|
|
toRoll.setValue(0);
|
|
|
|
float time;
|
|
float rank = vendor.getBuilding().getRank() - 1;
|
|
float rate = (float) (2.5 * rank);
|
|
time = (20 - rate);
|
|
time *= MBServerStatics.ONE_MINUTE;
|
|
|
|
if (toRoll.getItemBase().getUUID() > 910010 && toRoll.getItemBase().getUUID() < 910019) {
|
|
rank = toRoll.getTemplateID() - 910010;
|
|
time = rank * 60 * 60 * 3 * 1000;
|
|
}
|
|
|
|
// No job is submitted, as object's upgradetime field
|
|
// is used to determine whether an object has
|
|
// completed rolling. The game object exists previously
|
|
// to this, not when 'complete' is pressed.
|
|
|
|
long upgradeTime = System.currentTimeMillis() + (long) (time * Float.parseFloat(ConfigManager.MB_PRODUCTION_RATE.getValue()));
|
|
|
|
DateTime dateTime = new DateTime();
|
|
dateTime = dateTime.withMillis(upgradeTime);
|
|
toRoll.setDateToUpgrade(upgradeTime);
|
|
|
|
int playerID = 0;
|
|
|
|
if (playerCharacter != null)
|
|
playerID = playerCharacter.getObjectUUID();
|
|
|
|
DbManager.NPCQueries.ADD_TO_PRODUCTION_LIST(toRoll.getObjectUUID(), vendor.getObjectUUID(), toRoll.getTemplateID(), dateTime, prefix, suffix, toRoll.name, true, playerID);
|
|
|
|
ProducedItem pi = new ProducedItem(toRoll.getObjectUUID(), vendor.getObjectUUID(), toRoll.getTemplateID(), dateTime, true, prefix, suffix, toRoll.name, playerID);
|
|
pi.setProducedItemID(toRoll.getObjectUUID());
|
|
pi.setAmount(itemsToRoll);
|
|
ItemQueue produced = ItemQueue.borrow(pi, (long) (time * Float.parseFloat(ConfigManager.MB_PRODUCTION_RATE.getValue())));
|
|
ItemProductionManager.send(produced);
|
|
|
|
return toRoll;
|
|
}
|
|
|
|
public static MobLoot produceRandomRoll(NPC npc, PlayerCharacter pc, String prefixString, String suffixString, int templateID) {
|
|
|
|
boolean useWarehouse = false;
|
|
|
|
if (npc == null)
|
|
return null;
|
|
|
|
ItemTemplate template = ItemTemplate.templates.get(templateID);
|
|
|
|
Building forge = npc.getBuilding();
|
|
|
|
if (forge == null)
|
|
return null;
|
|
|
|
Zone zone = npc.getBuilding().getParentZone();
|
|
|
|
if (zone == null)
|
|
return null;
|
|
|
|
City city = City.getCity(zone.playerCityUUID);
|
|
|
|
if (city == null)
|
|
return null;
|
|
|
|
MobLoot ml = null;
|
|
city.transactionLock.writeLock().lock();
|
|
|
|
try {
|
|
|
|
|
|
Warehouse cityWarehouse = city.warehouse;
|
|
|
|
if (cityWarehouse != null && forge.assetIsProtected())
|
|
useWarehouse = true;
|
|
|
|
ConcurrentHashMap<Enum.ResourceType, Integer> resources = null;
|
|
|
|
if (useWarehouse)
|
|
resources = cityWarehouse.resources;
|
|
|
|
int galvorAmount = 0;
|
|
int wormwoodAmount = 0;
|
|
|
|
if (template.item_type.equals(ItemType.WEAPON) && template.item_skill_required.isEmpty() == false &&
|
|
template.item_skill_required.values().iterator().next() == 110) {
|
|
switch (template.item_skill_used) {
|
|
case "Bow":
|
|
case "Crossbow":
|
|
case "Spear":
|
|
case "Pole Arm":
|
|
case "Staff":
|
|
wormwoodAmount = 22;
|
|
break;
|
|
case "Axe":
|
|
case "Dagger":
|
|
case "Sword":
|
|
case "Hammer":
|
|
case "Unarmed Combat":
|
|
|
|
if (ItemTemplate.isTwoHanded(template))
|
|
galvorAmount = 22;
|
|
else
|
|
galvorAmount = 11;
|
|
break;
|
|
}
|
|
}
|
|
|
|
//Cant roll 110% weapons that require resources if not allowed to use warehouse.
|
|
if (galvorAmount > 0 || wormwoodAmount > 0)
|
|
if (!useWarehouse)
|
|
return null;
|
|
|
|
if (galvorAmount > 0) {
|
|
if (Warehouse.isResourceLocked(cityWarehouse, Enum.ResourceType.GALVOR)) {
|
|
ErrorPopupMsg.sendErrorMsg(pc, "Galvor is locked." + template.item_base_name);
|
|
return null;
|
|
}
|
|
|
|
if (cityWarehouse.resources.get(Enum.ResourceType.GALVOR) < galvorAmount) {
|
|
ErrorPopupMsg.sendErrorMsg(pc, "Not enough Galvor in warehouse to roll this item." + template.item_base_name);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
if (wormwoodAmount > 0) {
|
|
if (Warehouse.isResourceLocked(cityWarehouse, Enum.ResourceType.WORMWOOD)) {
|
|
ErrorPopupMsg.sendErrorMsg(pc, "Galvor is locked." + template.item_base_name);
|
|
return null;
|
|
}
|
|
|
|
if (cityWarehouse.resources.get(Enum.ResourceType.WORMWOOD) < wormwoodAmount) {
|
|
ErrorPopupMsg.sendErrorMsg(pc, "Not enough Galvor in warehouse to roll this item." + template.item_base_name);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
EffectsBase prefix = null;
|
|
|
|
if (!prefixString.isEmpty()) {
|
|
prefix = PowersManager.getEffectByIDString(prefixString);
|
|
if (prefix == null)
|
|
return null;
|
|
}
|
|
|
|
int baseCost = template.item_value;
|
|
int total = (int) (baseCost + baseCost * .10);
|
|
|
|
EffectsBase suffix = null;
|
|
|
|
if (!suffixString.isEmpty()) {
|
|
suffix = PowersManager.getEffectByIDString(suffixString);
|
|
|
|
if (suffix == null)
|
|
return null;
|
|
}
|
|
|
|
//calculate gold costs and remove from the warehouse
|
|
if (prefix != null || suffix != null) {
|
|
int costToCreate = (int) (template.item_value + template.item_value * .10f);
|
|
int buildingWithdraw = BuildingManager.GetWithdrawAmountForRolling(forge, costToCreate);
|
|
int overdraft = BuildingManager.GetOverdraft(forge, costToCreate);
|
|
|
|
if (overdraft > 0 && !useWarehouse) {
|
|
ErrorPopupMsg.sendErrorMsg(pc, "Not enough gold in building strongbox." + template.item_base_name);
|
|
return null;
|
|
}
|
|
|
|
if (useWarehouse && overdraft > 0 && Warehouse.isResourceLocked(cityWarehouse, Enum.ResourceType.GOLD)) {
|
|
if (pc != null)
|
|
ErrorPopupMsg.sendErrorMsg(pc, "Warehouse gold is barred! Overdraft cannot be withdrawn from warehouse." + template.item_base_name);
|
|
return null;
|
|
}
|
|
|
|
if (useWarehouse && overdraft > resources.get(Enum.ResourceType.GOLD)) {
|
|
ErrorPopupMsg.sendErrorMsg(pc, "Not enough Gold in Warehouse for overdraft." + template.item_base_name);
|
|
return null;
|
|
}
|
|
|
|
if (!forge.transferGold(-buildingWithdraw, false)) {
|
|
overdraft += buildingWithdraw;
|
|
|
|
if (!useWarehouse) {
|
|
ErrorPopupMsg.sendErrorMsg(pc, "Building does not have enough gold to produce this item." + template.item_base_name);
|
|
return null;
|
|
} else {
|
|
if (overdraft > resources.get(Enum.ResourceType.GOLD)) {
|
|
ErrorPopupMsg.sendErrorMsg(pc, "Not enough Gold in Warehouse to produce this item." + template.item_base_name);
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
|
|
// there was an overdraft, withdraw the rest from warehouse.
|
|
if (overdraft > 0) {
|
|
if (pc != null) {
|
|
if (!Warehouse.withdraw(cityWarehouse, pc, Enum.ResourceType.GOLD, overdraft, false, true)) {
|
|
Logger.error("Warehouse for city " + cityWarehouse.city.getName() + "Failed to Withdrawl ");
|
|
return null;
|
|
}
|
|
} else {
|
|
if (!Warehouse.withdraw(cityWarehouse, npc, Enum.ResourceType.GOLD, overdraft, true)) {
|
|
Logger.error("Warehouse for city " + cityWarehouse.city.getName() + "Failed to Withdrawl ");
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (prefix == null && suffix == null) {
|
|
|
|
int buildingWithdraw = BuildingManager.GetWithdrawAmountForRolling(forge, total);
|
|
int overdraft = BuildingManager.GetOverdraft(forge, total);
|
|
|
|
if (overdraft > 0 && !useWarehouse) {
|
|
ErrorPopupMsg.sendErrorMsg(pc, "Not enough gold in building strongbox." + template.item_base_name);
|
|
return null;
|
|
}
|
|
|
|
if (useWarehouse && overdraft > 0 && Warehouse.isResourceLocked(cityWarehouse, Enum.ResourceType.GOLD)) {
|
|
if (pc != null)
|
|
ErrorPopupMsg.sendErrorMsg(pc, "Warehouse gold is barred! Overdraft cannot be withdrawn from warehouse." + template.item_base_name);
|
|
return null;
|
|
}
|
|
|
|
if (useWarehouse && overdraft > resources.get(Enum.ResourceType.GOLD)) {
|
|
ErrorPopupMsg.sendErrorMsg(pc, "Not enough Gold in Warehouse for overdraft." + template.item_base_name);
|
|
return null;
|
|
}
|
|
|
|
if (!forge.transferGold(-buildingWithdraw, false)) {
|
|
overdraft += buildingWithdraw;
|
|
|
|
if (!useWarehouse) {
|
|
ErrorPopupMsg.sendErrorMsg(pc, "Building does not have enough gold to produce this item." + template.item_base_name);
|
|
return null;
|
|
} else {
|
|
if (overdraft > resources.get(Enum.ResourceType.GOLD)) {
|
|
ErrorPopupMsg.sendErrorMsg(pc, "Not enough Gold in Warehouse to produce this item." + template.item_base_name);
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (overdraft > 0 && useWarehouse) {
|
|
|
|
if (pc != null) {
|
|
if (!Warehouse.withdraw(cityWarehouse, pc, Enum.ResourceType.GOLD, overdraft, false, true)) {
|
|
Logger.error("Warehouse for city " + cityWarehouse.city.getName() + "Failed to Withdrawl ");
|
|
return null;
|
|
}
|
|
} else {
|
|
if (!Warehouse.withdraw(cityWarehouse, npc, Enum.ResourceType.GOLD, overdraft, true)) {
|
|
Logger.error("Warehouse for city " + cityWarehouse.city.getName() + "Failed to Withdrawl ");
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (galvorAmount > 0 && useWarehouse) {
|
|
//ChatManager.chatGuildInfo(pc, "Withdrawing " + galvorAmount + " galvor from warehouse");
|
|
if (!Warehouse.withdraw(cityWarehouse, npc, Enum.ResourceType.GALVOR, galvorAmount, true)) {
|
|
ErrorPopupMsg.sendErrorMsg(pc, "Failed to withdraw Galvor from warehouse!" + template.item_base_name);
|
|
Logger.error("Warehouse for city " + cityWarehouse.city.getName() + "Failed to Withdrawl ");
|
|
return null;
|
|
}
|
|
}
|
|
|
|
if (wormwoodAmount > 0 && useWarehouse) {
|
|
//ChatManager.chatGuildInfo(pc, "Withdrawing " + wormwoodAmount + " wormwood from warehouse");
|
|
if (!Warehouse.withdraw(cityWarehouse, npc, Enum.ResourceType.WORMWOOD, wormwoodAmount, true)) {
|
|
ErrorPopupMsg.sendErrorMsg(pc, "Failed to withdraw Wormwood from warehouse for " + template.item_base_name);
|
|
Logger.error("Warehouse for city " + cityWarehouse.city.getName() + "Failed to Withdrawl ");
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
ml = new MobLoot(npc, template, false);
|
|
|
|
ml.containerType = Enum.ItemContainerType.FORGE;
|
|
|
|
if (prefix != null) {
|
|
ml.addPermanentEnchantment(prefix.getIDString(), 0, 0, true);
|
|
ml.setPrefix(prefix.getIDString());
|
|
}
|
|
|
|
if (suffix != null) {
|
|
ml.addPermanentEnchantment(suffix.getIDString(), 0, 0, false);
|
|
ml.setSuffix(suffix.getIDString());
|
|
}
|
|
|
|
ml.loadEnchantments();
|
|
|
|
|
|
ml.setValue(0);
|
|
ml.setRandom(true);
|
|
npc.addItemToForge(ml);
|
|
} catch (Exception e) {
|
|
Logger.error(e);
|
|
} finally {
|
|
city.transactionLock.writeLock().unlock();
|
|
}
|
|
return ml;
|
|
|
|
}
|
|
}
|