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(); } }