public SocketOperationsImpl(EntityCache <CustomSocket> socketCache, EntityCache <SocketGroup> socketGroupCache,
SocketExchange.SocketExchangeClient client, SocketOperationsOptions options)
{
_client = client;
_socketCache = socketCache;
_socketGroupCache = socketGroupCache;
_options = options;
var sockets = _socketCache.GetAll();
var productionRulesGenerator = new ProductionRulesGenerator();
var logicRulesGenerator = new LogicRulesGenerator();
var fuzzyRulesGenerator = new FuzzyRulesGenerator();
var neuralRulesGenerator = new NeuralRulesGenerator();
// Продукционный вывод
var rulesGraph = productionRulesGenerator.GenerateRules(sockets);
// Логический вывод
var logicRules = logicRulesGenerator.GenerateRules(sockets);
// Нечеткий вывод
var fuzzyDomains = fuzzyRulesGenerator.GetFuzzyDomains(sockets);
var fuzzyFacts = fuzzyRulesGenerator.GetFuzzyFacts(fuzzyDomains, sockets);
// Нейро-нечеткий вывод
var neuralNetwork = neuralRulesGenerator.GetNeuralNetwork(sockets);
var processorOptions = new ProcessorOptions {
Debug = _options.Debug
};
_productionProcessor = new ProductionProcessor(rulesGraph, processorOptions);
_logicProcessor = new LogicProcessor(logicRules, processorOptions);
_fuzzyProcessor = new FuzzyProcessor(fuzzyDomains, fuzzyFacts, processorOptions);
_neuralProcessor = new NeuralProcessor(neuralNetwork, processorOptions);
}
public ProductionProcessorTest()
{
var sockets = TestData.GetSockets();
var rulesGenerator = new ProductionRulesGenerator();
var rulesGraph = rulesGenerator.GenerateRules(sockets);
_productionProcessor = new ProductionProcessor(rulesGraph, new ProcessorOptions {
Debug = false
});
}
public void HandleRequest(IRequest request)
{
var facility = request.Data.GetOrDefault <long>(k.facility);
var cprgEid = request.Data.GetOrDefault <long>(k.eid);
var character = request.Session.Character;
_productionManager.PrepareProductionForPublicContainer(facility, character, out Mill mill, out PublicContainer container);
var replyDict = ProductionProcessor.LineQuery(character, container, cprgEid, mill);
Message.Builder.FromRequest(request).WithData(replyDict).Send();
}
private IDictionary <string, object> EndPrototype(ProductionInProgress productionInProgress)
{
Logger.Info("Prototype finished: " + productionInProgress);
//delete the used items
foreach (var item in productionInProgress.GetReservedItems())
{
var b = TransactionLogEvent.Builder().SetTransactionType(TransactionType.PrototypeDeleted).SetCharacter(productionInProgress.character).SetItem(item);
productionInProgress.character.LogTransaction(b);
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;
});
container.Save();
productionInProgress.character.WriteItemTransactionLog(TransactionType.PrototypeCreated, resultItem);
//get list in order to return
Logger.Info("EndPrototype created an item: " + resultItem + " production:" + productionInProgress);
var replyDict = new Dictionary <string, object>
{
{ k.result, resultItem.BaseInfoToDictionary() },
};
ProductionProcessor.EnqueueProductionMissionTarget(MissionTargetType.prototype, productionInProgress.character, MyMissionLocationId(), productionInProgress.resultDefinition);
return(replyDict);
}
public ProductionInProgressCorporation(ProductionProcessor productionProcessor)
{
_productionProcessor = productionProcessor;
}
public ProductionCancel(ProductionProcessor productionProcessor)
{
_productionProcessor = productionProcessor;
}
public ProductionForceEnd(ProductionProcessor productionProcessor)
{
_productionProcessor = productionProcessor;
}
public ProductionComponentsList(ProductionProcessor productionProcessor)
{
_productionProcessor = productionProcessor;
}
public ProductionFacilityDescription(ProductionProcessor productionProcessor)
{
_productionProcessor = productionProcessor;
}
public ProductionResearch(ProductionManager productionManager, ProductionProcessor productionProcessor)
{
_productionManager = productionManager;
_productionProcessor = productionProcessor;
}
public ProductionInsuranceDelete(ProductionProcessor productionProcessor)
{
_productionProcessor = productionProcessor;
}
public ProductionFacilityInfo(ProductionProcessor productionProcessor)
{
_productionProcessor = productionProcessor;
}
public ProductionLineStart(ProductionManager productionManager, ProductionProcessor productionProcessor)
{
_productionManager = productionManager;
_productionProcessor = productionProcessor;
}
public ProductionSpawnComponents(ProductionProcessor productionProcessor)
{
_productionProcessor = productionProcessor;
}
public ProductionInProgress LineStart(Character character, ProductionLine productionLine, Container sourceContainer, int cycles, bool useCorporationWallet, out bool hasBonus)
{
var cprg = productionLine.GetOrCreateCalibrationProgram(this);
var components = cprg.Components;
//search for components
var foundComponents = ProductionHelper.SearchForAvailableComponents(sourceContainer, components).ToList();
var materialMultiplier = CalculateFinalMaterialMultiplier(character, productionLine.GetMaterialPoints(), productionLine.TargetDefinition, out hasBonus);
if (cprg.IsMissionRelated)
{
//clamp the material multiplier at 1.0
//so it can ask less that in the mission but never more
var preMatMult = materialMultiplier;
materialMultiplier = materialMultiplier.Clamp();
Logger.Info("pre material multiplier:" + preMatMult + " -> " + materialMultiplier);
}
//match components
var itemsNeeded = ProductionHelper.ProcessComponentRequirement(ProductionInProgressType.massProduction, foundComponents, cycles, materialMultiplier, components);
//put them to storage
long[] reservedEids;
ProductionHelper.ReserveComponents_noSQL(itemsNeeded, StorageEid, sourceContainer, out reservedEids).ThrowIfError();
//calculate time
var productionTimeSeconds = cycles * CalculateFinalProductionTimeSeconds(character, cprg.TargetDefinition, productionLine.GetTimePoints());
productionTimeSeconds = GetShortenedProductionTime(productionTimeSeconds);
if (cprg.IsMissionRelated)
{
productionTimeSeconds = 10;
}
var newProduction = ProductionInProgressFactory();
newProduction.startTime = DateTime.Now;
newProduction.finishTime = DateTime.Now.AddSeconds(productionTimeSeconds);
newProduction.type = ProductionInProgressType.massProduction;
newProduction.character = character;
newProduction.facilityEID = Eid;
newProduction.resultDefinition = productionLine.TargetDefinition;
newProduction.totalProductionTimeSeconds = productionTimeSeconds;
newProduction.baseEID = Parent;
newProduction.pricePerSecond = cprg.IsMissionRelated ? 0.0 : GetPricePerSecond(productionLine.TargetDefinition);
newProduction.ReservedEids = reservedEids;
newProduction.amountOfCycles = cycles;
newProduction.useCorporationWallet = useCorporationWallet;
if (!newProduction.TryWithdrawCredit())
{
//not enough money
return(null);
}
//save to sql
newProduction.InsertProductionInProgess();
//set running production id to line
ProductionLine.SetRunningProductionId(productionLine.Id, newProduction.ID).ThrowIfError();
productionLine.DecreaseRounds();
sourceContainer.Save();
Transaction.Current.OnCommited(() =>
{
//add to ram
ProductionProcessor.AddToRunningProductions(newProduction);
});
//send info to client
newProduction.SendProductionEventToCorporationMembersOnCommitted(Commands.ProductionRemoteStart);
return(newProduction);
}
public ProductionFacilityOnOff(ProductionProcessor productionProcessor)
{
_productionProcessor = productionProcessor;
}
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 ProductionServerInfo(ProductionProcessor productionProcessor)
{
_productionProcessor = productionProcessor;
}
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 ProductionScaleComponentsAmount(ProductionProcessor productionProcessor)
{
_productionProcessor = productionProcessor;
}
public ProductionRemoveFacility(ProductionProcessor productionProcessor)
{
_productionProcessor = productionProcessor;
}
public ProductionInProgressHandler(ProductionProcessor productionProcessor)
{
_productionProcessor = productionProcessor;
}
