public static ErrorCodes GetInsurancePrice(int definition, ref double insuranceFee, ref double insurancePayOut)
{
var ec = ErrorCodes.NoError;
insuranceFee = 0;
insurancePayOut = 0;
InsurancePrice insurancePrice;
if (_insurancePrices.TryGetValue(definition, out insurancePrice))
{
if (insurancePrice == null)
{
return(ErrorCodes.WTFErrorMedicalAttentionSuggested);
}
}
else
{
var record = Db.Query().CommandText("select fee,payout from insuranceprices where definition=@definition").SetParameter("@definition", definition)
.ExecuteSingleRow();
if (record == null)
{
_insurancePrices.AddOrUpdate(definition, o => null, (k, v) => null);
Logger.Info("no record was found for definition: " + definition + " " + EntityDefault.Get(definition).Name);
return(ErrorCodes.WTFErrorMedicalAttentionSuggested);
}
insurancePrice = new InsurancePrice
{
definition = definition,
fee = record.GetValue <double>(0),
payOut = record.GetValue <double>(1)
};
_insurancePrices.AddOrUpdate(definition, insurancePrice, (k, v) => v);
}
insuranceFee = insurancePrice.fee;
insurancePayOut = insurancePrice.payOut;
return(ec);
}
public static ErrorCodes ReserveComponents_noSQL(IEnumerable <ProductionLiveComponent> itemsNeeded, long storageEid, Container container, out long[] reservedItems)
{
var ec = ErrorCodes.NoError;
var reservedList = new List <long>();
reservedItems = null;
foreach (var plc in itemsNeeded)
{
//load the component
var component = container.GetItem(plc.eid, true);
if (component == null)
{
ec = ErrorCodes.ItemNotFound;
return(ec);
}
if (plc.resultQuantity == 0)
{
//the component will be completely used for the manufacture
//put it into the storage
if (!container.RemoveItemFromTree(component))
{
return(ErrorCodes.ItemNotFound);
}
component.Parent = storageEid;
reservedList.Add(component.Eid); //this is the item we put into the storage
component.Save();
}
else
{
//create a portion of the component
var componentPortion = component.Unstack(plc.quantity - plc.resultQuantity);
componentPortion.Parent = storageEid;
//save the component portion
componentPortion.Save();
reservedList.Add(componentPortion.Eid);
}
}
reservedItems = reservedList.ToArray();
//---------------------------------------------DEBUG OUTPUT-------------------------------------
var outputDict = new Dictionary <string, int>();
foreach (var comp in itemsNeeded)
{
var defname = EntityDefault.Get(comp.definition).Name;
var quantityUsed = comp.resultQuantity == 0 ? comp.quantity : comp.quantity - comp.resultQuantity;
if (outputDict.ContainsKey(defname))
{
outputDict[defname] += quantityUsed;
}
else
{
outputDict[defname] = quantityUsed;
}
}
Logger.Info("items used for production: ----------------------------------");
foreach (var pair in outputDict)
{
Logger.Info(pair.Key + " " + pair.Value);
}
Logger.Info("-------------------------------------------------------------");
return(ec);
}
private IDictionary <string, object> EndMassProduction(ProductionInProgress productionInProgress, bool forced)
{
Logger.Info("mass production finished: " + productionInProgress);
//delete the used items
foreach (var item in productionInProgress.GetReservedItems())
{
productionInProgress.character.LogTransaction(TransactionLogEvent.Builder()
.SetTransactionType(TransactionType.MassProductionDeleted)
.SetCharacter(productionInProgress.character)
.SetItem(item));
Repository.Delete(item);
}
//pick the output defintion---------------------------------------------------
var outputDefinition = productionInProgress.resultDefinition;
//load container
var container = (PublicContainer)Container.GetOrThrow(PublicContainerEid);
container.ReloadItems(productionInProgress.character);
var outputDefault = EntityDefault.Get(outputDefinition).ThrowIfEqual(EntityDefault.None, ErrorCodes.DefinitionNotSupported);
//create item
var resultItem = container.CreateAndAddItem(outputDefinition, false, item =>
{
item.Owner = productionInProgress.character.Eid;
item.Quantity = outputDefault.Quantity * productionInProgress.amountOfCycles;
});
productionInProgress.character.WriteItemTransactionLog(TransactionType.MassProductionCreated, resultItem);
CalibrationProgram calibrationProgram;
var wasLineDead = false;
var affectedProductionLine = DecalibrateLine(productionInProgress, ref wasLineDead, out calibrationProgram);
if (affectedProductionLine == null)
{
Logger.Error("EndMassProduction: a production line was not found for an ending productionInProgress " + productionInProgress);
}
else
{
if (!forced && !wasLineDead)
{
if (affectedProductionLine.Rounds >= 1)
{
//do production rounds
//ThreadPoolHelper.ScheduledTask(3000, () => TryNextRound(productionInProgress.character, affectedProductionLine.ID, productionInProgress.amountOfCycles, productionInProgress.useCorporationWallet));
var nrp = new NextRoundProduction(ProductionProcessor, productionInProgress.character, affectedProductionLine.Id, productionInProgress.amountOfCycles, productionInProgress.useCorporationWallet, Eid);
ProductionProcessor.EnqueueNextRoundProduction(nrp);
}
}
}
//mission stuff
if (outputDefault.CategoryFlags.IsCategory(CategoryFlags.cf_generic_random_items))
{
var randomCalibrationProgram = calibrationProgram as RandomCalibrationProgram;
if (randomCalibrationProgram != null)
{
//set it from the ct
resultItem.Quantity = randomCalibrationProgram.TargetQuantity;
Logger.Info("mission quantity is forced from CPRG:" + randomCalibrationProgram.Eid + " qty:" + randomCalibrationProgram.TargetQuantity);
}
}
container.Save();
//get list in order to return
var linesList = GetLinesList(productionInProgress.character);
Logger.Info("Mass Production created an item: " + resultItem + " production:" + productionInProgress);
var replyDict = new Dictionary <string, object>
{
{ k.result, resultItem.BaseInfoToDictionary() },
{ k.lines, linesList },
{ k.lineCount, linesList.Count }
};
ProductionProcessor.EnqueueProductionMissionTarget(MissionTargetType.massproduce, productionInProgress.character, MyMissionLocationId(), resultItem.Definition, resultItem.Quantity);
return(replyDict);
}
public static Dictionary <string, object> Build(IExtensionReader extensionReader, IRobotTemplateRelations robotTemplateRelations, EntityDefault ed)
{
var info = ed.ToDictionary();
try
{
Entity entity = null;
var robotTemplate = robotTemplateRelations.GetRelatedTemplate(ed);
if (robotTemplate != null)
{
entity = robotTemplate.Build();
}
if (entity == null)
{
entity = Entity.Factory.CreateWithRandomEID(ed);
}
var item = entity as Item;
item?.Initialize();
var builder = new InfoBuilder(extensionReader, info);
entity.AcceptVisitor(builder);
}
catch (Exception ex)
{
Logger.Error($"troubled definition: {ed.Definition} {ex.Message}");
Logger.Error($"{ex}\n{ex.Message}\n{ex.Source}\n{ex.InnerException?.Message}\n{ex.StackTrace}\n");
}
return(info);
}
private RobotSetup(EntityDefault robotShell, EntityDefault head, EntityDefault chassis, EntityDefault leg, EntityDefault container, EntityDefault hybridShell)
{
_robotShell = robotShell;
_head = head;
_chassis = chassis;
_leg = leg;
_container = container;
_hybridShell = hybridShell;
}
private static void CollectHangarRent(IStandingHandler standingHandler)
{
var storage = EntityDefault.GetByName(DefinitionNames.PUBLIC_CORPORATE_HANGARS_STORAGE);
var hangarEids = Db.Query().CommandText("select eid from entities where parent in (SELECT eid FROM dbo.getLiveDockingbaseChildren() WHERE definition=@hangarDef) order by parent")
.SetParameter("@hangarDef", storage.Definition)
.Execute()
.Select(h => (CorporateHangar)GetOrThrow(h.GetValue <long>(0)))
.ToArray();
Logger.Info("--- hangars collected for rent check: " + hangarEids.Count());
using (var scope = Db.CreateTransaction())
{
try
{
foreach (var hangar in hangarEids)
{
var hangarStorage = hangar.GetHangarStorage();
switch (hangarStorage.GetParentDockingBase())
{
case Outpost outpost:
{
var siteInfo = outpost.GetIntrusionSiteInfo();
if (siteInfo?.Owner != null)
{
//it has an owner
if (hangar.Owner != siteInfo.Owner)
{
//the owner is not the hangar's owner
var dockingStandingLimit = siteInfo.DockingStandingLimit;
if (dockingStandingLimit != null)
{
//the outpost has standing limit set
var standingTowardsOwner = standingHandler.GetStanding((long)siteInfo.Owner, hangar.Owner);
if (standingTowardsOwner < dockingStandingLimit)
{
//the hangar is inaccessible
Logger.Info("hangar is inaccessible for corp. " + hangar.Owner + " hangaried:" + hangar.Eid + " standing:" + standingTowardsOwner + " dockingStandingLimit:" + dockingStandingLimit);
continue;
}
}
}
}
break;
}
case PBSDockingBase pbsDockingBase:
{
if (pbsDockingBase.StandingEnabled)
{
var standingTowardsOwner = standingHandler.GetStanding(pbsDockingBase.Owner, hangar.Owner);
if (standingTowardsOwner < pbsDockingBase.StandingLimit)
{
Logger.Info("hangar is inaccessible for corp. " + hangar.Owner + " hangaried:" + hangar.Eid + " standing:" + standingTowardsOwner + " dockingStandingLimit:" + pbsDockingBase.StandingLimit);
continue;
}
}
break;
}
}
var rentInfo = hangarStorage.GetCorporationHangarRentInfo();
// rent expired?
if (hangar.IsLeaseExpired)
{
continue;
}
if (DateTime.Now > hangar.LeaseEnd)
{
var corporation = hangar.GetCorporation();
Logger.Info("--- hangar rent process started for hangarEID:" + hangar.Eid + " hangarName:" + hangar.Name + " corporaration:" + corporation.Eid + " corpname:" + corporation.Description.name);
var wallet = new CorporationWallet(corporation);
if (wallet.Balance < rentInfo.price)
{
Logger.Info("--- corporation is broken. corporationEID:" + corporation.Eid + " hangar closed. EID:" + hangar.Eid);
//corporation broken
hangar.IsLeaseExpired = true; //block the hangar's content
//alert accountants
var info = new Dictionary <string, object> {
{ k.containerEID, hangar.Eid }
};
Message.Builder.SetCommand(Commands.CorporationHangarRentExpired)
.WithData(info)
.ToCorporation(corporation, CorporationRole.Accountant)
.Send();
}
else
{
wallet.Balance -= rentInfo.price;
var b = TransactionLogEvent.Builder()
.SetCorporation(corporation)
.SetTransactionType(TransactionType.hangarRentAuto)
.SetCreditBalance(wallet.Balance)
.SetCreditChange(-rentInfo.price);
corporation.LogTransaction(b);
hangarStorage.GetParentDockingBase().AddCentralBank(TransactionType.hangarRentAuto, rentInfo.price);
hangar.LeaseStart = DateTime.Now;
hangar.LeaseEnd = DateTime.Now + rentInfo.period;
hangar.IsLeaseExpired = false;
Logger.Info("--- hangar price paid. hangarEID: " + hangar.Eid + " lease ended:" + hangar.LeaseEnd + " lease extened:" + hangar.LeaseEnd);
}
hangar.Save();
}
else
{
Logger.Info("--- hangar still paid. eid:" + hangar.Eid + " lease end:" + hangar.LeaseEnd);
}
}
scope.Complete();
}
catch (Exception ex)
{
Logger.Exception(ex);
}
}
}
/// <summary>
/// This spawns the reward items for the config missions
/// </summary>
/// <param name="mission"></param>
/// <param name="missionInProgress"></param>
private static void SpawnStartItemsForConfigMissions(Mission mission, MissionInProgress missionInProgress)
{
if (!mission.StartItems.Any())
{
return;
}
var container = missionInProgress.myLocation.GetContainer;
var startItems = new List <Item>();
foreach (var itemInfo in mission.StartItems)
{
var ed = EntityDefault.Get(itemInfo.Definition);
if (ed.AttributeFlags.NonStackable)
{
//give one by one the nonstackable
for (var i = 0; i < itemInfo.Quantity; i++)
{
var startItem = container.CreateAndAddItem(itemInfo.Definition, false, item =>
{
item.Owner = missionInProgress.character.Eid;
item.Quantity = 1;
});
startItems.Add(startItem);
}
}
else
{
//these ones are also nonstacked just for the clarity, so the player sees the items separately
var info = itemInfo;
var startItem = container.CreateAndAddItem(itemInfo.Definition, false, item =>
{
item.Owner = missionInProgress.character.Eid;
item.Quantity = info.Quantity;
});
startItems.Add(startItem);
}
}
container.Save();
if (startItems.Count <= 0)
{
return;
}
var startItemsDict = startItems.ToDictionary("i", i => i.ToDictionary());
var result = new Dictionary <string, object>(2)
{
{ k.locationID, missionInProgress.myLocation.id },
{ k.startItems, startItemsDict },
};
Transaction.Current.OnCommited(() =>
{
Message.Builder.SetCommand(Commands.MissionStartItems)
.WithData(result)
.ToCharacter(missionInProgress.character)
.Send();
});
}
public static void GetCalibrationDefault(this IProductionDataAccess dataAccess, EntityDefault ed, out int materialEfficiency, out int timeEfficiency)
{
dataAccess.GetCalibrationDefault(ed.Definition, out materialEfficiency, out timeEfficiency);
}
public ErrorCodes StartResearch(Character character, int researchTimeSeconds, Item sourceItem, ResearchKit researchKit, bool useCorporationWallet, out ProductionInProgress newProduction)
{
newProduction = ProductionInProgressFactory();
var itemsList = new [] { researchKit, sourceItem };
ItemResearchLevel itemResearchLevel;
if (!ProductionDataAccess.ResearchLevels.TryGetValue(sourceItem.Definition, out itemResearchLevel))
{
Logger.Error("consistency error. no research level or calibration program was defined for " + EntityDefault.Get(sourceItem.Definition).Name + " " + sourceItem.Definition);
return(ErrorCodes.ServerError);
}
if (itemResearchLevel.calibrationProgramDefinition == null)
{
Logger.Error("consistency error. CPRG definition is NULL for " + EntityDefault.Get(sourceItem.Definition).Name + " " + sourceItem.Definition);
return(ErrorCodes.ServerError);
}
var cprgDefiniton = (int)itemResearchLevel.calibrationProgramDefinition;
MoveItemsToStorage(itemsList);
newProduction = ProductionInProgressFactory();
newProduction.startTime = DateTime.Now;
newProduction.finishTime = DateTime.Now.AddSeconds(researchTimeSeconds);
newProduction.type = ProductionInProgressType.research;
newProduction.character = character;
newProduction.facilityEID = Eid;
newProduction.resultDefinition = cprgDefiniton;
newProduction.totalProductionTimeSeconds = researchTimeSeconds;
newProduction.baseEID = Parent;
newProduction.pricePerSecond = GetPricePerSecond();
newProduction.ReservedEids = (from i in itemsList select i.Eid).ToArray();
newProduction.useCorporationWallet = useCorporationWallet;
newProduction.amountOfCycles = 1;
if (!newProduction.TryWithdrawCredit())
{
if (useCorporationWallet)
{
throw new PerpetuumException(ErrorCodes.CorporationNotEnoughMoney);
}
throw new PerpetuumException(ErrorCodes.CharacterNotEnoughMoney);
}
return(ErrorCodes.NoError);
}
public void HandleRequest(IRequest request)
{
using (var scope = Db.CreateTransaction())
{
var buyer = request.Session.Character;
var itemDefinition = request.Data.GetOrDefault <int>(k.definition);
var duration = request.Data.GetOrDefault <int>(k.duration);
var pricePerPiece = request.Data.GetOrDefault <double>(k.price);
var quantity = request.Data.GetOrDefault(k.quantity, 1);
var useBuyerCorporationWallet = request.Data.GetOrDefault <int>(k.useCorporationWallet) == 1;
var forMyCorporation = request.Data.GetOrDefault <int>(k.forMembersOf) == 1;
quantity.ThrowIfLessOrEqual(0, ErrorCodes.AmountTooLow);
buyer.IsDocked.ThrowIfFalse(ErrorCodes.CharacterHasToBeDocked);
buyer.CheckPrivilegedTransactionsAndThrowIfFailed();
pricePerPiece.ThrowIfLessOrEqual(0, ErrorCodes.IllegalMarketPrice);
duration.ThrowIfLessOrEqual(1, ErrorCodes.MinimalDurationNotReached);
var ed = EntityDefault.Get(itemDefinition).ThrowIfEqual(EntityDefault.None, ErrorCodes.DefinitionNotSupported);
ed.IsSellable.ThrowIfFalse(ErrorCodes.ItemNotSellable);
var market = buyer.GetCurrentDockingBase().GetMarketOrThrow();
var realMarketFee = Market.GetRealMarketFee(buyer, duration);
var corporationEid = buyer.CorporationEid;
//cash market fee anyways
_marketHelper.CashInMarketFee(buyer, useBuyerCorporationWallet, realMarketFee);
buyer.GetCurrentDockingBase().AddCentralBank(TransactionType.marketFee, realMarketFee);
if (_marketInfoService.CheckAveragePrice)
{
var avgPrice = _marketHandler.GetAveragePriceByMarket(market, itemDefinition);
if (avgPrice != null && avgPrice.AveragePrice > 0)
{
if (pricePerPiece < avgPrice.AveragePrice * (1 - _marketInfoService.Margin) || pricePerPiece > avgPrice.AveragePrice * (1 + _marketInfoService.Margin))
{
throw new PerpetuumException(ErrorCodes.PriceOutOfAverageRange);
}
}
}
var publicContainer = buyer.GetPublicContainerWithItems();
long?forMembersOf = null;
if (forMyCorporation)
{
if (!DefaultCorporationDataCache.IsCorporationDefault(corporationEid))
{
forMembersOf = corporationEid;
}
else
{
forMyCorporation = false;
}
}
if (!forMyCorporation)
{
_marketHelper.CheckBuyOrderCounts(buyer).ThrowIfFalse(ErrorCodes.MarketItemsExceed);
}
var lowestSellOrder = _marketOrderRepository.GetLowestSellOrder(itemDefinition, pricePerPiece, buyer.Eid, market, corporationEid);
if (!forMyCorporation && lowestSellOrder != null)
{
// requested item was found on the market, make immediate transaction
market.FulfillBuyOrderInstantly(buyer, useBuyerCorporationWallet, lowestSellOrder, pricePerPiece, duration, quantity, publicContainer, forMembersOf);
}
else
{
var deposit = pricePerPiece * quantity;
// take the deposit from the character
_marketHelper.CashIn(buyer, useBuyerCorporationWallet, pricePerPiece, itemDefinition, quantity, TransactionType.buyOrderDeposit);
//store the deposit in the central bank
market.AddCentralBank(TransactionType.buyOrderDeposit, deposit);
// create a new buy order
var newBuyOrder = market.CreateBuyOrder(buyer, itemDefinition, duration, pricePerPiece, quantity, useBuyerCorporationWallet, forMembersOf);
var data = new Dictionary <string, object>
{
{ k.buyOrder, newBuyOrder.ToDictionary() }
};
Message.Builder.SetCommand(Commands.MarketBuyOrderCreated)
.WithData(data)
.ToCharacter(buyer)
.Send();
}
publicContainer.Save();
Message.Builder.SetCommand(Commands.ListContainer)
.WithData(publicContainer.ToDictionary())
.ToCharacter(buyer)
.Send();
scope.Complete();
}
}
public static int GetResultingDefinitionFromCalibrationDefinition(this IProductionDataAccess dataAccess, int definition)
{
var target = (dataAccess.ResearchLevels.Values.Where(ir => ir.calibrationProgramDefinition == definition).Select(ir => ir.definition)).FirstOrDefault();
if (target == 0)
{
Logger.Error("no target definition was found for calibration program: " + EntityDefault.Get(definition).Name + " " + definition);
}
return(target);
}
public Item CreateItem(EntityDefault entityDefault, EntityIDGenerator idGenerator)
{
return((Item)_entityServices.Factory.Create(entityDefault, idGenerator));
}
public static PrivateCorporation Create(CorporationDescription corporationDescription)
{
var container = SystemContainer.GetByName(k.es_private_corporation);
return((PrivateCorporation)Create(EntityDefault.GetByName(DefinitionNames.PRIVATE_CORPORATION), container, corporationDescription, EntityIDGenerator.Random));
}
public void HandleRequest(IRequest request)
{
using (var scope = Db.CreateTransaction())
{
var cfLong = request.Data.GetOrDefault <long>(k.categoryFlags);
var category = request.Data.GetOrDefault <string>(k.category);
var global = request.Data.GetOrDefault <int>(k.global) == 1;
var marketEID = request.Data.GetOrDefault <long>(k.marketEID);
var withVendor = request.Data.GetOrDefault("vendor", 1) == 1;
var nameFilter = request.Data.GetOrDefault <string>(k.filter);
if (global)
{
if (cfLong > 0)
{
_marketHelper.RemoveItemsByCategoryFlags((CategoryFlags)cfLong, withVendor);
}
if (Enum.TryParse(category, true, out CategoryFlags cf))
{
_marketHelper.RemoveItemsByCategoryFlags(cf, withVendor);
}
}
else
{
if (marketEID == 0)
{
var character = request.Session.Character;
var dockingBase = character.GetCurrentDockingBase();
var market = dockingBase.GetMarket();
marketEID = market.Eid;
}
Enum.TryParse(category, true, out CategoryFlags cf).ThrowIfFalse(ErrorCodes.SyntaxError);
var definitions = _entityServices.Defaults.GetAll().GetDefinitionsByCategoryFlag(cf);
if (!nameFilter.IsNullOrEmpty())
{
var tmpList = new List <int>();
foreach (var definition in definitions)
{
var ed = EntityDefault.Get(definition);
if (!ed.Name.Contains(nameFilter))
{
continue;
}
tmpList.Add(ed.Definition);
}
definitions = tmpList.ToArray();
}
var definitionsString = definitions.ArrayToString();
var queryString = "delete marketitems where marketeid=@marketEID and itemdefinition in (" + definitionsString + ") ";
if (!withVendor)
{
queryString += " and isvendoritem=0";
}
Db.Query().CommandText(queryString)
.SetParameter("@marketEID", marketEID)
.ExecuteNonQuery();
}
Message.Builder.FromRequest(request).WithOk().Send();
scope.Complete();
}
}
private FittingPreset(string name, EntityDefault robot, IEnumerable <ModuleInfo> modules)
{
_modules = modules.ToArray();
Name = name;
Robot = robot;
}
private IDictionary <string, object> EndResearch(ProductionInProgress productionInProgress)
{
Logger.Info("research finished: " + productionInProgress);
Item item;
ResearchKit researchKit;
LoadItemAndResearchKit(productionInProgress, out researchKit, out item).ThrowIfError();
var isPrototypeItem = ProductionDataAccess.IsPrototypeDefinition(item.Definition);
var itemLevel = ProductionDataAccess.GetResearchLevel(item.Definition);
var researchKitLevel = researchKit.GetResearchLevel();
int researchTime;
int levelDifferenceBonusPoints;
CalculateFinalResearchTimeSeconds(productionInProgress.character, itemLevel, researchKitLevel, isPrototypeItem, out researchTime, out levelDifferenceBonusPoints);
var outputDefinition = productionInProgress.resultDefinition;
//load public container
var targetContainer = (PublicContainer)Container.GetOrThrow(PublicContainerEid);
targetContainer.ReloadItems(productionInProgress.character);
var outputDefault = EntityDefault.Get(outputDefinition).ThrowIfEqual(EntityDefault.None, ErrorCodes.DefinitionNotSupported);
(outputDefault.CategoryFlags.IsCategory(CategoryFlags.cf_calibration_programs) || outputDefault.CategoryFlags.IsCategory(CategoryFlags.cf_random_calibration_programs)).ThrowIfFalse(ErrorCodes.WTFErrorMedicalAttentionSuggested);
//create item
var resultItem = targetContainer.CreateAndAddItem(outputDefinition, false, item1 =>
{
item1.Owner = productionInProgress.character.Eid;
item1.Quantity = 1;
});
var calibrationProgram = resultItem as CalibrationProgram;
calibrationProgram.ThrowIfNull(ErrorCodes.ConsistencyError);
var itemResearchLevel = ProductionDataAccess.GetItemReserchLevelByCalibrationProgram(calibrationProgram);
int materialEfficiency;
int timeEfficiency;
researchKit.GetCalibrationDefaults(outputDefault, out materialEfficiency, out timeEfficiency);
var rawMatEff = materialEfficiency;
//modify the results even further
CalculateMaterialAndTimeEfficiency(productionInProgress.character, itemResearchLevel, levelDifferenceBonusPoints, ref materialEfficiency, ref timeEfficiency);
if (calibrationProgram.IsMissionRelated)
{
materialEfficiency = rawMatEff;
calibrationProgram.MaterialEfficiencyPoints = rawMatEff;
calibrationProgram.TimeEfficiencyPoints = timeEfficiency;
}
else
{
calibrationProgram.MaterialEfficiencyPoints = materialEfficiency;
calibrationProgram.TimeEfficiencyPoints = timeEfficiency;
}
var randomCalibrationProgram = calibrationProgram as RandomCalibrationProgram;
//for random missions look up for targets, gang and stuff
randomCalibrationProgram?.SetComponentsFromRunningTargets(productionInProgress.character);
calibrationProgram.Save();
productionInProgress.character.WriteItemTransactionLog(TransactionType.ResearchCreated, calibrationProgram);
//delete the used items
Repository.Delete(item);
Repository.Delete(researchKit);
productionInProgress.character.WriteItemTransactionLog(TransactionType.ResearchDeleted, item);
productionInProgress.character.WriteItemTransactionLog(TransactionType.ResearchDeleted, researchKit);
targetContainer.Save();
Logger.Info("endResearch created an item: " + calibrationProgram + " production:" + productionInProgress);
var replyDict = new Dictionary <string, object>
{
{ k.result, calibrationProgram.ToDictionary() }
};
ProductionProcessor.EnqueueProductionMissionTarget(MissionTargetType.research, productionInProgress.character, MyMissionLocationId(), calibrationProgram.Definition);
return(replyDict);
}
public ModuleInfo(RobotComponentType component, int slot, EntityDefault module, EntityDefault ammo)
{
Component = component;
Slot = slot;
Module = module;
Ammo = ammo;
}
public IDictionary <string, object> ResearchQuery(Character character, int researchKitDefinition, int targetDefinition)
{
var replyDict = new Dictionary <string, object>
{
{ k.researchKitDefinition, researchKitDefinition },
{ k.itemDefinition, targetDefinition }
};
var researchKitDefault = EntityDefault.Get(researchKitDefinition);
var itemDefault = EntityDefault.Get(targetDefinition);
var missionRelated = false;
//match item vs research kit vs mission
if (researchKitDefault.CategoryFlags.IsCategory(CategoryFlags.cf_random_research_kits))
{
itemDefault.CategoryFlags.IsCategory(CategoryFlags.cf_generic_random_items).ThrowIfFalse(ErrorCodes.OnlyMissionItemAccepted);
missionRelated = true;
}
if (itemDefault.CategoryFlags.IsCategory(CategoryFlags.cf_generic_random_items))
{
researchKitDefault.CategoryFlags.IsCategory(CategoryFlags.cf_random_research_kits).ThrowIfFalse(ErrorCodes.OnlyMissionResearchKitAccepted);
missionRelated = true;
}
//on gamma not even possible
if (GetDockingBase().IsOnGammaZone())
{
missionRelated.ThrowIfTrue(ErrorCodes.MissionItemCantBeResearchedOnGamma);
}
var researchKitLevel = ResearchKit.GetResearchLevelByDefinition(researchKitDefinition);
replyDict.Add(k.researchKitLevel, researchKitLevel);
var isPrototypeItem = ProductionDataAccess.IsPrototypeDefinition(targetDefinition);
Logger.Info("item definition: " + EntityDefault.Get(targetDefinition).Name + " isPrototype:" + isPrototypeItem);
var nominalDict = new Dictionary <string, object>();
var realDict = new Dictionary <string, object>();
//match research levels
var itemLevel = ProductionDataAccess.GetResearchLevel(targetDefinition);
itemLevel.ThrowIfEqual(0, ErrorCodes.ItemNotResearchable);
itemLevel.ThrowIfGreater(researchKitLevel, ErrorCodes.ResearchLevelMismatch);
var itemResearchLevel = ProductionDataAccess.ResearchLevels.GetOrDefault(targetDefinition).ThrowIfNull(ErrorCodes.ItemNotResearchable);
var outputDefinition = (int)itemResearchLevel.calibrationProgramDefinition.ThrowIfNull(ErrorCodes.ServerError);
//calculate
CalculateFinalResearchTimeSeconds(character, itemLevel, researchKitLevel, isPrototypeItem, out int researchTimeSeconds, out int levelDifferenceBonusPoints);
researchTimeSeconds = GetShortenedProductionTime(researchTimeSeconds);
var price = missionRelated ? 0.0 : researchTimeSeconds *GetPricePerSecond();
ProductionDataAccess.GetCalibrationDefault(outputDefinition, out int materialEfficiency, out int timeEfficiency);
var rawMaterialEfficiency = materialEfficiency;
CalculateMaterialAndTimeEfficiency(character, itemResearchLevel, levelDifferenceBonusPoints, ref materialEfficiency, ref timeEfficiency);
if (missionRelated)
{
//the material efficiency must be default 1.0
materialEfficiency = rawMaterialEfficiency;
}
//calculate nominal
var nominalResearchTimeSeconds = CalculateNominalResearchTimeSeconds(character, itemResearchLevel.researchLevel);
var nominalPrice = missionRelated ? 0.0 : nominalResearchTimeSeconds *GetPricePerSecond();
ProductionDataAccess.GetCalibrationDefault(outputDefinition, out int nominalMaterialEfficiency, out int nominalTimeEfficiency);
var rawNominalMatEff = nominalMaterialEfficiency;
CalculateMaterialAndTimeEfficiency(character, itemResearchLevel, 0, ref nominalMaterialEfficiency, ref nominalTimeEfficiency);
if (missionRelated)
{
nominalMaterialEfficiency = rawNominalMatEff;
researchTimeSeconds = 10;
nominalResearchTimeSeconds = 10;
}
//collect definition related
replyDict.Add(k.calibrationProgram, itemResearchLevel.calibrationProgramDefinition);
//collect real
realDict.Add(k.price, (long)price);
realDict.Add(k.researchTime, researchTimeSeconds);
realDict.Add(k.materialEfficiency, materialEfficiency);
realDict.Add(k.timeEfficiency, timeEfficiency);
//collect nominal
nominalDict.Add(k.price, (long)nominalPrice);
nominalDict.Add(k.researchTime, nominalResearchTimeSeconds);
nominalDict.Add(k.materialEfficiency, nominalMaterialEfficiency);
nominalDict.Add(k.timeEfficiency, nominalTimeEfficiency);
replyDict.Add(k.real, realDict);
replyDict.Add(k.nominal, nominalDict);
replyDict.Add(k.facility, Eid);
return(replyDict);
}
public static CorporateHangar Create()
{
return((CorporateHangar)Factory.CreateWithRandomEID(EntityDefault.GetByName(DefinitionNames.CORPORATE_HANGAR_STANDARD)));
}
private Coin(EntityDefault coinED, int amount)
{
_coinED = coinED;
_amount = amount;
}
private double GetAverageWorldPriceByComponents(EntityDefault entityDefault)
{
Logger.Info("wavg for " + entityDefault.Name + " " + entityDefault.Definition);
var sumCost = 0.0;
foreach (var component in _productionDataAccess.ProductionComponents[entityDefault.Definition])
{
if (component.IsRobotShard)
{
continue;
}
// COMMODITY es MATERIAL
if (component.IsMaterial)
{
var commodityComponents = _productionDataAccess.ProductionComponents[component.EntityDefault.Definition].ToArray();
if (commodityComponents.Length > 0)
{
//this is a commodity => do components
Logger.Info(" commodity break down for: " + component.EntityDefault.Name);
foreach (var commodityComponent in commodityComponents)
{
var marketAverage = _marketHandler.GetWorldAveragePriceByTrades(commodityComponent.EntityDefault);
var cost = commodityComponent.Amount * marketAverage * component.Amount;
if (marketAverage > 0)
{
sumCost += cost;
Logger.Info(" comm=>raw comp: " + EntityDefault.Get(commodityComponent.EntityDefault.Definition).Name + " q:" + commodityComponent.Amount * component.Amount + " mavg: " + marketAverage + " cost:" + cost);
}
else
{
Logger.Info(" comp WTF - no trade - " + EntityDefault.Get(commodityComponent.EntityDefault.Definition).Name);
}
}
}
else
{
// raw material => get market average
var marketAverage = _marketHandler.GetWorldAveragePriceByTrades(component.EntityDefault);
var cost = component.Amount * marketAverage;
if (marketAverage > 0)
{
sumCost += cost;
Logger.Info(" raw comp: " + component.EntityDefault.Name + " q:" + component.Amount + " mavg: " + marketAverage + " cost:" + cost);
}
else
{
Logger.Info(" comp WTF - no trade - " + component.EntityDefault.Name);
}
}
}
if (component.IsEquipment)
{
Logger.Info(" component is equipment: " + component.EntityDefault.Name + " recursion starts");
var marketAverage = GetAverageWorldPriceByComponents(component.EntityDefault);
var cost = component.Amount * marketAverage;
if (marketAverage > 0)
{
sumCost += cost;
Logger.Info(" equipment comp: " + component.EntityDefault.Name + " q:" + component.Amount + " mavg: " + marketAverage + " cost:" + cost);
}
else
{
Logger.Info(" comp WTF - no trade - " + component.EntityDefault.Name);
}
}
if (!component.IsRobot)
{
continue;
}
Logger.Info(" component is robot: " + component.EntityDefault.Name + " recursion starts");
var template = _robotTemplateRelations.GetRelatedTemplateOrDefault(component.EntityDefault.Definition);
var marketAverageHead = GetAverageWorldPriceByComponents(template.Head.EntityDefault);
var costHead = component.Amount * marketAverageHead;
if (marketAverageHead > 0)
{
sumCost += costHead;
Logger.Info(" head comp: " + template.Head.EntityDefault.Name + " q:" + component.Amount + " mavg: " + marketAverageHead + " cost:" + costHead);
}
else
{
Logger.Info(" comp WTF - no trade - " + template.Head.EntityDefault.Name);
}
var marketAverageChassis = GetAverageWorldPriceByComponents(template.Chassis.EntityDefault);
var costChassis = component.Amount * marketAverageChassis;
if (marketAverageChassis > 0)
{
sumCost += costChassis;
Logger.Info(" chassis comp: " + template.Chassis.EntityDefault.Name + " q:" + component.Amount + " mavg: " + marketAverageChassis + " cost:" + costChassis);
}
else
{
Logger.Info(" comp WTF - no trade - " + template.Chassis.EntityDefault.Name);
}
var marketAverageLeg = GetAverageWorldPriceByComponents(template.Leg.EntityDefault);
var costLeg = component.Amount * marketAverageLeg;
if (marketAverageLeg > 0)
{
sumCost += costLeg;
Logger.Info(" leg comp: " + template.Leg.EntityDefault.Name + " q:" + component.Amount + " mavg: " + marketAverageLeg + " cost:" + costLeg);
}
else
{
Logger.Info(" comp WTF - no trade - " + template.Leg.EntityDefault.Name);
}
}
Logger.Info("total comp sum for " + entityDefault.Name + " " + sumCost);
return(sumCost);
}
public static Coin CreateASICoin(int amount)
{
return(new Coin(EntityDefault.GetByName(DefinitionNames.ASI_MISSION_COIN), amount));
}
public override string ToString()
{
return($"productionLineId:{Id}, CharacterId:{CharacterId}, Facility:{FacilityEid}, Definition:{TargetDefinition} {EntityDefault.Get(TargetDefinition).Name}");
}
public static Coin CreateUniversalCoin(int amount)
{
return(new Coin(EntityDefault.GetByName(DefinitionNames.UNIVERSAL_MISSION_COIN), amount));
}
public ErrorCodes PrepareResearchKitMerge(
PublicContainer publicContainer,
Character character, long target, int quantity,
out int nextDefinition,
out int nextLevel,
out double fullPrice,
out int availableQuantity,
out int searchDefinition)
{
ErrorCodes ec;
nextDefinition = 0;
nextLevel = 0;
fullPrice = 0;
availableQuantity = 0;
searchDefinition = 0;
var researchKit = (ResearchKit)publicContainer.GetItem(target, true);
if (researchKit == null)
{
return(ErrorCodes.ItemNotFound);
}
var definition = researchKit.Definition;
searchDefinition = definition;
EntityDefault ed;
if (!EntityDefault.TryGet(definition, out ed))
{
return(ErrorCodes.DefinitionNotSupported);
}
int level = ed.Options.Level;
if (level == 0)
{
Logger.Error("no level was defined for research kit: " + ed.Name + " " + ed.Definition);
return(ErrorCodes.ConsistencyError);
}
if (level == 10)
{
return(ErrorCodes.MaximumResearchLevelReached);
}
nextLevel = level + 1;
var sameDefinitions = publicContainer.GetItems().Where(i => i.Definition == definition).Sum(i => i.Quantity);
if (sameDefinitions % 2 == 1)
{
sameDefinitions--;
}
var pairs = sameDefinitions / 2;
if ((ec = ProductionHelper.FindResearchKitDefinitionByLevel(nextLevel, out nextDefinition)) != ErrorCodes.NoError)
{
return(ec);
}
availableQuantity = Math.Min(pairs, quantity);
fullPrice = GetReserchKitMergePrice(nextLevel, character) * availableQuantity;
return(ec);
}
public void ScaleComponentsAmount(double scale, CategoryFlags targetCategoryFlag, CategoryFlags componentCategory)
{
var descriptions = _productionDescriptions.Values.Where(productionDescription => EntityDefault.Get(productionDescription.definition).CategoryFlags.IsCategory(targetCategoryFlag));
foreach (var productionDescription in descriptions)
{
productionDescription.ScaleComponents(scale, componentCategory);
}
_productionDescriptionCache = null;
_productionDescriptions.Clear();
InitProductionDescriptions();
}
public void HandleRequest(IRequest request)
{
var rootEID = request.Data.GetOrDefault <long>(k.eid);
var character = request.Session.Character;
var owner = character.Eid;
var records = Enumerable.Select(Db.Query().CommandText("getitemsummary")
.SetParameter("@ownerEID", owner)
.SetParameter("@rootEID", rootEID)
.Execute(), r =>
{
return(new
{
definition = r.GetValue <int>(0),
parent = r.GetValue <long>(1),
qty = r.GetValue <long>(2)
});
}).ToList();
var itemsDict = new Dictionary <string, object>();
var count = 0;
var parents = new List <long>(records.Count);
foreach (var record in records)
{
var l = record.qty;
if (l >= int.MaxValue)
{
l = int.MaxValue;
}
var quantitySum = (int)l;
if (!EntityDefault.TryGet(record.definition, out EntityDefault ed))
{
continue;
}
if (!(ed.CategoryFlags.IsCategory(CategoryFlags.cf_robot_equipment) ||
ed.CategoryFlags.IsCategory(CategoryFlags.cf_robots) ||
ed.CategoryFlags.IsCategory(CategoryFlags.cf_ammo) ||
ed.CategoryFlags.IsCategory(CategoryFlags.cf_material) ||
ed.CategoryFlags.IsCategory(CategoryFlags.cf_documents) ||
ed.CategoryFlags.IsCategory(CategoryFlags.cf_dogtags) ||
ed.CategoryFlags.IsCategory(CategoryFlags.cf_production_items) ||
ed.CategoryFlags.IsCategory(CategoryFlags.cf_mission_items) ||
ed.CategoryFlags.IsCategory(CategoryFlags.cf_field_accessories) ||
ed.CategoryFlags.IsCategory(CategoryFlags.cf_container) ||
ed.CategoryFlags.IsCategory(CategoryFlags.cf_dynamic_cprg) ||
ed.CategoryFlags.IsCategory(CategoryFlags.cf_scan_result) ||
ed.CategoryFlags.IsCategory(CategoryFlags.cf_redeemables) ||
ed.CategoryFlags.IsCategory(CategoryFlags.cf_pbs_capsules)))
{
continue;
}
var oneEntry = new Dictionary <string, object>
{
{ k.definition, record.definition },
{ k.parent, record.parent },
{ k.quantity, quantitySum }
};
parents.Add(record.parent);
itemsDict.Add("c" + count++, oneEntry);
Logger.DebugInfo($"{record.parent} {EntityDefault.Get(record.definition).Name} {quantitySum}");
}
var result = new Dictionary <string, object>
{
{ k.items, itemsDict },
{ k.rootEID, rootEID }
};
if (parents.Count > 0)
{
var parentStr = parents.ArrayToString();
var counter = 0;
var parentsDict = new Dictionary <string, object>();
var secondParents = new List <long>();
var dataRecords = Db.Query().CommandText($"select eid,ename,parent,definition from entities where eid in ({parentStr})").Execute();
foreach (var r in dataRecords)
{
var secondDefinition = r.GetValue <int>(3);
var secondParent = r.GetValue <long?>(2);
EntityDefault ed;
if (!EntityDefault.TryGet(secondDefinition, out ed))
{
continue;
}
if (ed.CategoryFlags.IsCategory(CategoryFlags.cf_volume_wrapper_container))
{
continue;
}
if (secondParent != null && secondParent > 0)
{
secondParents.Add((long)secondParent);
}
var oneEntry =
new Dictionary <string, object>
{
{ k.eid, r.GetValue <long>(0) },
{ k.eName, r.GetValue <string>(1) },
{ k.parent, secondParent },
{ k.definition, secondDefinition }
};
parentsDict.Add("p" + counter++, oneEntry);
}
if (secondParents.Count > 0)
{
var secondParentStr = secondParents.Except(parents).ArrayToString();
foreach (var r in Db.Query().CommandText("select eid,ename,parent,definition from entities where eid in (" + secondParentStr + ")").Execute())
{
var oneEntry =
new Dictionary <string, object>
{
{ k.eid, r.GetValue <long>(0) },
{ k.eName, r.GetValue <string>(1) },
{ k.parent, r.GetValue <long>(2) },
{ k.definition, r.GetValue <int>(3) }
};
parentsDict.Add("p" + counter++, oneEntry);
}
}
result.Add(k.data, parentsDict);
foreach (var pair in parentsDict)
{
var v = (Dictionary <string, object>)pair.Value;
Logger.DebugInfo($"{v[k.eid]} {v[k.parent]} {v[k.eName]} {EntityDefault.Get((int)v[k.definition]).Name}");
}
}
Message.Builder.FromRequest(request).WithData(result).Send();
}
private void GetSuppliedItem(Player player)
{
if (!player.InZone)
{
return;
}
//csak mission felveve
var supplyTargets = player.MissionHandler.GetTargetsForMissionStructure(this);
if (supplyTargets.Count == 0)
{
return;
}
using (var scope = Db.CreateTransaction())
{
try
{
var container = player.GetContainer();
Debug.Assert(container != null, "container != null");
container.EnlistTransaction();
//spawn item to player
var spawnedItems = new List <Item>();
foreach (var targetBase in supplyTargets.Cast <ItemSupplyZoneTarget>())
{
var goalQuantity = targetBase.MyTarget.ValidQuantitySet ? targetBase.MyTarget.Quantity : 1;
var alreadyGiven = targetBase.GetCurrentProgress();
var quantityNeeded = (goalQuantity - alreadyGiven).Clamp(0, goalQuantity);
if (quantityNeeded == 0)
{
Logger.Error("WTF in GetSuppliedItem " + targetBase.MyTarget);
continue;
}
var itemEd = EntityDefault.Get(targetBase.MyTarget.Definition);
var quantity = container.GetMaximalQuantity(itemEd, quantityNeeded);
if (quantity <= 0)
{
// clarify gameplay
Message.Builder.SetCommand(Commands.MissionError).WithData(container.GetCapacityInfo()).ToCharacter(player.Character).WithError(ErrorCodes.ContainerIsFull).Send();
continue;
}
var item = (Item)Factory.CreateWithRandomEID(itemEd);
item.Owner = player.Character.Eid;
item.Quantity = quantity;
// ha itt megall akkor rosszul van kiszamolva a quantity
Debug.Assert(container.IsEnoughCapacity(item), "not enough capacity!");
//this is the point when the item supply spawns a cprg
//collect components here from the mission
var randomCalibrationProgram = item as RandomCalibrationProgram;
randomCalibrationProgram?.SetComponentsFromRunningTargets(player.Character);
container.AddItem(item, false);
spawnedItems.Add(item);
var b = TransactionLogEvent.Builder().SetTransactionType(TransactionType.ItemSupply).SetCharacter(player.Character).SetItem(item);
player.Character.LogTransaction(b);
}
container.Save();
Transaction.Current.OnCommited(() =>
{
foreach (var item in spawnedItems)
{
player.MissionHandler.EnqueueMissionEventInfo(new ItemSupplyEventInfo(player, item, this, CurrentPosition));
}
//success beam kirajzolo
CreateSuccessBeam(player);
container.SendUpdateToOwner();
CreateInteractionBeam(player);
});
scope.Complete();
}
catch (Exception ex)
{
var err = ErrorCodes.ServerError;
var gex = ex as PerpetuumException;
if (gex != null)
{
err = gex.error;
Logger.Exception(ex);
}
else
{
Logger.Exception(ex);
}
player.Character.SendErrorMessage(Commands.MissionError, err);
}
}
}
public override string ToString()
{
return(string.Format("ID:{0} characterID:{1} characterEID:{2} resultDefinition:{3} {9} type:{4} facilityEID:{5} baseEID:{6} price:{7} amountOfCycles:{8}", ID, character.Id, character.Eid, resultDefinition, type, facilityEID, baseEID, Price, amountOfCycles, EntityDefault.Get(resultDefinition).Name));
}
public static RobotTemplate GetRelatedTemplateOrDefault(this IRobotTemplateRelations relations, EntityDefault ed)
{
return(relations.GetRelatedTemplateOrDefault(ed.Definition));
}
