public void CheckTargetDefinitionAndThrowIfFailed(int definition)
{
var ed = EntityDefault.Get(definition).ThrowIfEqual(EntityDefault.None, ErrorCodes.DefinitionNotSupported);
//is it a refinable basic commodity?
IsProducible(ed.Definition).ThrowIfFalse(ErrorCodes.DefinitionNotSupported);
}
private static ModuleTemplate Create(int definition, int slot, ItemTemplate <Ammo> ammo)
{
return(new ModuleTemplate(slot, ammo)
{
EntityDefault = EntityDefault.Get(definition)
});
}
public void HandleRequest(IRequest request)
{
using (var scope = Db.CreateTransaction())
{
var character = request.Session.Character;
var definition = request.Data.GetOrDefault <int>(k.definition);
var ed = EntityDefault.Get(definition);
ed.CategoryFlags.IsCategory(CategoryFlags.cf_calibration_programs).ThrowIfFalse(ErrorCodes.DefinitionNotSupported);
var container = character.GetPublicContainerWithItems();
var cprg = container.CreateAndAddItem(definition, false, item =>
{
item.Owner = character.Eid;
item.Quantity = 1;
});
cprg.DynamicProperties.Update(k.nextMaterialEfficiency, 0.5);
cprg.DynamicProperties.Update(k.timeEfficiency, 0.5);
cprg.Save();
Message.Builder.FromRequest(request).WithData(cprg.BaseInfoToDictionary()).Send();
scope.Complete();
}
}
//load the components table
private void InitProductionDescriptions()
{
var loaded = 0;
try
{
var definitions = Db.Query().CommandText("select distinct c.definition from components c join entitydefaults d on c.definition=d.definition WHERE d.enabled=1").Execute()
.Select(r => r.GetValue <int>(0)).ToList();
foreach (var definition in definitions)
{
var ed = EntityDefault.Get(definition);
if (ed == EntityDefault.None)
{
Logger.Error("definition not found while loading production components. definition:" + definition);
continue;
}
var desc = _productionDescFactory(ed.Definition);
_productionDescriptions.Add(definition, desc);
loaded++;
}
Logger.Info(loaded + " production descriptions loaded");
}
catch (Exception ex)
{
Logger.Error("Error occured loading the production descriptions " + ex.Message);
}
}
protected static ItemTemplate <T> Create(int definition, int quantity, bool repackaged)
{
return(new ItemTemplate <T>(quantity, repackaged)
{
EntityDefault = EntityDefault.Get(definition)
});
}
public void LoadAllConfig()
{
var records = Db.Query().CommandText("select * from npcflock").Execute();
foreach (var r in records)
{
var builder = _flockConfigurationBuilderFactory();
builder.With(c =>
{
c.ID = r.GetValue <int>("id");
c.Name = r.GetValue <string>("name");
c.PresenceID = r.GetValue <int>("presenceid");
c.FlockMemberCount = r.GetValue <int>("flockmembercount");
c.EntityDefault = EntityDefault.Get(r.GetValue <int>("definition"));
c.SpawnOrigin = new Position(r.GetValue <int>("spawnoriginX"), r.GetValue <int>("spawnoriginY"));
c.SpawnRange = new IntRange(r.GetValue <int>("spawnrangeMin"), r.GetValue <int>("spawnrangeMax"));
c.RespawnTime = TimeSpan.FromSeconds(r.GetValue <int>("respawnseconds"));
c.TotalSpawnCount = r.GetValue <int>("totalspawncount");
c.HomeRange = r.GetValue <int>("homerange");
c.Note = r.GetValue <string>("note");
c.RespawnMultiplierLow = r.GetValue <double>("respawnmultiplierlow");
c.IsCallForHelp = r.GetValue <bool>("iscallforhelp");
c.Enabled = r.GetValue <bool>("enabled");
c.BehaviorType = (NpcBehaviorType)r.GetValue <int>("behaviorType");
});
var config = builder.Build();
_flockConfigurations[config.ID] = config;
}
}
public static RobotComponentTemplate <T> Create(int definition, ModuleTemplate[] moduleTemplates)
{
return(new RobotComponentTemplate <T>(moduleTemplates)
{
EntityDefault = EntityDefault.Get(definition)
});
}
public static RobotInventoryTemplate Create(int definition, ItemTemplate <Item>[] itemTemplates)
{
return(new RobotInventoryTemplate(itemTemplates)
{
EntityDefault = EntityDefault.Get(definition)
});
}
/// <summary>
/// Loads average price data from a given market for a definition
/// </summary>
public void LoadAveragePrice(int definition, int daysBack, Market market)
{
LastUpdated = DateTime.Now;
var startDate = DateTime.Today.AddDays(-1 * daysBack);
//get it from the live data
var record = Db.Query().CommandText(@"select sum(totalprice) / sum(quantity) as price, sum(quantity) from
marketaverageprices where
marketeid = @marketEID and
itemdefinition = @itemDefinition and
date >= @startDate")
.SetParameter("@itemDefinition", definition)
.SetParameter("@day", daysBack)
.SetParameter("@marketEID", market.Eid)
.SetParameter("@startDate", startDate)
.ExecuteSingleRow();
var entityDefault = EntityDefault.Get(definition);
if (record != null)
{
var price = record.GetValue <double>(0);
var quantity = record.GetValue <long>(1);
AveragePrice = price;
SumQuantity = quantity; //the amount they traded in the current period
Logger.Info("avg cached on market " + market.Eid + " for definition:" + definition + " " + entityDefault.Name + " price:" + AveragePrice + " sumQuantity:" + quantity);
}
else
{
Logger.Info("no trade with " + definition + " " + entityDefault.Name + " on market: " + market.Eid);
}
}
protected override bool CanHandleMissionEvent(LootMissionEventInfo e)
{
if (MyTarget.Definition != e.LootedItem.Definition)
{
return(false);
}
if (!IsZoneOrPositionValid(e.LootedPosition.ToPosition()))
{
return(false);
}
var isGenericRandomItem = EntityDefault.Get(MyTarget.Definition).CategoryFlags.IsCategory(CategoryFlags.cf_generic_random_items);
var myMission = MyZoneMissionInProgress.GetMission;
if (myMission.behaviourType == MissionBehaviourType.Random && isGenericRandomItem)
{
if (e.MissionGuid != MyZoneMissionInProgress.missionGuid)
{
return(false);
}
if (e.DisplayOrder != MyTarget.displayOrder)
{
return(false);
}
}
return(true);
}
public static IDictionary <string, object> LineQuery(Character character, Container container, long cprgEid, Mill mill)
{
var calibrationProgram = (CalibrationProgram)container.GetItemOrThrow(cprgEid);
var targetDefinition = calibrationProgram.TargetDefinition;
targetDefinition.ThrowIfEqual(0, ErrorCodes.CPRGNotProducible);
var targetDefault = EntityDefault.Get(targetDefinition);
if (calibrationProgram.IsMissionRelated || targetDefault.CategoryFlags.IsCategory(CategoryFlags.cf_random_items))
{
if (mill.GetDockingBase().IsOnGammaZone())
{
throw new PerpetuumException(ErrorCodes.MissionItemCantBeProducedOnGamma);
}
}
calibrationProgram.HasComponents.ThrowIfFalse(ErrorCodes.CPRGNotProducible);
var replyDict = mill.QueryMaterialAndTime(calibrationProgram, character, targetDefinition, calibrationProgram.MaterialEfficiencyPoints, calibrationProgram.TimeEfficiencyPoints);
replyDict.Add(k.materialEfficiency, calibrationProgram.MaterialEfficiencyPoints);
replyDict.Add(k.timeEfficiency, calibrationProgram.TimeEfficiencyPoints);
return(replyDict);
}
public IDictionary <string, object> CalibrateLine(Character character, long calibrationEid, Container container)
{
var lineCount = ProductionLine.CountLinesForCharacter(character, Eid);
var maxSlots = RealMaxSlotsPerCharacter(character);
lineCount.ThrowIfGreaterOrEqual(maxSlots, ErrorCodes.MaximumAmountOfProducionsReached);
var calibrationItem = (CalibrationProgram)container.GetItemOrThrow(calibrationEid);
calibrationItem.Quantity.ThrowIfNotEqual(1, ErrorCodes.ServerError);
var targetDefinition = calibrationItem.TargetDefinition;
targetDefinition.ThrowIfEqual(0, ErrorCodes.CPRGNotProducible);
var targetDefault = EntityDefault.Get(targetDefinition);
calibrationItem.HasComponents.ThrowIfFalse(ErrorCodes.CPRGNotProducible);
//no mission stuff here
if (calibrationItem.IsMissionRelated || targetDefault.CategoryFlags.IsCategory(CategoryFlags.cf_random_items))
{
if (this.GetDockingBase().IsOnGammaZone())
{
throw new PerpetuumException(ErrorCodes.MissionItemCantBeProducedOnGamma);
}
}
ProductionLine.CreateCalibratedLine(character, Eid, calibrationItem);
//remove from container
container.RemoveItemOrThrow(calibrationItem);
//parent the cprg to the facility
this.GetStorage().AddChild(calibrationItem);
calibrationItem.Save();
container.Save();
ProductionHelper.ProductionLogInsert(character, targetDefinition, 1, ProductionInProgressType.inserCT, 0, 0, false);
var informDict = container.ToDictionary();
var linesList = GetLinesList(character);
var facilityInfo = GetFacilityInfo(character);
var replyDict = new Dictionary <string, object>
{
{ k.lines, linesList },
{ k.lineCount, linesList.Count },
{ k.sourceContainer, informDict },
{ k.facility, facilityInfo }
};
return(replyDict);
}
public static ModuleInfo CreateFrom(IDictionary <string, object> dictionary)
{
var component = (RobotComponentType)dictionary.GetOrDefault <int>(k.component);
var slot = dictionary.GetOrDefault <int>(k.slot);
var module = EntityDefault.Get(dictionary.GetOrDefault <int>(k.module));
var ammo = EntityDefault.Get(dictionary.GetOrDefault <int>(k.ammo));
return(new ModuleInfo(component, slot, module, ammo));
}
public static FittingPreset CreateFrom(GenxyString preset)
{
var dictionary = preset.ToDictionary();
var name = dictionary.GetOrDefault <string>(k.name);
var robot = EntityDefault.Get(dictionary.GetOrDefault <int>(k.robot));
var modules = dictionary.GetOrDefault <IDictionary <string, object> >(k.modules, () => new Dictionary <string, object>()).Select(kvp => ModuleInfo.CreateFrom((IDictionary <string, object>)kvp.Value));
return(new FittingPreset(name, robot, modules));
}
public static void InsertComponentToSql(int sourceDefinition, int componentDefinition, int componentAmount)
{
Logger.Info($" {EntityDefault.Get(sourceDefinition).Name} comp:{EntityDefault.Get(componentDefinition).Name} amount:{componentAmount}");
Db.Query().CommandText("insert components (definition, componentdefinition, componentamount) values (@def, @compDef, @am)")
.SetParameter("@def", sourceDefinition)
.SetParameter("@compDef", componentDefinition)
.SetParameter("@am", componentAmount)
.ExecuteNonQuery();
}
private int GetWallHealerCycleTime()
{
var dc = EntityDefault.Get(Definition).Config;
if (dc.cycle_time != null)
{
return((int)dc.cycle_time);
}
Logger.Error("consistency error in " + Definition + " " + ED.Name + " no cycletime defined. ");
return((int)TimeSpan.FromSeconds(10).TotalMilliseconds);
}
public int GetGeoscanDocumentByMineral(int mineralDefinition)
{
int documentDefinition;
if (!_mineralDefinitionToGeoscanDocumentDefinition.TryGetValue(mineralDefinition, out documentDefinition))
{
Logger.Error(EntityDefault.Get(mineralDefinition).Name + " " + mineralDefinition + " in, but no related geoscan document.");
throw new PerpetuumException(ErrorCodes.ConsistencyError);
}
return(documentDefinition);
}
public virtual int GetProbeInterval()
{
var config = EntityDefault.Get(Definition).Config;
if (config.cycle_time == null)
{
Logger.Error("consistency error in proximityProbe. interval not defined. " + Definition + " " + ED.Name);
return(150000);
}
return(((int)config.cycle_time) + FastRandom.NextInt(0, 250));
}
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);
}
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);
}
static Outpost()
{
StabilityBonusThresholds = Db.Query().CommandText("select * from intrusionsitestabilitythreshold").Execute().Select(r => new StabilityBonusThreshold(r)).ToArray();
_sapInfos = Db.Query().CommandText("select * from intrusionsaps").Execute().ToLookup(r => r.GetValue <long>("siteEid"), r =>
{
var x = r.GetValue <int>("x");
var y = r.GetValue <int>("y");
return(new SAPInfo(EntityDefault.Get(r.GetValue <int>("definition")), new Position(x, y).Center));
});
var bonusList = StabilityBonusThresholds.Where(bi => bi.bonusType == StabilityBonusType.DefenseNodes).ToArray();
DefenseNodesStabilityLimit = bonusList.Length > 0 ? bonusList[0].threshold : 5000;
}
public int CalculateFinalProductionTimeSeconds(Character character, int targetDefinition, int lineOrCPRGTimePoints)
{
if (EntityDefault.Get(targetDefinition).CategoryFlags.IsCategory(CategoryFlags.cf_random_items))
{
return(10); //fix time for mission items
}
//definition related time modifier
var durationModifier = ProductionDataAccess.GetProductionDuration(targetDefinition);
var multiplier = CalculateFinalTimeMultiplier(character, targetDefinition, lineOrCPRGTimePoints);
var facilityProductionTime = GetProductionTimeSeconds();
return((int)(facilityProductionTime * multiplier * durationModifier));
}
private void InitMedicine()
{
var dc = EntityDefault.Get(Definition).Config;
if (dc.chargeAmount == null)
{
Logger.Error("consistency error in " + Definition + " " + ED.Name + " no chargeAmount defined. ");
_medicine = 500;
return;
}
_medicine = (int)dc.chargeAmount;
_medicineMax = (int)dc.chargeAmount;
Armor = _medicine;
}
private int GetCalibrationProgramFromPool(MissionInProgress missionInProgress)
{
var possibleRandomCPRGList = EntityDefault.All.GetByCategoryFlags(CategoryFlags.cf_random_calibration_programs).Select(d => d.Definition).ToList();
Log("possible CPRG definitions:" + possibleRandomCPRGList.Count);
var exceptCPRGDefinitions = missionInProgress.CollectCPRGDefinitionsFromItems();
possibleRandomCPRGList = possibleRandomCPRGList.Except(missionInProgress.SelectedItemDefinitions).Except(exceptCPRGDefinitions).ToList();
Log("except choosen:" + possibleRandomCPRGList.Count);
if (possibleRandomCPRGList.Count == 0)
{
Log("no possible CPRG definitions to select from. " + this + " " + missionInProgress);
throw new PerpetuumException(ErrorCodes.ConsistencyError);
}
//now we load the active cprg definitions from the character/gang
var activeCPRGDefinitions = missionInProgress.CollectActiveCPRGDefinitions();
Log("active CPRG definitions:" + activeCPRGDefinitions.Count);
possibleRandomCPRGList = possibleRandomCPRGList.Except(activeCPRGDefinitions).ToList();
Log("except active: " + possibleRandomCPRGList.Count);
if (possibleRandomCPRGList.Count == 0)
{
Log("too many active cprgs running. mission resolve fails " + this + " " + missionInProgress);
throw new PerpetuumException(ErrorCodes.TooManyActiveCPRG);
}
var choosenCPRG = possibleRandomCPRGList.RandomElement();
//exclude
missionInProgress.AddToSelectedItems(choosenCPRG);
//and exclude this as well
var resultingDefinition = ProductionDataAccess.GetResultingDefinitionFromCalibrationDefinition(choosenCPRG);
missionInProgress.AddToSelectedItems(resultingDefinition);
Log("selected CPRG: " + EntityDefault.Get(choosenCPRG).Name + " " + choosenCPRG);
return(choosenCPRG);
}
public void HandleRequest(IZoneRequest request)
{
using (var scope = Db.CreateTransaction())
{
var decorDescription = new DecorDescription
{
id = request.Data.GetOrDefault <int>(k.ID),
definition = request.Data.GetOrDefault <int>(k.definition),
quaternionX = request.Data.GetOrDefault <double>(k.quaternionX),
//shifted
quaternionY = request.Data.GetOrDefault <double>(k.quaternionY),
quaternionZ = request.Data.GetOrDefault <double>(k.quaternionZ),
quaternionW = request.Data.GetOrDefault <double>(k.quaternionW),
scale = request.Data.GetOrDefault <double>(k.scale),
position = new Position(request.Data.GetOrDefault <int>(k.x), request.Data.GetOrDefault <int>(k.y), request.Data.GetOrDefault <int>(k.z)),
zoneId = request.Zone.Id,
fadeDistance = request.Data.GetOrDefault <double>(k.fadeDistance),
category = request.Data.GetOrDefault <int>(k.category),
changed = true
};
//check definition
EntityDefault.Get(decorDescription.definition).CategoryFlags.IsCategory(CategoryFlags.cf_decor).ThrowIfFalse(ErrorCodes.DefinitionNotSupported);
DecorDescription oldDescription;
request.Zone.DecorHandler.Decors.TryGetValue(decorDescription.id, out oldDescription).ThrowIfFalse(ErrorCodes.ItemNotFound);
if (oldDescription.locked)
{
request.Zone.DecorHandler.SpreadDecorChanges(oldDescription);
throw new PerpetuumException(ErrorCodes.DecorLocked);
}
//save to sql
request.Zone.DecorHandler.UpdateDecorSql(decorDescription).ThrowIfError();
Transaction.Current.OnCommited(() =>
{
//save to ram
request.Zone.DecorHandler.SetDecor(decorDescription);
request.Zone.DecorHandler.SpreadDecorChanges(decorDescription);
});
scope.Complete();
}
}
private static ItemShopEntry CreateItemShopEntryFromRecord(IDataRecord record)
{
var id = record.GetValue <int>("id");
var targetDefinition = record.GetValue <int>("targetdefinition");
var targetAmount = record.GetValue <int>("targetamount");
var globalLimit = record.GetValue <int?>("globalLimit");
var purchaseCount = record.GetValue <int>("purchaseCount");
var price = record.GetValue <double?>("credit") ?? 0.0;
var standing = record.GetValue <double?>("standing");
var tmCoin = record.GetValue <int?>("tmCoin") ?? 0;
var icsCoin = record.GetValue <int?>("icscoin") ?? 0;
var asiCoin = record.GetValue <int?>("asicoin") ?? 0;
var uniCoin = record.GetValue <int?>("unicoin") ?? 0;
return(new ItemShopEntry(id, EntityDefault.Get(targetDefinition), targetAmount, tmCoin, icsCoin, asiCoin, uniCoin, price, globalLimit, purchaseCount, standing));
}
static RobotSetup()
{
_setups = new List <RobotSetup>();
foreach (var record in Db.Query().CommandText("select * from robotsetup").Execute())
{
var robotShell = EntityDefault.Get(record.GetValue <int>(k.robotShell.ToLower()));
if (robotShell == EntityDefault.None)
{
continue;
}
var head = EntityDefault.Get(record.GetValue <int>(k.head));
if (head == EntityDefault.None)
{
continue;
}
var chassis = EntityDefault.Get(record.GetValue <int>(k.chassis));
if (chassis == EntityDefault.None)
{
continue;
}
var leg = EntityDefault.Get(record.GetValue <int>(k.leg));
if (leg == EntityDefault.None)
{
continue;
}
var container = EntityDefault.Get(record.GetValue <int>(k.container));
if (container == EntityDefault.None)
{
continue;
}
var hybridShell = EntityDefault.Get(record.GetValue <int>(k.hybridShell.ToLower()));
if (hybridShell == EntityDefault.None)
{
continue;
}
_setups.Add(new RobotSetup(robotShell, head, chassis, leg, container, hybridShell));
}
}
public static RobotTemplate CreateFromDictionary(string name, IDictionary <string, object> dictionary)
{
if (dictionary == null)
{
return(null);
}
var template = new RobotTemplate(name)
{
EntityDefault = EntityDefault.Get(dictionary.GetOrDefault(k.robot, 0)),
Head = RobotComponentTemplate <RobotHead> .Create(dictionary.GetOrDefault(k.head, 0), ModulesFromDictionary(dictionary, k.headModules)),
Chassis = RobotComponentTemplate <RobotChassis> .Create(dictionary.GetOrDefault(k.chassis, 0), ModulesFromDictionary(dictionary, k.chassisModules)),
Leg = RobotComponentTemplate <RobotLeg> .Create(dictionary.GetOrDefault(k.leg, 0), ModulesFromDictionary(dictionary, k.legModules)),
Inventory = RobotInventoryTemplate.Create(dictionary.GetOrDefault(k.container, 0), ItemsFromDictionary(dictionary, k.items))
};
return(template);
}
private int GetWallHealerRadius()
{
if (_wallHealerRadius == 0)
{
var dc = EntityDefault.Get(Definition).Config;
if (dc.item_work_range == null)
{
Logger.Error("consistency error in " + Definition + " " + ED.Name + " no item_work_range defined. ");
_wallHealerRadius = 10;
return(_wallHealerRadius);
}
_wallHealerRadius = (int)dc.item_work_range;
}
return(_wallHealerRadius);
}
/// <summary>
/// ONLY ADMIN
/// </summary>
public void SpawnRequiredComponentsAdmin(Character character)
{
var container = character.GetPublicContainer();
foreach (var component in Components)
{
//skip license, since that's only possible to get by creating it from the patent
if (EntityDefault.Get(component.EntityDefault.Definition).CategoryFlags.IsCategory(CategoryFlags.cf_documents))
{
continue;
}
var entity = Entity.Factory.CreateWithRandomEID(component.EntityDefault);
entity.Owner = character.Eid;
entity.Parent = container.Eid;
entity.Quantity = (int)(component.Amount * (1 + (FastRandom.NextDouble() * 2)));
entity.Save();
}
}
