private ProductionLine DecalibrateLine(ProductionInProgress productionInProgress, ref bool wasLineDead, out CalibrationProgram cprg)
{
cprg = null;
var productionLine = ProductionLine.LoadByProductionId(productionInProgress.character, productionInProgress.ID);
if (productionLine == null)
{
Logger.Error("DecalibrateLine: productionline was not found. a production in progress exists without related productionline. " + productionInProgress);
return(null);
}
//this CPRG drives the production
cprg = productionLine.GetOrCreateCalibrationProgram(this);
// mission mechanism
if (cprg.IsMissionRelated)
{
//kill the line, delete cprg
wasLineDead = true;
ProductionLine.DeleteById(productionLine.Id);
Logger.Info("production line was deleted " + productionLine);
Repository.Delete(cprg);
Logger.Info("CPRG deleted from db " + cprg.Eid);
return(productionLine);
}
//decalibrate
var newMaterialEfficiency = productionLine.MaterialEfficiency;
var newTimeEfficiency = productionLine.TimeEfficiency;
Logger.Info("pre decalibration mateff:" + newMaterialEfficiency + " timeeff:" + newTimeEfficiency + " " + productionInProgress);
productionLine.GetDecalibratedEfficiencies(ref newMaterialEfficiency, ref newTimeEfficiency);
Logger.Info("post decalibration mateff:" + newMaterialEfficiency + " timeeff:" + newTimeEfficiency + " " + productionInProgress);
productionLine.MaterialEfficiency = newMaterialEfficiency;
productionLine.TimeEfficiency = newTimeEfficiency;
if (productionLine.IsAtZero())
{
wasLineDead = true;
Logger.Info("line is dead. " + productionInProgress);
var info = new Dictionary <string, object>
{
{ k.facility, GetFacilityInfo(productionInProgress.character) },
{ k.line, productionLine.ToDictionary() }
};
Message.Builder.SetCommand(Commands.ProductionLineDead)
.WithData(info)
.ToCharacter(productionInProgress.character)
.Send();
}
ProductionLine.PostMassProduction(productionInProgress.character, productionLine.Id, newTimeEfficiency, newMaterialEfficiency);
return(productionLine);
}
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(sourceItem.Definition);
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 override IDictionary <string, object> EndProduction(ProductionInProgress productionInProgress, bool forced)
{
return(EndMassProduction(productionInProgress, forced));
}
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 override IDictionary <string, object> CancelProduction(ProductionInProgress productionInProgress)
{
return(ReturnReservedItems(productionInProgress));
}
public override IDictionary <string, object> CancelProduction(ProductionInProgress productionInProgress)
{
//hatha kell itt meg valamit csinalni
return(ReturnReservedItems(productionInProgress));
}
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 virtual IDictionary <string, object> CancelProduction(ProductionInProgress productionInProgress)
{
return(null);
}
public virtual IDictionary <string, object> EndProduction(ProductionInProgress productionInProgress, bool forced)
{
return(null);
}
