public void TestlPerfomanceWithBigAdsCount() { const int GenerationCount = 10000; //long totalRndProfit = 0; //long totalMaxProfit = 0; //long totalRealProfit = 0; //totalMaxProfit += _maxAbsProfit; //_maxAbsProfit = 0; //totalRealProfit += _realProfit; //_realProfit = 0; //totalRndProfit += _rndProfit; //_rndProfit = 0; ResetState(); for (int a = 0; a < GenerationCount; a++) { List<Ad> ads = GenerateAds(200, 0, 0.3); TestPerfomance(ads); _rnd = new ThreadSafeRandom(); } //double perc = (double)_failedCount / (_failedCount + _correctCount); //Console.WriteLine("Failed: {0}%.", perc * 100); // Console.WriteLine("Done in {0} ms.", stopwatch.ElapsedMilliseconds); Console.WriteLine("Max profit: {0}. Real profit: {1}. Rnd profit: {2}", _maxAbsProfit, _realProfit, _rndProfit); Console.WriteLine("Real profit is smaller then max on: {0}%. Rnd profit: {1}%", (-100d * (_maxAbsProfit - _realProfit) / _maxAbsProfit), (-100d * (_maxAbsProfit - _rndProfit) / _maxAbsProfit)); }
//------------------------------------------------------------------------- public CellApp() { Instance = this; Cfg = new CellConfig(); Rd = new ThreadSafeRandom(); jsonCfg = new JsonConfig(); // 注册BtFactory _regBtFactory(new BtFactoryBot()); _regBtFactory(new BtFactoryPlayer()); }
public BeginTransactionRetryDecorator(ISqLiteTransactionWrapper decorated, ILogFactory log, ThreadSafeRandom threadSafeRandom) { Guard.NotNull(() => decorated, decorated); Guard.NotNull(() => log, log); Guard.NotNull(() => threadSafeRandom, threadSafeRandom); _decorated = decorated; _log = log.Create(); _threadSafeRandom = threadSafeRandom; }
/// <summary> /// Initializes the StrengthenMgr. /// </summary> /// <returns></returns> public static bool Init() { try { m_lock = new System.Threading.ReaderWriterLock(); _consortiaLevel = new Dictionary<int, ConsortiaLevelInfo>(); rand = new ThreadSafeRandom(); return Load(_consortiaLevel); } catch (Exception e) { if (log.IsErrorEnabled) log.Error("ConsortiaLevelMgr", e); return false; } }
/// <summary> /// Initializes the BallMgr. /// </summary> /// <returns></returns> public static bool Init() { try { m_lock = new System.Threading.ReaderWriterLock(); _fusions = new Dictionary<string, FusionInfo>(); rand = new ThreadSafeRandom(); return LoadFusion(_fusions); } catch (Exception e) { if (log.IsErrorEnabled) log.Error("FusionMgr", e); return false; } }
public static double Calculate(int iterations) { var random = new ThreadSafeRandom(); var inCircle = ParallelEnumerable.Range(0, iterations) // doesn't make sense to use more threads than we have processors .WithDegreeOfParallelism(Environment.ProcessorCount) .Select(_ => { double a, b; return Math.Sqrt((a = random.NextDouble()) * a + (b = random.NextDouble()) * b) <= 1; }) .Aggregate<bool, int, int>( 0, // Seed (agg, val) => val ? agg + 1 : agg, // Iterations (agg, subTotal) => agg + subTotal, // Aggregating subtotals result => result); // No projection of result needed return ((double)inCircle / iterations) * 4; }
/// <summary> /// Initializes the StrengthenMgr. /// </summary> /// <returns></returns> public static bool Init() { try { m_lock = new System.Threading.ReaderWriterLock(); _strengthens = new Dictionary<int, StrengthenInfo>(); m_Refinery_Strengthens = new Dictionary<int, StrengthenInfo>(); Strengthens_Goods = new Dictionary<int, StrengthenGoodsInfo>(); rand = new ThreadSafeRandom(); return LoadStrengthen(_strengthens, m_Refinery_Strengthens); } catch (Exception e) { if (log.IsErrorEnabled) log.Error("StrengthenMgr", e); return false; } }
public static double Calculate(int iterations) { var counterLockObject = new object(); int inCircle = 0; var random = new ThreadSafeRandom(); Parallel.For(0, iterations, // doesn't make sense to use more threads than we have processors new ParallelOptions() { MaxDegreeOfParallelism = Environment.ProcessorCount }, () => 0, (i, _, tLocal) => { #if LANG_EXPERIMENTAL // Note C# 6 declarating expression here return tLocal += Math.Sqrt((var a = random.NextDouble()) * a + (var b = random.NextDouble()) * b) <= 1 ? 1 : 0; #else double a, b; return tLocal += Math.Sqrt((a = random.NextDouble()) * a + (b = random.NextDouble()) * b) <= 1 ? 1 : 0; #endif }, subTotal => Interlocked.Add(ref inCircle, subTotal)); return ((double)inCircle / iterations) * 4; }
private static int GetArmorLevelModifier(int tier, int armorType) { // Olthoi Armor base weenies already have the full amount of AL if (armorType > (int)LootTables.ArmorType.OlthoiKoujiaArmor) { return(0); } if (armorType > (int)LootTables.ArmorType.HaebreanArmor && armorType < (int)LootTables.ArmorType.OlthoiAlduressaArmor) { switch (tier) { case 7: return(ThreadSafeRandom.Next(0, 40)); default: return(ThreadSafeRandom.Next(160, 200)); } } switch (tier) { case 1: if (armorType == (int)LootTables.ArmorType.StuddedLeatherArmor || armorType == (int)LootTables.ArmorType.Helms || armorType == (int)LootTables.ArmorType.Shields) { return(ThreadSafeRandom.Next(0, 27)); } else if (armorType == (int)LootTables.ArmorType.LeatherArmor || armorType == (int)LootTables.ArmorType.MiscClothing) { return(ThreadSafeRandom.Next(0, 23)); } else { return(ThreadSafeRandom.Next(0, 40)); } case 2: if (armorType == (int)LootTables.ArmorType.StuddedLeatherArmor || armorType == (int)LootTables.ArmorType.Helms || armorType == (int)LootTables.ArmorType.Shields) { return(ThreadSafeRandom.Next(27, 54)); } else if (armorType == (int)LootTables.ArmorType.LeatherArmor || armorType == (int)LootTables.ArmorType.MiscClothing) { return(ThreadSafeRandom.Next(23, 46)); } else { return(ThreadSafeRandom.Next(40, 80)); } case 3: if (armorType == (int)LootTables.ArmorType.StuddedLeatherArmor || armorType == (int)LootTables.ArmorType.Helms || armorType == (int)LootTables.ArmorType.Shields) { return(ThreadSafeRandom.Next(54, 81)); } else if (armorType == (int)LootTables.ArmorType.LeatherArmor || armorType == (int)LootTables.ArmorType.MiscClothing) { return(ThreadSafeRandom.Next(46, 69)); } else if (armorType == (int)LootTables.ArmorType.CovenantArmor) { return(ThreadSafeRandom.Next(90, 130)); } else { return(ThreadSafeRandom.Next(80, 120)); } case 4: if (armorType == (int)LootTables.ArmorType.StuddedLeatherArmor || armorType == (int)LootTables.ArmorType.Helms || armorType == (int)LootTables.ArmorType.Shields) { return(ThreadSafeRandom.Next(81, 108)); } else if (armorType == (int)LootTables.ArmorType.LeatherArmor || armorType == (int)LootTables.ArmorType.MiscClothing) { return(ThreadSafeRandom.Next(69, 92)); } else if (armorType == (int)LootTables.ArmorType.CovenantArmor) { return(ThreadSafeRandom.Next(130, 170)); } else { return(ThreadSafeRandom.Next(120, 160)); } case 5: if (armorType == (int)LootTables.ArmorType.StuddedLeatherArmor || armorType == (int)LootTables.ArmorType.Helms || armorType == (int)LootTables.ArmorType.Shields) { return(ThreadSafeRandom.Next(108, 135)); } else if (armorType == (int)LootTables.ArmorType.LeatherArmor || armorType == (int)LootTables.ArmorType.MiscClothing) { return(ThreadSafeRandom.Next(92, 115)); } else if (armorType == (int)LootTables.ArmorType.CovenantArmor) { return(ThreadSafeRandom.Next(170, 210)); } else { return(ThreadSafeRandom.Next(160, 200)); } case 6: if (armorType == (int)LootTables.ArmorType.StuddedLeatherArmor || armorType == (int)LootTables.ArmorType.Helms || armorType == (int)LootTables.ArmorType.Shields) { return(ThreadSafeRandom.Next(135, 162)); } else if (armorType == (int)LootTables.ArmorType.LeatherArmor || armorType == (int)LootTables.ArmorType.MiscClothing) { return(ThreadSafeRandom.Next(115, 138)); } else if (armorType == (int)LootTables.ArmorType.CovenantArmor) { return(ThreadSafeRandom.Next(210, 250)); } else { return(ThreadSafeRandom.Next(200, 240)); } case 7: if (armorType == (int)LootTables.ArmorType.StuddedLeatherArmor || armorType == (int)LootTables.ArmorType.Helms || armorType == (int)LootTables.ArmorType.Shields) { return(ThreadSafeRandom.Next(162, 189)); } else if (armorType == (int)LootTables.ArmorType.LeatherArmor || armorType == (int)LootTables.ArmorType.MiscClothing) { return(ThreadSafeRandom.Next(138, 161)); } else if (armorType == (int)LootTables.ArmorType.CovenantArmor) { return(ThreadSafeRandom.Next(250, 290)); } else { return(ThreadSafeRandom.Next(240, 280)); } case 8: if (armorType == (int)LootTables.ArmorType.StuddedLeatherArmor || armorType == (int)LootTables.ArmorType.Helms || armorType == (int)LootTables.ArmorType.Shields) { return(ThreadSafeRandom.Next(189, 216)); } else if (armorType == (int)LootTables.ArmorType.LeatherArmor || armorType == (int)LootTables.ArmorType.MiscClothing) { return(ThreadSafeRandom.Next(161, 184)); } else if (armorType == (int)LootTables.ArmorType.CovenantArmor) { return(ThreadSafeRandom.Next(290, 330)); } else { return(ThreadSafeRandom.Next(280, 320)); } default: return(0); } }
public static bool Init() { try { random = new ThreadSafeRandom(); m_lock = new System.Threading.ReaderWriterLock(); _maps = new Dictionary<int, MapPoint>(); _mapInfos = new Dictionary<int, Map>(); if (!LoadMap(_maps, _mapInfos)) return false; _serverMap = new Dictionary<int, List<int>>(); if (!InitServerMap(_serverMap)) return false; } catch (Exception e) { if (log.IsErrorEnabled) log.Error("MapMgr", e); return false; } return true; }
/// <summary> /// Initializes a new instance of the <see cref="UniformOneGenerator"/> class. /// </summary> /// /// <remarks>Initializes random numbers generator with zero seed.</remarks> /// public UniformOneGenerator( ) { rand = new ThreadSafeRandom( 0 ); }
private static void RandomizeArtGallery() { var wideAssets = TFCBuilder.ListTextureAssets("Kasumi.ArtGallery.wide").Select(x => $"Kasumi.ArtGallery.wide.{x}").ToList(); var tallAssets = TFCBuilder.ListTextureAssets("Kasumi.ArtGallery.tall").Select(x => $"Kasumi.ArtGallery.tall.{x}").ToList(); wideAssets.Shuffle(); tallAssets.Shuffle(); var artyGallery = GetKasumiArtGallerySetup(); foreach (var kagf in artyGallery) { var artGalleryF = MERFileSystem.GetPackageFile(kagf.PackageName); if (artGalleryF != null && File.Exists(artGalleryF)) { var artGalleryP = MEPackageHandler.OpenMEPackage(artGalleryF); // Rename instances so they're memory unique so we have a few more paintings if (kagf.RenameMemoryInstances) { if (kagf.TallTextureUIndexes != null) { foreach (var uindex in kagf.TallTextureUIndexes) { if (!artGalleryP.GetUExport(uindex).IsTexture()) { Debugger.Break(); } artGalleryP.GetUExport(uindex).ObjectName = $"ME2R_T_KASUMIPAINTING{ThreadSafeRandom.Next(15000)}"; } } // Rename mats so they're also unique if (kagf.WideTextureUIndexes != null) { foreach (var uindex in kagf.WideTextureUIndexes) { if (!artGalleryP.GetUExport(uindex).IsTexture()) { Debugger.Break(); } artGalleryP.GetUExport(uindex).ObjectName = $"ME2R_W_KASUMIPAINTING{ThreadSafeRandom.Next(15000)}"; } } if (kagf.MaterialUIndexes != null) { foreach (var uindex in kagf.MaterialUIndexes) { var exp = artGalleryP.GetUExport(uindex); if (!exp.ClassName.Contains("Material")) { Debugger.Break(); } artGalleryP.GetUExport(uindex).ObjectName = $"ME2R_PAINTMAT_KASUMI{ThreadSafeRandom.Next(15000)}"; } } } InstallARArtTextures(kagf.WideTextureUIndexes, wideAssets, artGalleryP, "Wide"); InstallARArtTextures(kagf.TallTextureUIndexes, tallAssets, artGalleryP, "Tall"); MERFileSystem.SavePackage(artGalleryP); } } }
public uint CalculateManaUsage(Creature caster, Spell spell, WorldObject target = null) { var baseCost = spell.BaseMana; // for casting spells built into a casting implement, use the ItemManaCost var castItem = caster.GetEquippedWand(); if (castItem != null && (castItem.SpellDID ?? 0) == spell.Id) { baseCost = (uint)(castItem.ItemManaCost ?? 0); } uint mana_conversion_skill = (uint)Math.Round(caster.GetCreatureSkill(Skill.ManaConversion).Current *GetWeaponManaConversionModifier(caster)); uint difficulty = spell.PowerMod; // modified power difficulty double baseManaPercent = 1.0; if (mana_conversion_skill > difficulty) { baseManaPercent = (double)difficulty / mana_conversion_skill; } uint preCost = 0; if ((spell.School == MagicSchool.ItemEnchantment) && (spell.MetaSpellType == SpellType.Enchantment) && (spell.Category >= SpellCategory.ArmorValueRaising) && (spell.Category <= SpellCategory.AcidicResistanceLowering) && target is Player targetPlayer) { int numTargetItems = 1; if (targetPlayer != null) { numTargetItems = targetPlayer.EquippedObjects.Values.Count(i => (i is Clothing || i.IsShield) && i.IsEnchantable); } preCost = (uint)Math.Round((baseCost + (spell.ManaMod * numTargetItems)) * baseManaPercent); } else if ((spell.Flags & SpellFlags.FellowshipSpell) != 0) { int numFellows = 1; var player = this as Player; if (player != null && player.Fellowship != null) { numFellows = player.Fellowship.FellowshipMembers.Count; } preCost = (uint)Math.Round((baseCost + (spell.ManaMod * numFellows)) * baseManaPercent); } else { preCost = (uint)Math.Round(baseCost * baseManaPercent); } if (preCost < 1) { preCost = 1; } uint manaUsed = ThreadSafeRandom.Next(1, preCost); return(manaUsed); }
private float DoCalculateDamage(Creature attacker, Creature defender, WorldObject damageSource) { var playerAttacker = attacker as Player; var playerDefender = defender as Player; Attacker = attacker; Defender = defender; CombatType = damageSource.ProjectileSource == null?attacker.GetCombatType() : CombatType.Missile; DamageSource = damageSource; Weapon = damageSource.ProjectileSource == null?attacker.GetEquippedWeapon() : damageSource.ProjectileLauncher; AttackType = attacker.AttackType; AttackHeight = attacker.AttackHeight ?? AttackHeight.Medium; // check lifestone protection if (playerDefender != null && playerDefender.UnderLifestoneProtection) { LifestoneProtection = true; playerDefender.HandleLifestoneProtection(); return(0.0f); } if (defender.Invincible) { return(0.0f); } // overpower if (attacker.Overpower != null) { Overpower = Creature.GetOverpower(attacker, defender); } // evasion chance if (!Overpower) { EvasionChance = GetEvadeChance(attacker, defender); if (EvasionChance > ThreadSafeRandom.Next(0.0f, 1.0f)) { Evaded = true; return(0.0f); } } // get base damage if (playerAttacker != null) { GetBaseDamage(playerAttacker); } else { GetBaseDamage(attacker, AttackMotion ?? MotionCommand.Invalid); } if (DamageType == DamageType.Undef && !AllowDamageTypeUndef.Contains(damageSource.WeenieClassId)) { log.Error($"DamageEvent.DoCalculateDamage({attacker?.Name} ({attacker?.Guid}), {defender?.Name} ({defender?.Guid}), {damageSource?.Name} ({damageSource?.Guid})) - DamageType == DamageType.Undef"); GeneralFailure = true; } if (GeneralFailure) { return(0.0f); } // get damage modifiers PowerMod = attacker.GetPowerMod(Weapon); AttributeMod = attacker.GetAttributeMod(Weapon); SlayerMod = WorldObject.GetWeaponCreatureSlayerModifier(attacker, defender); // ratings DamageRatingBaseMod = Creature.GetPositiveRatingMod(attacker.GetDamageRating()); RecklessnessMod = Creature.GetRecklessnessMod(attacker, defender); SneakAttackMod = attacker.GetSneakAttackMod(defender); HeritageMod = attacker.GetHeritageBonus(Weapon) ? 1.05f : 1.0f; DamageRatingMod = Creature.AdditiveCombine(DamageRatingBaseMod, RecklessnessMod, SneakAttackMod, HeritageMod); // damage before mitigation DamageBeforeMitigation = BaseDamage * AttributeMod * PowerMod * SlayerMod * DamageRatingMod; // critical hit? var attackSkill = attacker.GetCreatureSkill(attacker.GetCurrentWeaponSkill()); CriticalChance = WorldObject.GetWeaponCriticalChance(attacker, attackSkill, defender); if (CriticalChance > ThreadSafeRandom.Next(0.0f, 1.0f)) { if (playerDefender != null && playerDefender.AugmentationCriticalDefense > 0) { var criticalDefenseMod = playerAttacker != null ? 0.05f : 0.25f; var criticalDefenseChance = playerDefender.AugmentationCriticalDefense * criticalDefenseMod; if (criticalDefenseChance > ThreadSafeRandom.Next(0.0f, 1.0f)) { CriticalDefended = true; } } if (!CriticalDefended) { IsCritical = true; CriticalDamageMod = 1.0f + WorldObject.GetWeaponCritDamageMod(attacker, attackSkill, defender); // recklessness excluded from crits RecklessnessMod = 1.0f; DamageRatingMod = Creature.AdditiveCombine(DamageRatingBaseMod, SneakAttackMod, HeritageMod); DamageBeforeMitigation = BaseDamageMod.MaxDamage * AttributeMod * PowerMod * SlayerMod * DamageRatingMod * CriticalDamageMod; } } // armor rending and cleaving var armorRendingMod = 1.0f; if (Weapon != null && Weapon.HasImbuedEffect(ImbuedEffectType.ArmorRending)) { armorRendingMod = WorldObject.GetArmorRendingMod(attackSkill); } var armorCleavingMod = attacker.GetArmorCleavingMod(Weapon); var ignoreArmorMod = Math.Min(armorRendingMod, armorCleavingMod); // get body part / armor pieces / armor modifier if (playerDefender != null) { // select random body part @ current attack height GetBodyPart(AttackHeight); // get player armor pieces Armor = attacker.GetArmorLayers(playerDefender, BodyPart); // get armor modifiers ArmorMod = attacker.GetArmorMod(DamageType, Armor, Weapon, ignoreArmorMod); } else { // determine height quadrant Quadrant = GetQuadrant(Defender, Attacker, AttackHeight, DamageSource); // select random body part @ current attack height GetBodyPart(Defender, Quadrant); if (Evaded) { return(0.0f); } Armor = CreaturePart.GetArmorLayers(PropertiesBodyPart.Key); // get target armor ArmorMod = CreaturePart.GetArmorMod(DamageType, Armor, Attacker, Weapon, ignoreArmorMod); } if (Weapon != null && Weapon.HasImbuedEffect(ImbuedEffectType.IgnoreAllArmor)) { ArmorMod = 1.0f; } // get resistance modifiers WeaponResistanceMod = WorldObject.GetWeaponResistanceModifier(attacker, attackSkill, DamageType); if (playerDefender != null) { ResistanceMod = playerDefender.GetResistanceMod(DamageType, Attacker, Weapon, WeaponResistanceMod); } else { var resistanceType = Creature.GetResistanceType(DamageType); ResistanceMod = (float)Math.Max(0.0f, defender.GetResistanceMod(resistanceType, Attacker, Weapon, WeaponResistanceMod)); } // damage resistance rating DamageResistanceRatingMod = Creature.GetNegativeRatingMod(defender.GetDamageResistRating(CombatType)); // get shield modifier ShieldMod = defender.GetShieldMod(attacker, DamageType, Weapon); // calculate final output damage Damage = DamageBeforeMitigation * ArmorMod * ShieldMod * ResistanceMod * DamageResistanceRatingMod; DamageMitigated = DamageBeforeMitigation - Damage; return(Damage); }
public Spectrum Li(Ray r, Scene s) { /* BASIC Implement repeat r <- random ray from camera L <- 0, β <- 1, nbounces <- 0 repeat isect <- intersect r with scene if isect == null // no hit break wo <- -r if isect == light // light hit L<- β*Le(wo) // add light emitted break wi <- random ray from isect (f,pr) <- bsdf(isect,wi,wo) β <- β*f*|cosθ|/pr r <- wi nbounces <- nbounces+1 AddSampleToImage(L,r) */ /* Russian Roulette Implement (f,pr) <- bsdf(isect,wi,wo) β <- β*f*|cosθ|/pr r <- wi if nbounces>3 q <- 1 - max(β) if random() < q break β <- β/(1-q) */ var L = Spectrum.ZeroSpectrum; var beta = Spectrum.Create((double)1); int nbounces = 0; double q; while(nbounces < 20) { (double? mint, SurfaceInteraction si) = s.Intersect(r); // If nothing hit end if (si == null) { break; } // If Light hit include it and finish if (si.Obj is Light) { if (nbounces == 0) { L = beta * si.Le(si.Wo); //Console.WriteLine(beta.c); //Console.WriteLine(L.c); } break; } // Sample light from SurfaceInteraction // TODO Spectrum Ld = Light.UniformSampleOneLight(si, s); L = L.AddTo(beta * Ld); // Make new reflected Ray //Ray wi = si.SpawnRay(UniformSampleSphere()); // Get BSDF of hit object (Spectrum f, Vector3 wi, double pr, bool p) = (si.Obj as Shape).BSDF.Sample_f(si.Wo, si); // Update beta beta = beta * f * Utils.AbsCosTheta(wi) / pr; // Set reflected Ray as original Ray r = new Ray(si.Point, wi); if (nbounces > 3) { q = 1 - beta.Max(); if (ThreadSafeRandom.NextDouble() < q) { break; } beta /= (1 - q); } nbounces += 1; } Console.WriteLine(L.c); return L; }
private async Task PutFileAcrossDrivesAsync( FileRealizationMode allowedFileRealizationMode, bool contentAlreadyCached, bool contentShouldBeCached, Func <PutResult, bool> checkResult) { // This only works when we have multiple drives. if (FileSystem is not MemoryFileSystem) { return; } using (var testDirectory = new DisposableDirectory(FileSystem)) { var context = new Context(Logger); try { using (var store = Create(testDirectory.Path, Clock)) { await store.StartupAsync(context).ShouldBeSuccess(); byte[] bytes = ThreadSafeRandom.GetBytes(ValueSize); ContentHash contentHash = bytes.CalculateHash(ContentHashType); // Verify content doesn't exist yet in store Assert.False(await store.ContainsAsync(context, contentHash, null)); var pathToContentDifferentVolume = new AbsolutePath(PathGeneratorUtilities.GetAbsolutePath("D", "foo.txt")); try { FileSystem.WriteAllBytes(pathToContentDifferentVolume, bytes); if (contentAlreadyCached) { await store.PutFileAsync( context, pathToContentDifferentVolume, FileRealizationMode.Copy, ContentHashType, null).ShouldBeSuccess(); } var result = await store.PutFileAsync( context, pathToContentDifferentVolume, allowedFileRealizationMode, ContentHashType, null); Assert.True(checkResult(result)); (await store.ContainsAsync(context, contentHash, null)).Should() .Be(contentShouldBeCached); } finally { FileSystem.DeleteFile(pathToContentDifferentVolume); } await store.ShutdownAsync(context).ShouldBeSuccess(); } } finally { FileSystem.DeleteDirectory(testDirectory.Path, DeleteOptions.All); } } }
/// <summary> /// Performs a melee attack for the monster /// </summary> /// <returns>The length in seconds for the attack animation</returns> public float MeleeAttack() { var target = AttackTarget as Creature; var targetPlayer = AttackTarget as Player; var targetPet = AttackTarget as CombatPet; var combatPet = this as CombatPet; if (target == null || !target.IsAlive) { FindNextTarget(); return(0.0f); } if (CurrentMotionState.Stance == MotionStance.NonCombat) { DoAttackStance(); } // choose a random combat maneuver var maneuver = GetCombatManeuver(); if (maneuver == null) { Console.WriteLine($"Combat maneuver null! Stance {CurrentMotionState.Stance}, MotionTable {MotionTableId:X8}"); return(0.0f); } AttackHeight = maneuver.AttackHeight; DoSwingMotion(AttackTarget, maneuver, out float animLength, out var attackFrames); PhysicsObj.stick_to_object(AttackTarget.PhysicsObj.ID); var numStrikes = attackFrames.Count; var actionChain = new ActionChain(); var prevTime = 0.0f; for (var i = 0; i < numStrikes; i++) { actionChain.AddDelaySeconds(attackFrames[i] * animLength - prevTime); prevTime = attackFrames[i] * animLength; actionChain.AddAction(this, () => { if (AttackTarget == null || IsDead) { return; } if (WeenieType == WeenieType.GamePiece) { target.TakeDamage(this, DamageType.Slash, target.Health.Current); (this as GamePiece).OnDealtDamage(); return; } var weapon = GetEquippedWeapon(); var damageEvent = DamageEvent.CalculateDamage(this, target, weapon, maneuver); //var damage = CalculateDamage(ref damageType, maneuver, bodyPart, ref critical, ref shieldMod); if (damageEvent.HasDamage) { if (combatPet != null || targetPet != null) { // combat pet inflicting or receiving damage //Console.WriteLine($"{target.Name} taking {Math.Round(damage)} {damageType} damage from {Name}"); target.TakeDamage(this, damageEvent.DamageType, damageEvent.Damage); EmitSplatter(target, damageEvent.Damage); } else if (targetPlayer != null) { // this is a player taking damage targetPlayer.TakeDamage(this, damageEvent); if (damageEvent.ShieldMod != 1.0f) { var shieldSkill = targetPlayer.GetCreatureSkill(Skill.Shield); Proficiency.OnSuccessUse(targetPlayer, shieldSkill, shieldSkill.Current); // ? } } } else { target.OnEvade(this, CombatType.Melee); } if (combatPet != null) { combatPet.PetOnAttackMonster(target); } }); } actionChain.EnqueueChain(); // TODO: figure out exact speed / delay formula var meleeDelay = ThreadSafeRandom.Next(MeleeDelayMin, MeleeDelayMax); NextAttackTime = Timers.RunningTime + animLength + meleeDelay; return(animLength); }
private async Task Run() { ClusterMembershipSnapshot activeMembersSnapshot = default; SiloAddress[] otherNodes = default; TimeSpan? overrideDelay = ThreadSafeRandom.NextTimeSpan(_clusterMembershipOptions.CurrentValue.ProbeTimeout); while (await _pingTimer.NextTick(overrideDelay)) { ProbeResult probeResult; overrideDelay = default; try { // Discover the other active nodes in the cluster, if there are any. var membershipSnapshot = _membershipService.CurrentSnapshot; if (otherNodes is null || !object.ReferenceEquals(activeMembersSnapshot, membershipSnapshot)) { activeMembersSnapshot = membershipSnapshot; otherNodes = membershipSnapshot.Members.Values .Where(v => v.Status == SiloStatus.Active && v.SiloAddress != this.SiloAddress && v.SiloAddress != _localSiloDetails.SiloAddress) .Select(s => s.SiloAddress) .ToArray(); } var isDirectProbe = !_clusterMembershipOptions.CurrentValue.EnableIndirectProbes || _failedProbes < _clusterMembershipOptions.CurrentValue.NumMissedProbesLimit - 1 || otherNodes.Length == 0; var timeout = GetTimeout(isDirectProbe); var cancellation = new CancellationTokenSource(timeout); if (isDirectProbe) { // Probe the silo directly. probeResult = await this.ProbeDirectly(cancellation.Token).ConfigureAwait(false); } else { // Pick a random other node and probe the target indirectly, using the selected node as an intermediary. var intermediary = otherNodes[ThreadSafeRandom.Next(otherNodes.Length)]; // Select a timeout which will allow the intermediary node to attempt to probe the target node and still respond to this node // if the remote node does not respond in time. // Attempt to account for local health degradation by extending the timeout period. probeResult = await this.ProbeIndirectly(intermediary, timeout, cancellation.Token).ConfigureAwait(false); // If the intermediary is not entirely healthy, remove it from consideration and continue to probe. // Note that all recused silos will be included in the consideration set the next time cluster membership changes. if (probeResult.Status != ProbeResultStatus.Succeeded && probeResult.IntermediaryHealthDegradationScore > 0) { _log.LogInformation("Recusing unhealthy intermediary {Intermediary} and trying again with remaining nodes", intermediary); otherNodes = otherNodes.Where(node => !node.Equals(intermediary)).ToArray(); overrideDelay = TimeSpan.FromMilliseconds(250); } } if (!_stoppingCancellation.IsCancellationRequested) { await _onProbeResult(this, probeResult).ConfigureAwait(false); } } catch (Exception exception) { _log.LogError(exception, "Exception monitoring silo {SiloAddress}", SiloAddress); } } TimeSpan GetTimeout(bool isDirectProbe) { var additionalTimeout = 0; if (_clusterMembershipOptions.CurrentValue.ExtendProbeTimeoutDuringDegradation) { // Attempt to account for local health degradation by extending the timeout period. var localDegradationScore = _localSiloHealthMonitor.GetLocalHealthDegradationScore(DateTime.UtcNow); additionalTimeout += localDegradationScore; } if (!isDirectProbe) { // Indirect probes need extra time to account for the additional hop. additionalTimeout += 1; } return(_clusterMembershipOptions.CurrentValue.ProbeTimeout.Multiply(1 + additionalTimeout)); } }
public async Task ActivationSched_Turn_Execution_Order_Loop() { TaskScheduler scheduler = this.masterScheduler.GetWorkItemGroup(this.context).TaskScheduler; const int NumChains = 100; const int ChainLength = 3; // Can we add a unit test that basicaly checks that any turn is indeed run till completion before any other turn? // For example, you have a long running main turn and in the middle it spawns a lot of short CWs (on Done promise) and StartNew. // You test that no CW/StartNew runs until the main turn is fully done. And run in stress. var resultHandles = new TaskCompletionSource <bool> [NumChains]; Task[] taskChains = new Task[NumChains]; Task[] taskChainEnds = new Task[NumChains]; bool[] executingChain = new bool[NumChains]; int[] stageComplete = new int[NumChains]; int executingGlobal = -1; for (int i = 0; i < NumChains; i++) { int chainNum = i; // Capture int sleepTime = ThreadSafeRandom.Next(100); resultHandles[i] = new TaskCompletionSource <bool>(); taskChains[i] = new Task(() => { const int taskNum = 0; try { Assert.Equal(-1, executingGlobal); // "Detected unexpected other execution in chain " + chainNum + " Task " + taskNum Assert.False(executingChain[chainNum], "Detected unexpected other execution on chain " + chainNum + " Task " + taskNum); executingGlobal = chainNum; executingChain[chainNum] = true; Thread.Sleep(sleepTime); } finally { stageComplete[chainNum] = taskNum; executingChain[chainNum] = false; executingGlobal = -1; } }); Task task = taskChains[i]; for (int j = 1; j < ChainLength; j++) { int taskNum = j; // Capture task = task.ContinueWith(t => { if (t.IsFaulted) { throw t.Exception; } this.output.WriteLine("Inside Chain {0} Task {1}", chainNum, taskNum); try { Assert.Equal(-1, executingGlobal); // "Detected unexpected other execution in chain " + chainNum + " Task " + taskNum Assert.False(executingChain[chainNum], "Detected unexpected other execution on chain " + chainNum + " Task " + taskNum); Assert.Equal(taskNum - 1, stageComplete[chainNum]); // "Detected unexpected execution stage on chain " + chainNum + " Task " + taskNum executingGlobal = chainNum; executingChain[chainNum] = true; Thread.Sleep(sleepTime); } finally { stageComplete[chainNum] = taskNum; executingChain[chainNum] = false; executingGlobal = -1; } }, scheduler); } taskChainEnds[chainNum] = task.ContinueWith(t => { if (t.IsFaulted) { throw t.Exception; } this.output.WriteLine("Inside Chain {0} Final Task", chainNum); resultHandles[chainNum].SetResult(true); }, scheduler); } for (int i = 0; i < NumChains; i++) { taskChains[i].Start(scheduler); } for (int i = 0; i < NumChains; i++) { TimeSpan waitCheckTime = TimeSpan.FromMilliseconds(150 * ChainLength * NumChains * WaitFactor); try { await resultHandles[i].Task.WithTimeout(waitCheckTime); } catch (TimeoutException) { Assert.True(false, "Result did not arrive before timeout " + waitCheckTime); } bool ok = resultHandles[i].Task.Result; try { // since resultHandle being complete doesn't directly imply that the final chain was completed (there's a chance for a race condition), give a small chance for it to complete. await taskChainEnds[i].WithTimeout(TimeSpan.FromMilliseconds(10)); } catch (TimeoutException) { Assert.True(false, $"Task chain end {i} should complete very shortly after after its resultHandle"); } Assert.True(taskChainEnds[i].IsCompleted, "Task chain " + i + " should be completed"); Assert.False(taskChainEnds[i].IsFaulted, "Task chain " + i + " should not be Faulted: " + taskChainEnds[i].Exception); Assert.Equal(ChainLength - 1, stageComplete[i]); // "Task chain " + i + " should have completed all stages" Assert.True(ok, "Successfully waited for ResultHandle for Task chain " + i); } }
public async Task ActivationSched_WhenAny_Busy_Timeout() { TaskScheduler scheduler = this.masterScheduler.GetWorkItemGroup(this.context).TaskScheduler; var pause1 = new TaskCompletionSource <bool>(); var pause2 = new TaskCompletionSource <bool>(); var finish = new TaskCompletionSource <bool>(); Task <int> task1 = null; Task <int> task2 = null; Task join = null; Task wrapper = new Task(() => { task1 = Task <int> .Factory.StartNew(() => { this.output.WriteLine("Task-1 Started"); Assert.Equal(scheduler, TaskScheduler.Current); int num1 = 1; while (!pause1.Task.Result) // Infinite busy loop { num1 = ThreadSafeRandom.Next(); } this.output.WriteLine("Task-1 Done"); return(num1); }); task2 = Task <int> .Factory.StartNew(() => { this.output.WriteLine("Task-2 Started"); Assert.Equal(scheduler, TaskScheduler.Current); int num2 = 2; while (!pause2.Task.Result) // Infinite busy loop { num2 = ThreadSafeRandom.Next(); } this.output.WriteLine("Task-2 Done"); return(num2); }); join = Task.WhenAny(task1, task2, Task.Delay(TimeSpan.FromSeconds(2))); finish.SetResult(true); }); wrapper.Start(scheduler); var timeoutLimit = TimeSpan.FromSeconds(1); try { await finish.Task.WithTimeout(timeoutLimit); } catch (TimeoutException) { Assert.True(false, "Result did not arrive before timeout " + timeoutLimit); } Assert.NotNull(join); // Joined promise assigned await join; Assert.True(join.IsCompleted && !join.IsFaulted, "Join Status " + join.Status); Assert.False(task1.IsFaulted, "Task-1 Faulted " + task1.Exception); Assert.False(task1.IsCompleted, "Task-1 Status " + task1.Status); Assert.False(task2.IsFaulted, "Task-2 Faulted " + task2.Exception); Assert.False(task2.IsCompleted, "Task-2 Status " + task2.Status); }
private static IReadOnlyCollection <Parameter> BuildParametersWithAllCombinationsOfFlags( Type valueType = null, bool valueCanBeNull = true, bool valueMustBeNull = false) { if (valueType == null) { valueType = typeof(object); } var flags = new[] { true, false }; var result = new List <Parameter>(); foreach (var nameFlag in flags) { foreach (var mustFlag in flags) { foreach (var eachFlag in flags) { foreach (var validatedFlag in flags) { var parameter = new Parameter { Value = valueMustBeNull ? null : valueCanBeNull ? (ThreadSafeRandom.Next(0, 2) == 0 ? AD.ummy(valueType) : null) : AD.ummy(valueType), ValueType = valueType, Name = ThreadSafeRandom.Next(0, 2) == 0 ? A.Dummy <string>() : null, HasBeenNamed = nameFlag, HasBeenMusted = mustFlag, HasBeenEached = eachFlag, HasBeenValidated = validatedFlag, }; result.Add(parameter); } } } } return(result); }
public static bool CanChangeStyle(BaseRoom game, GSPacketIn pkg) { FightRateInfo[] allFightRateInfo = FightRateMgr.GetAllFightRateInfo(); try { FightRateInfo[] array = allFightRateInfo; for (int i = 0; i < array.Length; i++) { FightRateInfo fightRateInfo = array[i]; if (fightRateInfo.BeginDay.Year <= DateTime.Now.Year && DateTime.Now.Year <= fightRateInfo.EndDay.Year && fightRateInfo.BeginDay.DayOfYear <= DateTime.Now.DayOfYear && DateTime.Now.DayOfYear <= fightRateInfo.EndDay.DayOfYear && fightRateInfo.BeginTime.TimeOfDay <= DateTime.Now.TimeOfDay && DateTime.Now.TimeOfDay <= fightRateInfo.EndTime.TimeOfDay && ThreadSafeRandom.NextStatic(1000000) < fightRateInfo.Rate) { return(true); } } } catch { } pkg.WriteBoolean(false); return(false); }
/// <summary> /// Initializes a new instance of the <see cref="ExceptionDescriptor"/> class. /// </summary> public ExceptionDescriptor() { Id = ThreadSafeRandom.GenerateHexNumber(ExceptionDescriptor.ExceptionDescriptorIdLength); }
public static Ability Thunder(Element damageElement) { return(new Ability { Name = "Thunder", Description = string.Empty, Cooldown = 6, Type = Ability.Types.AbilityType.Offensive, ModelMetadata = new ModelMetadata { ConstructorName = "mc_ab_all_3040078000_03", JsAssetPath = "npc/60d4c46a-f1bd-4d11-b39b-e18835d5e21d/abilities/2/ab_all_3040078000_03.js", ImageAssets = { new ImageAsset { Name = "ab_all_3040078000_03", Path = "npc/60d4c46a-f1bd-4d11-b39b-e18835d5e21d/abilities/2/ab_all_3040078000_03.png", }, }, }, AnimationName = "ab_motion", Effects = { new AbilityEffect { Type = AbilityEffect.Types.AbilityEffectType.MultihitDamage, ExtraData = new MultihitDamage { Element = damageElement, HitNumber = 1, HitAllTargets = true, DamageModifier = 2, DamageCap = 470000, }.ToByteString(), }, }, ProcessEffects = (zooey, target, raidActions) => { var random = ThreadSafeRandom.NextDouble(); foreach (var enemy in zooey.Raid.Enemies) { if (enemy.IsAlive() && enemy.PositionInFrontline < 4) { enemy.ApplyStatusEffect( new StatusEffectSnapshot { Id = random <= 1.0 / 3 ? StatusEffectLibrary.StackableDefenseDownNpc : (random <= 2.0 / 3 ? StatusEffectLibrary.StackableAttackDownNpc : StatusEffectLibrary.StackableDebuffResistanceDownNpc), Strength = -10, IsStackable = true, StackingCap = random <= 1.0 / 3 ? -25 : -30, BaseAccuracy = 100, RemainingDurationInSeconds = 180, }, raidActions); } } }, }); }
public DatabaseDummyFactory() { // ------------------------------- EVENTS ------------------------------------- AutoFixtureBackedDummyFactory.AddDummyCreator( () => new HandlingForStreamDisabledEvent( A.Dummy <UtcDateTime>(), A.Dummy <string>())); AutoFixtureBackedDummyFactory.AddDummyCreator( () => new HandlingForStreamEnabledEvent( A.Dummy <UtcDateTime>(), A.Dummy <string>())); AutoFixtureBackedDummyFactory.AddDummyCreator( () => new HandlingForRecordDisabledEvent( A.Dummy <long>(), A.Dummy <string>(), A.Dummy <UtcDateTime>(), A.Dummy <string>())); AutoFixtureBackedDummyFactory.AddDummyCreator( () => { var record = A.Dummy <StreamRecord>(); return(new RecordHandlingAvailableEvent( record.InternalRecordId, A.Dummy <string>(), record, A.Dummy <UtcDateTime>(), A.Dummy <string>())); }); AutoFixtureBackedDummyFactory.AddDummyCreator( () => new RecordHandlingCanceledEvent( A.Dummy <long>(), A.Dummy <string>(), A.Dummy <UtcDateTime>(), A.Dummy <string>())); AutoFixtureBackedDummyFactory.AddDummyCreator( () => new RecordHandlingCompletedEvent( A.Dummy <long>(), A.Dummy <string>(), A.Dummy <UtcDateTime>(), A.Dummy <string>())); AutoFixtureBackedDummyFactory.AddDummyCreator( () => new RecordHandlingFailedEvent( A.Dummy <long>(), A.Dummy <string>(), A.Dummy <UtcDateTime>(), A.Dummy <string>())); AutoFixtureBackedDummyFactory.AddDummyCreator( () => new RecordHandlingFailureResetEvent( A.Dummy <long>(), A.Dummy <string>(), A.Dummy <UtcDateTime>(), A.Dummy <string>())); AutoFixtureBackedDummyFactory.AddDummyCreator( () => new RecordHandlingRunningEvent( A.Dummy <long>(), A.Dummy <string>(), A.Dummy <UtcDateTime>(), A.Dummy <string>())); AutoFixtureBackedDummyFactory.AddDummyCreator( () => new RecordHandlingSelfCanceledEvent( A.Dummy <long>(), A.Dummy <string>(), A.Dummy <UtcDateTime>(), A.Dummy <string>())); AutoFixtureBackedDummyFactory.AddDummyCreator( () => new PruneOperationExecutedEvent( A.Dummy <IPruneOp>(), A.Dummy <PruneSummary>(), A.Dummy <UtcDateTime>())); AutoFixtureBackedDummyFactory.AddDummyCreator( () => new PruneOperationRequestedEvent( A.Dummy <IPruneOp>(), A.Dummy <UtcDateTime>())); AutoFixtureBackedDummyFactory.AddDummyCreator( () => new PruneRequestCanceledEvent( A.Dummy <string>(), A.Dummy <UtcDateTime>())); AutoFixtureBackedDummyFactory.AddDummyCreator( () => new UniqueLongIssuedEvent( A.Dummy <long>(), A.Dummy <UtcDateTime>(), A.Dummy <string>())); AutoFixtureBackedDummyFactory.AddDummyCreator( () => { var result = new IdDeprecatedEvent( A.Dummy <UtcDateTime>(), A.Dummy <string>()); return(result); }); AutoFixtureBackedDummyFactory.AddDummyCreator( () => new IdDeprecatedEvent <Version, Version>( A.Dummy <Version>(), A.Dummy <UtcDateTime>(), A.Dummy <string>())); AutoFixtureBackedDummyFactory.AddDummyCreator( () => new IdDeprecatedEvent <Version>( A.Dummy <UtcDateTime>(), A.Dummy <string>())); // ------------------------------- MODELS ------------------------------------- AutoFixtureBackedDummyFactory.AddDummyCreator( () => new StreamRecordHandlingEntry( A.Dummy <long>(), A.Dummy <long>(), A.Dummy <string>(), A.Dummy <HandlingStatus>(), A.Dummy <IReadOnlyCollection <NamedValue <string> > >(), A.Dummy <string>(), A.Dummy <UtcDateTime>())); AutoFixtureBackedDummyFactory.AddDummyCreator( () => { var scenario = ThreadSafeRandom.Next(1, 4); switch (scenario) { case 1: return(new CreateStreamResult(false, true)); case 2: return(new CreateStreamResult(true, false)); case 3: return(new CreateStreamResult(true, true)); default: throw new NotSupportedException( FormattableString.Invariant($"Invalid scenario {scenario} for creating a dummy {nameof(CreateStreamResult)}.")); } }); AutoFixtureBackedDummyFactory.AddDummyCreator( () => new StreamRecordMetadata( A.Dummy <string>(), A.Dummy <SerializerRepresentation>(), A.Dummy <TypeRepresentationWithAndWithoutVersion>(), A.Dummy <TypeRepresentationWithAndWithoutVersion>(), A.Dummy <IReadOnlyCollection <NamedValue <string> > >(), A.Dummy <UtcDateTime>(), A.Dummy <UtcDateTime>())); AutoFixtureBackedDummyFactory.AddDummyCreator( () => new StreamRecordMetadata <Version>( A.Dummy <Version>(), A.Dummy <SerializerRepresentation>(), A.Dummy <TypeRepresentationWithAndWithoutVersion>(), A.Dummy <TypeRepresentationWithAndWithoutVersion>(), A.Dummy <IReadOnlyCollection <NamedValue <string> > >(), A.Dummy <UtcDateTime>(), A.Dummy <UtcDateTime>())); AutoFixtureBackedDummyFactory.AddDummyCreator( () => new GetStreamFromRepresentationOp <FileStreamRepresentation, MemoryStandardStream>( A.Dummy <FileStreamRepresentation>())); AutoFixtureBackedDummyFactory.AddDummyCreator( () => { var scenario = ThreadSafeRandom.Next(1, 5); switch (scenario) { case 1: return(new PutRecordResult(A.Dummy <long>(), null)); case 2: return(new PutRecordResult(null, Some.ReadOnlyDummies <long>().ToList())); case 3: return(new PutRecordResult(null, Some.ReadOnlyDummies <long>().ToList(), Some.ReadOnlyDummies <long>().ToList())); case 4: return(new PutRecordResult(A.Dummy <long>(), Some.ReadOnlyDummies <long>().ToList(), Some.ReadOnlyDummies <long>().ToList())); default: throw new NotSupportedException(FormattableString.Invariant($"Invalid scenario {scenario} for creating a dummy {nameof(PutRecordResult)}.")); } }); AutoFixtureBackedDummyFactory.AddDummyCreator( () => { var scenario = ThreadSafeRandom.Next(1, 4); switch (scenario) { case 1: return(new TryHandleRecordResult(null, false)); case 2: return(new TryHandleRecordResult(A.Dummy <StreamRecord>(), false)); case 3: return(new TryHandleRecordResult(null, true)); default: throw new NotSupportedException(FormattableString.Invariant($"Invalid scenario {scenario} for creating a dummy {nameof(TryHandleRecordResult)}.")); } }); // ------------------------------- ENUMS -------------------------------------- AutoFixtureBackedDummyFactory.ConstrainDummyToBeOneOf(VersionMatchStrategy.Any, VersionMatchStrategy.SpecifiedVersion); AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(CompositeHandlingStatus.Unknown); AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(ExistingDatabaseStrategy.Unknown); AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(ExistingRecordStrategy.Unknown); AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(ExistingStreamStrategy.Unknown); AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(HandlingStatus.Unknown); AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(OrderRecordsBy.Unknown); AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(RecordNotFoundStrategy.Unknown); AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(StreamNotFoundStrategy.Unknown); AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(StreamRecordItemsToInclude.Unknown); AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(TagMatchStrategy.Unknown); // ------------------------------- MODEL INTERFACES -------------------------------------- AutoFixtureBackedDummyFactory.UseRandomInterfaceImplementationForDummy <IResourceLocator>(); AutoFixtureBackedDummyFactory.UseRandomInterfaceImplementationForDummy <IStreamRepresentation>(); // ------------------------------- OPERATIONS ------------------------------------- AutoFixtureBackedDummyFactory.AddDummyCreator( () => new PruneBeforeInternalRecordDateOp( A.Dummy <UtcDateTime>(), A.Dummy <string>())); AutoFixtureBackedDummyFactory.AddDummyCreator( () => new StandardPruneStreamOp( A.Dummy <long>(), A.Dummy <UtcDateTime>(), A.Dummy <string>(), A.Dummy <IResourceLocator>())); AutoFixtureBackedDummyFactory.AddDummyCreator( () => new StandardUpdateHandlingStatusForRecordOp( A.Dummy <long>(), A.Dummy <string>(), A.Dummy <HandlingStatus>().ThatIsNot(HandlingStatus.DisabledForStream), Some.ReadOnlyDummies <HandlingStatus>().ToList(), A.Dummy <string>(), Some.ReadOnlyDummies <NamedValue <string> >().ToList(), A.Dummy <bool>(), A.Dummy <IResourceLocator>())); AutoFixtureBackedDummyFactory.AddDummyCreator( () => new StandardUpdateHandlingStatusForStreamOp( A.Dummy <HandlingStatus>().ThatIsIn(new[] { HandlingStatus.DisabledForStream, HandlingStatus.AvailableByDefault }), A.Dummy <string>(), Some.ReadOnlyDummies <NamedValue <string> >().ToList(), A.Dummy <IResourceLocator>())); AutoFixtureBackedDummyFactory.AddDummyCreator( () => { var existingRecordStrategy = A.Dummy <ExistingRecordStrategy>(); var result = new PutAndReturnInternalRecordIdOp <Version>( A.Dummy <Version>(), A.Dummy <IReadOnlyCollection <NamedValue <string> > >(), existingRecordStrategy, existingRecordStrategy == ExistingRecordStrategy.PruneIfFoundById || existingRecordStrategy == ExistingRecordStrategy.PruneIfFoundByIdAndType ? (int?)A.Dummy <ZeroOrPositiveInteger>() : null, A.Dummy <VersionMatchStrategy>()); return(result); }); AutoFixtureBackedDummyFactory.AddDummyCreator( () => { var existingRecordStrategy = A.Dummy <ExistingRecordStrategy>(); var result = new PutOp <Version>( A.Dummy <Version>(), A.Dummy <IReadOnlyCollection <NamedValue <string> > >(), existingRecordStrategy, existingRecordStrategy == ExistingRecordStrategy.PruneIfFoundById || existingRecordStrategy == ExistingRecordStrategy.PruneIfFoundByIdAndType ? (int?)A.Dummy <ZeroOrPositiveInteger>() : null, A.Dummy <VersionMatchStrategy>()); return(result); }); AutoFixtureBackedDummyFactory.AddDummyCreator( () => { var existingRecordStrategy = A.Dummy <ExistingRecordStrategy>(); var result = new PutWithIdAndReturnInternalRecordIdOp <Version, Version>( A.Dummy <Version>(), A.Dummy <Version>(), A.Dummy <IReadOnlyCollection <NamedValue <string> > >(), existingRecordStrategy, existingRecordStrategy == ExistingRecordStrategy.PruneIfFoundById || existingRecordStrategy == ExistingRecordStrategy.PruneIfFoundByIdAndType ? (int?)A.Dummy <ZeroOrPositiveInteger>() : null, A.Dummy <VersionMatchStrategy>()); return(result); }); AutoFixtureBackedDummyFactory.AddDummyCreator( () => { var existingRecordStrategy = A.Dummy <ExistingRecordStrategy>(); var result = new PutWithIdOp <Version, Version>( A.Dummy <Version>(), A.Dummy <Version>(), A.Dummy <IReadOnlyCollection <NamedValue <string> > >(), existingRecordStrategy, existingRecordStrategy == ExistingRecordStrategy.PruneIfFoundById || existingRecordStrategy == ExistingRecordStrategy.PruneIfFoundByIdAndType ? (int?)A.Dummy <ZeroOrPositiveInteger>() : null, A.Dummy <VersionMatchStrategy>()); return(result); }); AutoFixtureBackedDummyFactory.AddDummyCreator( () => { var existingRecordStrategy = A.Dummy <ExistingRecordStrategy>(); var result = new StandardPutRecordOp( A.Dummy <StreamRecordMetadata>(), A.Dummy <DescribedSerializationBase>(), existingRecordStrategy, existingRecordStrategy == ExistingRecordStrategy.PruneIfFoundById || existingRecordStrategy == ExistingRecordStrategy.PruneIfFoundByIdAndType ? (int?)A.Dummy <ZeroOrPositiveInteger>() : null, A.Dummy <VersionMatchStrategy>(), A.Dummy <long?>(), A.Dummy <IResourceLocator>()); return(result); }); // ------------------------------- OPERATION INTERFACES ------------------------------------- AutoFixtureBackedDummyFactory.UseRandomInterfaceImplementationForDummy <IPruneOp>(); }
private static MemoryStream RandomStream(long size) { return(new MemoryStream(ThreadSafeRandom.GetBytes((int)size))); }
/// <summary> /// Starts the process of monster turning towards target /// </summary> public void StartTurn() { //if (Timers.RunningTime < NextMoveTime) //return; if (!MoveReady()) { return; } if (DebugMove) { Console.WriteLine($"{Name} ({Guid}) - StartTurn, ranged={IsRanged}"); } if (MoveSpeed == 0.0f) { GetMovementSpeed(); } //Console.WriteLine($"[{Timers.RunningTime}] - {Name} ({Guid}) - starting turn"); IsTurning = true; // send network actions var targetDist = GetDistanceToTarget(); var turnTo = IsRanged || (CurrentAttack == CombatType.Magic && targetDist <= GetSpellMaxRange()); if (turnTo) { TurnTo(AttackTarget); } else { MoveTo(AttackTarget, RunRate); } // need turning listener? IsTurning = false; IsMoving = true; LastMoveTime = Timers.RunningTime; NextCancelTime = LastMoveTime + ThreadSafeRandom.Next(2, 4); var mvp = GetMovementParameters(); if (turnTo) { PhysicsObj.TurnToObject(AttackTarget.PhysicsObj.ID, mvp); } else { PhysicsObj.MoveToObject(AttackTarget.PhysicsObj, mvp); } if (!InitSticky) { PhysicsObj.add_moveto_listener(OnMoveComplete); PhysicsObj.add_sticky_listener(OnSticky); PhysicsObj.add_unsticky_listener(OnUnsticky); InitSticky = true; } }
internal static IGrainContext PickRandom(List <IGrainContext> local) => local[local.Count == 1 ? 0 : ThreadSafeRandom.Next(local.Count)];
public static bool RandomizeExport(ExportEntry export, RandomizationOption option) { if (!CanRandomize(export)) { return(false); } MERLog.Information($"[{Path.GetFileNameWithoutExtension(export.FileRef.FilePath)}] Randomizing movement interpolations for " + export.UIndex + ": " + export.InstancedFullPath); var props = export.GetProperties(); var posTrack = props.GetProp <StructProperty>("PosTrack"); if (posTrack != null) { var points = posTrack.GetProp <ArrayProperty <StructProperty> >("Points"); if (points != null) { foreach (StructProperty s in points) { var outVal = s.GetProp <StructProperty>("OutVal"); if (outVal != null) { FloatProperty x = outVal.GetProp <FloatProperty>("X"); FloatProperty y = outVal.GetProp <FloatProperty>("Y"); FloatProperty z = outVal.GetProp <FloatProperty>("Z"); x.Value = x.Value * ThreadSafeRandom.NextFloat(1 - option.SliderValue, 1 + option.SliderValue); y.Value = y.Value * ThreadSafeRandom.NextFloat(1 - option.SliderValue, 1 + option.SliderValue); z.Value = z.Value * ThreadSafeRandom.NextFloat(1 - option.SliderValue, 1 + option.SliderValue); } } } } var eulerTrack = props.GetProp <StructProperty>("EulerTrack"); if (eulerTrack != null) { var points = eulerTrack.GetProp <ArrayProperty <StructProperty> >("Points"); if (points != null) { foreach (StructProperty s in points) { var outVal = s.GetProp <StructProperty>("OutVal"); if (outVal != null) { FloatProperty x = outVal.GetProp <FloatProperty>("X"); FloatProperty y = outVal.GetProp <FloatProperty>("Y"); FloatProperty z = outVal.GetProp <FloatProperty>("Z"); if (x.Value != 0) { x.Value = x.Value * ThreadSafeRandom.NextFloat(1 - option.SliderValue, 1 + option.SliderValue); } else { x.Value = ThreadSafeRandom.NextFloat(0, ThreadSafeRandom.NextFloat(-1000 * option.SliderValue, 1000 * option.SliderValue)); } if (y.Value != 0) { y.Value = y.Value * ThreadSafeRandom.NextFloat(1 - option.SliderValue, 1 + option.SliderValue); } else { y.Value = ThreadSafeRandom.NextFloat(0, ThreadSafeRandom.NextFloat(-1000 * option.SliderValue, 1000 * option.SliderValue)); } if (z.Value != 0) { z.Value = z.Value * ThreadSafeRandom.NextFloat(1 - option.SliderValue, 1 + option.SliderValue); } else { z.Value = ThreadSafeRandom.NextFloat(0, ThreadSafeRandom.NextFloat(-1000 * option.SliderValue, 1000 * option.SliderValue)); } } } } } export.WriteProperties(props); return(true); }
public Task PutSameContentManyTimesTest(bool useRedundantPutFileShortcut) { var context = new Context(Logger); ContentStoreSettings = new ContentStoreSettings() { UseRedundantPutFileShortcut = useRedundantPutFileShortcut }; return(TestStore(context, Clock, async store => { byte[] bytes = ThreadSafeRandom.GetBytes(ValueSize); ContentHash contentHash = bytes.CalculateHash(ContentHashType); // Verify content doesn't exist yet in store Assert.False(await store.ContainsAsync(context, contentHash, null)); using (var tempDirectory = new DisposableDirectory(FileSystem)) { ContentHash hashFromPut; using (var pinContext = store.CreatePinContext()) { var concurrency = 24; var iterations = 100; var items = Enumerable.Range(0, concurrency).Select(i => { AbsolutePath pathToContent = tempDirectory.Path / $"tempContent{i}.txt"; FileSystem.WriteAllBytes(pathToContent, bytes); return (pathToContent, iterations); }).ToArray(); int nonDuplicatedPuts = 0; await ParallelAlgorithms.WhenDoneAsync(24, CancellationToken.None, async(scheduleItem, item) => { // Put the content into the store w/ hard link var r = await store.PutFileAsync( context, item.pathToContent, FileRealizationMode.Any, ContentHashType, new PinRequest(pinContext)); hashFromPut = r.ContentHash; if (!r.ContentAlreadyExistsInCache) { Interlocked.Increment(ref nonDuplicatedPuts); } Clock.Increment(); Assert.True(pinContext.Contains(hashFromPut)); if (item.iterations != 0) { scheduleItem((item.pathToContent, item.iterations - 1)); } }, items); Assert.Equal(1, nonDuplicatedPuts); } } })); }
public void SetCaptain() { List<int> list = new List<int>(); ThreadSafeRandom random = new ThreadSafeRandom(); GamePlayer[] players = Data.FlagPlayer.ToArray(); int rand = random.Next(players.Length); for (int i = rand; i < players.Length + rand; i++) { if (Data.Players[players[i % players.Length]].State == TankGameState.LOSE) continue; if (players[i % players.Length].CurrentTeamIndex != 0) { if (!list.Contains(players[i % players.Length].CurrentTeamIndex)) { list.Add(players[i % players.Length].CurrentTeamIndex); Data.Players[players[i % players.Length]].IsCaptain = true; } else { Data.Players[players[i % players.Length]].IsCaptain = false; } } else { list.Add(0); Data.Players[players[i % players.Length]].IsCaptain = true; } } players = Data.Players.Keys.ToArray(); rand = random.Next(players.Length); for (int i = rand; i < players.Length + rand; i++) { if (Data.Players[players[i % players.Length]].State == TankGameState.LOSE) continue; if (!list.Contains(players[i % players.Length].CurrentTeamIndex)) { list.Add(players[i % players.Length].CurrentTeamIndex); Data.Players[players[i % players.Length]].IsCaptain = true; } } }
private float DoCalculateDamage(Creature attacker, Creature defender, WorldObject damageSource) { var playerAttacker = attacker as Player; var playerDefender = defender as Player; Attacker = attacker; Defender = defender; CombatType = attacker.GetCombatType(); DamageSource = damageSource; Weapon = attacker.GetEquippedWeapon(); AttackType = attacker.GetAttackType(Weapon, CombatManeuver); AttackHeight = attacker.AttackHeight ?? AttackHeight.Medium; // check lifestone protection if (playerDefender != null && playerDefender.UnderLifestoneProtection) { LifestoneProtection = true; playerDefender.HandleLifestoneProtection(); return(0.0f); } if (defender.Invincible) { return(0.0f); } // evasion chance EvasionChance = GetEvadeChance(attacker, defender); if (EvasionChance > ThreadSafeRandom.Next(0.0f, 1.0f)) { Evaded = true; return(0.0f); } // get base damage if (playerAttacker != null) { GetBaseDamage(playerAttacker, CombatManeuver); } else { GetBaseDamage(attacker, CombatManeuver); } if (GeneralFailure) { return(0.0f); } // get damage modifiers PowerMod = attacker.GetPowerMod(Weapon); AttributeMod = attacker.GetAttributeMod(Weapon); SlayerMod = WorldObject.GetWeaponCreatureSlayerModifier(attacker, defender); // ratings DamageRatingBaseMod = Creature.GetPositiveRatingMod(attacker.GetDamageRating()); RecklessnessMod = Creature.GetRecklessnessMod(attacker, defender); SneakAttackMod = attacker.GetSneakAttackMod(defender); HeritageMod = attacker.GetHeritageBonus(Weapon) ? 1.05f : 1.0f; DamageRatingMod = Creature.AdditiveCombine(DamageRatingBaseMod, RecklessnessMod, SneakAttackMod, HeritageMod); // damage before mitigation DamageBeforeMitigation = BaseDamage * AttributeMod * PowerMod * SlayerMod * DamageRatingMod; // critical hit? var attackSkill = attacker.GetCreatureSkill(attacker.GetCurrentWeaponSkill()); CriticalChance = WorldObject.GetWeaponCritChanceModifier(attacker, attackSkill, defender); if (CriticalChance > ThreadSafeRandom.Next(0.0f, 1.0f)) { var criticalDefended = false; if (playerDefender != null && playerDefender.AugmentationCriticalDefense > 0) { var criticalDefenseMod = playerAttacker != null ? 0.05f : 0.25f; var criticalDefenseChance = playerDefender.AugmentationCriticalDefense * criticalDefenseMod; if (criticalDefenseChance > ThreadSafeRandom.Next(0.0f, 1.0f)) { criticalDefended = true; } } if (!criticalDefended) { IsCritical = true; CriticalDamageMod = 1.0f + WorldObject.GetWeaponCritDamageMod(attacker, attackSkill, defender); // recklessness excluded from crits RecklessnessMod = 1.0f; DamageRatingMod = Creature.AdditiveCombine(DamageRatingBaseMod, SneakAttackMod, HeritageMod); DamageBeforeMitigation = BaseDamageMod.MaxDamage * AttributeMod * PowerMod * SlayerMod * DamageRatingMod * CriticalDamageMod; } } // Armor Rending reduces physical armor too? var armorRendingMod = 1.0f; if (Weapon != null && Weapon.HasImbuedEffect(ImbuedEffectType.ArmorRending)) { armorRendingMod = WorldObject.GetArmorRendingMod(attackSkill); } // get body part / armor pieces / armor modifier if (playerDefender != null) { // select random body part @ current attack height GetBodyPart(AttackHeight); // get player armor pieces Armor = attacker.GetArmorLayers(playerDefender, BodyPart); // get armor modifiers ArmorMod = attacker.GetArmorMod(DamageType, Armor, Weapon, armorRendingMod); } else { // select random body part @ current attack height GetBodyPart(AttackHeight, defender); if (Evaded) { return(0.0f); } Armor = CreaturePart.GetArmorLayers((CombatBodyPart)BiotaPropertiesBodyPart.Key); // get target armor ArmorMod = CreaturePart.GetArmorMod(DamageType, Armor, Weapon, armorRendingMod); } if (Weapon != null && Weapon.HasImbuedEffect(ImbuedEffectType.IgnoreAllArmor)) { ArmorMod = 1.0f; } // get resistance modifiers WeaponResistanceMod = WorldObject.GetWeaponResistanceModifier(attacker, attackSkill, DamageType); if (playerDefender != null) { ResistanceMod = playerDefender.GetResistanceMod(DamageType, Weapon, WeaponResistanceMod); } else { var resistanceType = Creature.GetResistanceType(DamageType); ResistanceMod = (float)defender.GetResistanceMod(resistanceType, Weapon, WeaponResistanceMod); } // damage resistance rating DamageResistanceRatingMod = Creature.GetNegativeRatingMod(defender.GetDamageResistRating(CombatType)); // get shield modifier ShieldMod = defender.GetShieldMod(attacker, DamageType, Weapon); // calculate final output damage Damage = DamageBeforeMitigation * ArmorMod * ShieldMod * ResistanceMod * DamageResistanceRatingMod; DamageMitigated = DamageBeforeMitigation - Damage; return(Damage); }
static StoredProcedureExecutionResultTest() { ConstructorArgumentValidationTestScenarios .RemoveAllScenarios() .AddScenario(() => new ConstructorArgumentValidationTestScenario <StoredProcedureExecutionResult> { Name = "constructor should throw ArgumentNullException when parameter 'operation' is null scenario", ConstructionFunc = () => { var referenceObject = A.Dummy <StoredProcedureExecutionResult>(); var result = new StoredProcedureExecutionResult( null, referenceObject.OutputParameters); return(result); }, ExpectedExceptionType = typeof(ArgumentNullException), ExpectedExceptionMessageContains = new[] { "operation", }, }) .AddScenario(() => new ConstructorArgumentValidationTestScenario <StoredProcedureExecutionResult> { Name = "constructor should throw ArgumentNullException when parameter 'outputParameters' is null scenario", ConstructionFunc = () => { var referenceObject = A.Dummy <StoredProcedureExecutionResult>(); var result = new StoredProcedureExecutionResult( referenceObject.Operation, null); return(result); }, ExpectedExceptionType = typeof(ArgumentNullException), ExpectedExceptionMessageContains = new[] { "outputParameters", }, }) .AddScenario(() => new ConstructorArgumentValidationTestScenario <StoredProcedureExecutionResult> { Name = "constructor should throw ArgumentException when parameter 'outputParameters' contains a key-value pair with a null value scenario", ConstructionFunc = () => { var referenceObject = A.Dummy <StoredProcedureExecutionResult>(); var dictionaryWithNullValue = referenceObject.OutputParameters.ToDictionary(_ => _.Key, _ => _.Value); var randomKey = dictionaryWithNullValue.Keys.ElementAt(ThreadSafeRandom.Next(0, dictionaryWithNullValue.Count)); dictionaryWithNullValue[randomKey] = null; var result = new StoredProcedureExecutionResult( referenceObject.Operation, dictionaryWithNullValue); return(result); }, ExpectedExceptionType = typeof(ArgumentException), ExpectedExceptionMessageContains = new[] { "outputParameters", "contains at least one key-value pair with a null value", }, }); }
public static void Train(string udSource, string ontonotesSource) { var trainFiles = Directory.GetFiles(udSource, "*-train.conllu", SearchOption.AllDirectories); var testFiles = Directory.GetFiles(udSource, "*-dev.conllu", SearchOption.AllDirectories); List <string> trainFilesOntonotesEnglish = null; if (!string.IsNullOrWhiteSpace(ontonotesSource)) { trainFilesOntonotesEnglish = Directory.GetFiles(ontonotesSource, "*.parse.ddg", SearchOption.AllDirectories) .Where(fn => !fn.Contains("sel_") || int.Parse(Path.GetFileNameWithoutExtension(fn).Split(new char[] { '_', '.' }).Skip(1).First()) < 3654) .ToList(); } var trainFilesPerLanguage = trainFiles.Select(f => new { lang = Path.GetFileNameWithoutExtension(f).Replace("_", "-").Split(new char[] { '-' }).First(), file = f }).GroupBy(f => f.lang).ToDictionary(g => g.Key, g => g.Select(f => f.file).ToList()); var testFilesPerLanguage = testFiles.Select(f => new { lang = Path.GetFileNameWithoutExtension(f).Replace("_", "-").Split(new char[] { '-' }).First(), file = f }).GroupBy(f => f.lang).ToDictionary(g => g.Key, g => g.Select(f => f.file).ToList()); var languages = trainFilesPerLanguage.Keys.ToList(); Logger.LogInformation($"Found these languages for training: {string.Join(", ", languages)}"); int N_training = 5; Parallel.ForEach(languages, lang => { Language language; try { language = Languages.CodeToEnum(lang); } catch { Logger.LogWarning($"Unknown language {lang}"); return; } var arcNames = new HashSet <string>(); if (trainFilesPerLanguage.TryGetValue(lang, out var langTrainFiles) && testFilesPerLanguage.TryGetValue(lang, out var langTestFiles)) { var trainDocuments = ReadCorpus(langTrainFiles, arcNames, language); var testDocuments = ReadCorpus(langTestFiles, arcNames, language); if (language == Language.English) { //Merge with Ontonotes 5.0 corpus trainDocuments.AddRange(ReadCorpus(trainFilesOntonotesEnglish, arcNames, language, isOntoNotes: true)); } double bestScore = double.MinValue; for (int i = 0; i < N_training; i++) { var Tagger = new AveragePerceptronTagger(language, 0); Tagger.Train(trainDocuments.AsEnumerable(), (int)(5 + ThreadSafeRandom.Next(15))); var scoreTrain = TestTagger(trainDocuments, Tagger); var scoreTest = TestTagger(testDocuments, Tagger); if (scoreTest > bestScore) { Logger.LogInformation($"\n>>>>> {lang}: NEW POS BEST: {scoreTest:0.0}%"); try { Tagger.StoreAsync().Wait(); } catch (Exception E) { Logger.LogError(E, $"\n>>>>> {lang}: Failed to store model"); } bestScore = scoreTest; } else { Logger.LogInformation($"\n>>>>> {lang}: POS BEST IS STILL : {bestScore:0.0}%"); } } bestScore = double.MinValue; for (int i = 0; i < N_training; i++) { var Parser = new AveragePerceptronDependencyParser(language, 0 /*, arcNames.ToList()*/); try { Parser.Train(trainDocuments.AsEnumerable(), (int)(5 + ThreadSafeRandom.Next(10)), (float)(1D - ThreadSafeRandom.NextDouble() * ThreadSafeRandom.NextDouble())); } catch (Exception E) { Logger.LogInformation("FAIL: " + E.Message); continue; } trainDocuments = ReadCorpus(langTrainFiles, arcNames, language); testDocuments = ReadCorpus(langTestFiles, arcNames, language); if (language == Language.English) { //Merge with Ontonotes 5.0 corpus trainDocuments.AddRange(ReadCorpus(trainFilesOntonotesEnglish, arcNames, language, isOntoNotes: true)); } var scoreTrain = TestParser(trainDocuments, Parser); var scoreTest = TestParser(testDocuments, Parser); if (scoreTest > bestScore) { Logger.LogInformation($"\n>>>>> {lang}: NEW DEP BEST: {scoreTest:0.0}%"); try { Parser.StoreAsync().Wait(); } catch (Exception E) { Logger.LogError(E, $"\n>>>>> {lang}: Failed to store model"); } bestScore = scoreTest; } else { Logger.LogInformation($"\n>>>>> {lang}: DEP BEST IS STILL : {bestScore:0.0}%"); } Parser = null; } } }); foreach (var lang in languages) { Language language; try { language = Languages.CodeToEnum(lang); } catch { Logger.LogInformation($"Unknown language {lang}"); return; } var arcNames = new HashSet <string>(); var trainDocuments = ReadCorpus(trainFilesPerLanguage[lang], arcNames, language); var testDocuments = ReadCorpus(testFilesPerLanguage[lang], arcNames, language); if (language == Language.English) { //Merge with Ontonotes 5.0 corpus var ontonotesDocuments = ReadCorpus(trainFilesOntonotesEnglish, arcNames, language, isOntoNotes: true); trainDocuments.AddRange(ontonotesDocuments); } var Tagger = AveragePerceptronTagger.FromStoreAsync(language, 0, "").WaitResult(); Logger.LogInformation($"\n{lang} - TAGGER / TRAIN"); TestTagger(trainDocuments, Tagger); Logger.LogInformation($"\n{lang} - TAGGER / TEST"); TestTagger(testDocuments, Tagger); trainDocuments = ReadCorpus(trainFilesPerLanguage[lang], arcNames, language); testDocuments = ReadCorpus(testFilesPerLanguage[lang], arcNames, language); var Parser = AveragePerceptronDependencyParser.FromStoreAsync(language, 0, "").WaitResult(); Logger.LogInformation($"\n{lang} - PARSER / TRAIN"); TestParser(trainDocuments, Parser); Logger.LogInformation($"\n{lang} - PARSER / TEST"); TestParser(testDocuments, Parser); } }
// The percentages for variances need to be fixed /// <summary> /// Gets Melee Weapon Variance /// </summary> /// <param name="category"></param><param name="type"></param> /// <returns>Returns Melee Weapon Variance</returns> private static double GetVariance(Skill category, LootWeaponType type) { double variance = 0; int chance = ThreadSafeRandom.Next(0, 99); switch (category) { case Skill.HeavyWeapons: switch (type) { case LootWeaponType.Axe: if (chance < 10) { variance = .90; } else if (chance < 30) { variance = .93; } else if (chance < 70) { variance = .95; } else if (chance < 90) { variance = .97; } else { variance = .99; } break; case LootWeaponType.Dagger: if (chance < 10) { variance = .47; } else if (chance < 30) { variance = .50; } else if (chance < 70) { variance = .53; } else if (chance < 90) { variance = .57; } else { variance = .62; } break; case LootWeaponType.DaggerMulti: if (chance < 10) { variance = .40; } else if (chance < 30) { variance = .43; } else if (chance < 70) { variance = .48; } else if (chance < 90) { variance = .53; } else { variance = .58; } break; case LootWeaponType.Mace: if (chance < 10) { variance = .30; } else if (chance < 30) { variance = .33; } else if (chance < 70) { variance = .37; } else if (chance < 90) { variance = .42; } else { variance = .46; } break; case LootWeaponType.Spear: if (chance < 10) { variance = .59; } else if (chance < 30) { variance = .63; } else if (chance < 70) { variance = .68; } else if (chance < 90) { variance = .72; } else { variance = .75; } break; case LootWeaponType.Staff: if (chance < 10) { variance = .38; } else if (chance < 30) { variance = .42; } else if (chance < 70) { variance = .45; } else if (chance < 90) { variance = .50; } else { variance = .52; } break; case LootWeaponType.Sword: if (chance < 10) { variance = .47; } else if (chance < 30) { variance = .50; } else if (chance < 70) { variance = .53; } else if (chance < 90) { variance = .57; } else { variance = .62; } break; case LootWeaponType.SwordMulti: if (chance < 10) { variance = .40; } else if (chance < 30) { variance = .43; } else if (chance < 70) { variance = .48; } else if (chance < 90) { variance = .53; } else { variance = .60; } break; case LootWeaponType.UA: if (chance < 10) { variance = .44; } else if (chance < 30) { variance = .48; } else if (chance < 70) { variance = .53; } else if (chance < 90) { variance = .58; } else { variance = .60; } break; } break; case Skill.LightWeapons: case Skill.FinesseWeapons: switch (type) { case LootWeaponType.Axe: // Axe if (chance < 10) { variance = .80; } else if (chance < 30) { variance = .83; } else if (chance < 70) { variance = .85; } else if (chance < 90) { variance = .90; } else { variance = .95; } break; case LootWeaponType.Dagger: // Dagger if (chance < 10) { variance = .42; } else if (chance < 30) { variance = .47; } else if (chance < 70) { variance = .52; } else if (chance < 90) { variance = .56; } else { variance = .60; } break; case LootWeaponType.DaggerMulti: // Dagger MultiStrike if (chance < 10) { variance = .24; } else if (chance < 30) { variance = .28; } else if (chance < 70) { variance = .35; } else if (chance < 90) { variance = .40; } else { variance = .45; } break; case LootWeaponType.Mace: // Mace if (chance < 10) { variance = .23; } else if (chance < 30) { variance = .28; } else if (chance < 70) { variance = .32; } else if (chance < 90) { variance = .37; } else { variance = .43; } break; case LootWeaponType.Jitte: // Jitte if (chance < 10) { variance = .325; } else if (chance < 30) { variance = .35; } else if (chance < 70) { variance = .40; } else if (chance < 90) { variance = .45; } else { variance = .50; } break; case LootWeaponType.Spear: // Spear if (chance < 10) { variance = .65; } else if (chance < 30) { variance = .68; } else if (chance < 70) { variance = .71; } else if (chance < 90) { variance = .75; } else { variance = .80; } break; case LootWeaponType.Staff: // Staff if (chance < 10) { variance = .325; } else if (chance < 30) { variance = .35; } else if (chance < 70) { variance = .40; } else if (chance < 90) { variance = .45; } else { variance = .50; } break; case LootWeaponType.Sword: // Sword if (chance < 10) { variance = .42; } else if (chance < 30) { variance = .47; } else if (chance < 70) { variance = .52; } else if (chance < 90) { variance = .56; } else { variance = .60; } break; case LootWeaponType.SwordMulti: // Sword Multistrike if (chance < 10) { variance = .24; } else if (chance < 30) { variance = .28; } else if (chance < 70) { variance = .35; } else if (chance < 90) { variance = .40; } else { variance = .45; } break; case LootWeaponType.UA: // UA if (chance < 10) { variance = .44; } else if (chance < 30) { variance = .48; } else if (chance < 70) { variance = .53; } else if (chance < 90) { variance = .58; } else { variance = .60; } break; } break; case Skill.TwoHandedCombat: // Two Handed only have one set of variances if (chance < 5) { variance = .30; } else if (chance < 20) { variance = .35; } else if (chance < 50) { variance = .40; } else if (chance < 80) { variance = .45; } else if (chance < 95) { variance = .50; } else { variance = .55; } break; default: return(0); } return(variance); }
/// <summary> /// Calculates the damage for a spell projectile /// Used by war magic, void magic, and life magic projectiles /// </summary> public float?CalculateDamage(WorldObject source, WorldObject caster, Creature target, ref bool criticalHit, ref bool critDefended, ref bool overpower) { var sourcePlayer = source as Player; var targetPlayer = target as Player; if (source == null || !target.IsAlive || targetPlayer != null && targetPlayer.Invincible) { return(null); } // check lifestone protection if (targetPlayer != null && targetPlayer.UnderLifestoneProtection) { if (sourcePlayer != null) { sourcePlayer.Session.Network.EnqueueSend(new GameMessageSystemChat($"The Lifestone's magic protects {targetPlayer.Name} from the attack!", ChatMessageType.Magic)); } targetPlayer.HandleLifestoneProtection(); return(null); } var critDamageBonus = 0.0f; var weaponCritDamageMod = 1.0f; var weaponResistanceMod = 1.0f; var resistanceMod = 1.0f; // life magic var lifeMagicDamage = 0.0f; // war/void magic var baseDamage = 0; var skillBonus = 0.0f; var finalDamage = 0.0f; var resistanceType = Creature.GetResistanceType(Spell.DamageType); var sourceCreature = source as Creature; if (sourceCreature?.Overpower != null) { overpower = Creature.GetOverpower(sourceCreature, target); } var resisted = source.TryResistSpell(target, Spell, caster, true); if (resisted && !overpower) { return(null); } CreatureSkill attackSkill = null; if (sourceCreature != null) { attackSkill = sourceCreature.GetCreatureSkill(Spell.School); } // critical hit var criticalChance = GetWeaponMagicCritFrequency(sourceCreature, attackSkill, target); if (ThreadSafeRandom.Next(0.0f, 1.0f) < criticalChance) { if (targetPlayer != null && targetPlayer.AugmentationCriticalDefense > 0) { var criticalDefenseMod = sourcePlayer != null ? 0.05f : 0.25f; var criticalDefenseChance = targetPlayer.AugmentationCriticalDefense * criticalDefenseMod; if (criticalDefenseChance > ThreadSafeRandom.Next(0.0f, 1.0f)) { critDefended = true; } } if (!critDefended) { criticalHit = true; } } var absorbMod = GetAbsorbMod(target); bool isPVP = sourcePlayer != null && targetPlayer != null; if (isPVP && Spell.IsHarmful) { Player.UpdatePKTimers(sourcePlayer, targetPlayer); } var elementalDamageMod = GetCasterElementalDamageModifier(sourceCreature, target, Spell.DamageType); // Possible 2x + damage bonus for the slayer property var slayerMod = GetWeaponCreatureSlayerModifier(sourceCreature, target); // life magic projectiles: ie., martyr's hecatomb if (Spell.MetaSpellType == ACE.Entity.Enum.SpellType.LifeProjectile) { lifeMagicDamage = LifeProjectileDamage * Spell.DamageRatio; // could life magic projectiles crit? // if so, did they use the same 1.5x formula as war magic, instead of 2.0x? if (criticalHit) { weaponCritDamageMod = GetWeaponCritDamageMod(sourceCreature, attackSkill, target); critDamageBonus = lifeMagicDamage * 0.5f * weaponCritDamageMod; } weaponResistanceMod = GetWeaponResistanceModifier(sourceCreature, attackSkill, Spell.DamageType); // if attacker/weapon has IgnoreMagicResist directly, do not transfer to spell projectile // only pass if SpellProjectile has it directly, such as 2637 - Invoking Aun Tanua resistanceMod = (float)Math.Max(0.0f, target.GetResistanceMod(resistanceType, this, null, weaponResistanceMod)); finalDamage = (lifeMagicDamage + critDamageBonus) * elementalDamageMod * slayerMod * resistanceMod * absorbMod; } // war/void magic projectiles else { if (criticalHit) { // Original: // http://acpedia.org/wiki/Announcements_-_2002/08_-_Atonement#Letter_to_the_Players // Critical Strikes: In addition to the skill-based damage bonus, each projectile spell has a 2% chance of causing a critical hit on the target and doing increased damage. // A magical critical hit is similar in some respects to melee critical hits (although the damage calculation is handled differently). // While a melee critical hit automatically does twice the maximum damage of the weapon, a magical critical hit will do an additional half the minimum damage of the spell. // For instance, a magical critical hit from a level 7 spell, which does 110-180 points of damage, would add an additional 55 points of damage to the spell. // Later updated for PvE only: // http://acpedia.org/wiki/Announcements_-_2004/07_-_Treaties_in_Stone#Letter_to_the_Players // Currently when a War Magic spell scores a critical hit, it adds a multiple of the base damage of the spell to a normal damage roll. // Starting in July, War Magic critical hits will instead add a multiple of the maximum damage of the spell. // No more crits that do less damage than non-crits! if (isPVP) // PvP: 50% of the MIN damage added to normal damage roll { critDamageBonus = Spell.MinDamage * 0.5f; } else // PvE: 50% of the MAX damage added to normal damage roll { critDamageBonus = Spell.MaxDamage * 0.5f; } weaponCritDamageMod = GetWeaponCritDamageMod(sourceCreature, attackSkill, target); critDamageBonus *= weaponCritDamageMod; } /* War Magic skill-based damage bonus * http://acpedia.org/wiki/Announcements_-_2002/08_-_Atonement#Letter_to_the_Players */ if (sourcePlayer != null) { // per retail stats, level 8 difficulty is capped to 350 instead of 400 // without this, level 7s have the potential to deal more damage than level 8s var difficulty = Math.Min(Spell.Power, 350); // was skillMod possibility capped to 1.3x for level 7 spells in retail, instead of level 8 difficulty cap? var magicSkill = sourcePlayer.GetCreatureSkill(Spell.School).Current; if (magicSkill > difficulty) { // Bonus clamped to a maximum of 50% //var percentageBonus = Math.Clamp((magicSkill - Spell.Power) / 100.0f, 0.0f, 0.5f); var percentageBonus = (magicSkill - difficulty) / 1000.0f; skillBonus = Spell.MinDamage * percentageBonus; } } baseDamage = ThreadSafeRandom.Next(Spell.MinDamage, Spell.MaxDamage); weaponResistanceMod = GetWeaponResistanceModifier(sourceCreature, attackSkill, Spell.DamageType); // if attacker/weapon has IgnoreMagicResist directly, do not transfer to spell projectile // only pass if SpellProjectile has it directly, such as 2637 - Invoking Aun Tanua resistanceMod = (float)Math.Max(0.0f, target.GetResistanceMod(resistanceType, this, null, weaponResistanceMod)); if (sourcePlayer != null && targetPlayer != null && Spell.DamageType == DamageType.Nether) { // for direct damage from void spells in pvp, // apply void_pvp_modifier *on top of* the player's natural resistance to nether // this supposedly brings the direct damage from void spells in pvp closer to retail resistanceMod *= (float)PropertyManager.GetDouble("void_pvp_modifier").Item; } finalDamage = baseDamage + critDamageBonus + skillBonus; finalDamage *= elementalDamageMod * slayerMod * resistanceMod * absorbMod; } // show debug info if (sourceCreature != null && sourceCreature.DebugDamage.HasFlag(Creature.DebugDamageType.Attacker)) { ShowInfo(sourceCreature, Spell, attackSkill, criticalChance, criticalHit, critDefended, overpower, weaponCritDamageMod, skillBonus, baseDamage, critDamageBonus, elementalDamageMod, slayerMod, weaponResistanceMod, resistanceMod, absorbMod, LifeProjectileDamage, lifeMagicDamage, finalDamage); } if (target.DebugDamage.HasFlag(Creature.DebugDamageType.Defender)) { ShowInfo(target, Spell, attackSkill, criticalChance, criticalHit, critDefended, overpower, weaponCritDamageMod, skillBonus, baseDamage, critDamageBonus, elementalDamageMod, slayerMod, weaponResistanceMod, resistanceMod, absorbMod, LifeProjectileDamage, lifeMagicDamage, finalDamage); } return(finalDamage); }
private static void MutateMeleeWeapon(WorldObject wo, TreasureDeath profile, bool isMagical, int weaponType, int subtype) { Skill wieldSkillType = Skill.None; int damage = 0; double damageVariance = 0; double weaponDefense = 0; double weaponOffense = 0; // Properties for weapons double magicD = GetMagicMissileDMod(profile.Tier); double missileD = GetMagicMissileDMod(profile.Tier); int gemCount = ThreadSafeRandom.Next(1, 5); int gemType = ThreadSafeRandom.Next(10, 50); int workmanship = GetWorkmanship(profile.Tier); int wieldDiff = GetWieldDifficulty(profile.Tier, WieldType.MeleeWeapon); WieldRequirement wieldRequirments = WieldRequirement.RawSkill; // Weapon Types // 0 = Heavy // 1 = Light // 2 = Finesse // default = Two Handed switch (weaponType) { case 0: // Heavy Weapons wieldSkillType = Skill.HeavyWeapons; switch (subtype) { case 0: case 1: case 2: weaponDefense = GetMaxDamageMod(profile.Tier, 18); weaponOffense = GetMaxDamageMod(profile.Tier, 22); damage = GetMeleeMaxDamage(wieldSkillType, wieldDiff, LootWeaponType.Axe); damageVariance = GetVariance(wieldSkillType, LootWeaponType.Axe); break; case 3: case 4: case 5: weaponDefense = GetMaxDamageMod(profile.Tier, 20); weaponOffense = GetMaxDamageMod(profile.Tier, 20); damage = GetMeleeMaxDamage(wieldSkillType, wieldDiff, LootWeaponType.Dagger); if (subtype == 3) { damageVariance = GetVariance(wieldSkillType, LootWeaponType.Dagger); } if (subtype == 4 || subtype == 5) { damage = GetMeleeMaxDamage(wieldSkillType, wieldDiff, LootWeaponType.DaggerMulti); damageVariance = GetVariance(wieldSkillType, LootWeaponType.DaggerMulti); } break; case 6: case 7: case 8: case 9: weaponDefense = GetMaxDamageMod(profile.Tier, 22); weaponOffense = GetMaxDamageMod(profile.Tier, 18); damage = GetMeleeMaxDamage(wieldSkillType, wieldDiff, LootWeaponType.Mace); damageVariance = GetVariance(wieldSkillType, LootWeaponType.Mace); break; case 10: case 11: case 12: weaponDefense = GetMaxDamageMod(profile.Tier, 15); weaponOffense = GetMaxDamageMod(profile.Tier, 25); damage = GetMeleeMaxDamage(wieldSkillType, wieldDiff, LootWeaponType.Spear); damageVariance = GetVariance(wieldSkillType, LootWeaponType.Spear); break; case 13: case 14: weaponDefense = GetMaxDamageMod(profile.Tier, 25); weaponOffense = GetMaxDamageMod(profile.Tier, 15); damage = GetMeleeMaxDamage(wieldSkillType, wieldDiff, LootWeaponType.Staff); damageVariance = GetVariance(wieldSkillType, LootWeaponType.Staff); break; case 15: case 16: case 17: case 18: case 19: case 20: weaponDefense = GetMaxDamageMod(profile.Tier, 20); weaponOffense = GetMaxDamageMod(profile.Tier, 20); damage = GetMeleeMaxDamage(wieldSkillType, wieldDiff, LootWeaponType.Sword); damageVariance = GetVariance(wieldSkillType, LootWeaponType.Sword); if (subtype == 20) { damage = GetMeleeMaxDamage(wieldSkillType, wieldDiff, LootWeaponType.SwordMulti); damageVariance = GetVariance(wieldSkillType, LootWeaponType.SwordMulti); } break; case 21: default: weaponDefense = GetMaxDamageMod(profile.Tier, 20); weaponOffense = GetMaxDamageMod(profile.Tier, 20); damage = GetMeleeMaxDamage(wieldSkillType, wieldDiff, LootWeaponType.UA); damageVariance = GetVariance(wieldSkillType, LootWeaponType.UA); break; } break; case 1: // Light Weapons; wieldSkillType = Skill.LightWeapons; switch (subtype) { case 0: case 1: case 2: case 3: weaponDefense = GetMaxDamageMod(profile.Tier, 18); weaponOffense = GetMaxDamageMod(profile.Tier, 22); damage = GetMeleeMaxDamage(wieldSkillType, wieldDiff, LootWeaponType.Axe); damageVariance = GetVariance(wieldSkillType, LootWeaponType.Axe); break; case 4: case 5: weaponDefense = GetMaxDamageMod(profile.Tier, 20); weaponOffense = GetMaxDamageMod(profile.Tier, 20); damage = GetMeleeMaxDamage(wieldSkillType, wieldDiff, LootWeaponType.DaggerMulti); damageVariance = GetVariance(wieldSkillType, LootWeaponType.DaggerMulti); break; case 6: case 7: case 8: weaponDefense = GetMaxDamageMod(profile.Tier, 22); weaponOffense = GetMaxDamageMod(profile.Tier, 18); damage = GetMeleeMaxDamage(wieldSkillType, wieldDiff, LootWeaponType.Mace); damageVariance = GetVariance(wieldSkillType, LootWeaponType.Mace); break; case 9: case 10: weaponDefense = GetMaxDamageMod(profile.Tier, 15); weaponOffense = GetMaxDamageMod(profile.Tier, 25); damage = GetMeleeMaxDamage(wieldSkillType, wieldDiff, LootWeaponType.Spear); damageVariance = GetVariance(wieldSkillType, LootWeaponType.Spear); break; case 11: weaponDefense = GetMaxDamageMod(profile.Tier, 25); weaponOffense = GetMaxDamageMod(profile.Tier, 15); damage = GetMeleeMaxDamage(wieldSkillType, wieldDiff, LootWeaponType.Staff); damageVariance = GetVariance(wieldSkillType, LootWeaponType.Staff); break; case 12: case 13: case 14: case 15: case 16: case 17: weaponDefense = GetMaxDamageMod(profile.Tier, 20); weaponOffense = GetMaxDamageMod(profile.Tier, 20); damage = GetMeleeMaxDamage(wieldSkillType, wieldDiff, LootWeaponType.Sword); damageVariance = GetVariance(wieldSkillType, LootWeaponType.Sword); if (subtype == 14) { damage = GetMeleeMaxDamage(wieldSkillType, wieldDiff, LootWeaponType.SwordMulti); damageVariance = GetVariance(wieldSkillType, LootWeaponType.SwordMulti); } break; case 18: default: weaponDefense = GetMaxDamageMod(profile.Tier, 20); weaponOffense = GetMaxDamageMod(profile.Tier, 20); damage = GetMeleeMaxDamage(wieldSkillType, wieldDiff, LootWeaponType.UA); damageVariance = GetVariance(wieldSkillType, LootWeaponType.UA); break; } break; case 2: // Finesse Weapons; wieldSkillType = Skill.FinesseWeapons; switch (subtype) { case 0: case 1: case 2: weaponDefense = GetMaxDamageMod(profile.Tier, 18); weaponOffense = GetMaxDamageMod(profile.Tier, 22); damage = GetMeleeMaxDamage(wieldSkillType, wieldDiff, LootWeaponType.Axe); damageVariance = GetVariance(wieldSkillType, LootWeaponType.Axe); break; case 3: case 4: case 5: weaponDefense = GetMaxDamageMod(profile.Tier, 20); weaponOffense = GetMaxDamageMod(profile.Tier, 20); damage = GetMeleeMaxDamage(wieldSkillType, wieldDiff, LootWeaponType.Dagger); damageVariance = GetVariance(wieldSkillType, LootWeaponType.Dagger); if (subtype == 3 || subtype == 4) { damageVariance = GetVariance(wieldSkillType, LootWeaponType.DaggerMulti); damage = GetMeleeMaxDamage(wieldSkillType, wieldDiff, LootWeaponType.DaggerMulti); } break; case 6: case 7: case 8: case 9: case 10: weaponDefense = GetMaxDamageMod(profile.Tier, 22); weaponOffense = GetMaxDamageMod(profile.Tier, 18); damage = GetMeleeMaxDamage(wieldSkillType, wieldDiff, LootWeaponType.Mace); damageVariance = GetVariance(wieldSkillType, LootWeaponType.Mace); if (subtype == 9) { damageVariance = GetVariance(wieldSkillType, LootWeaponType.Jitte); } break; case 11: case 12: weaponDefense = GetMaxDamageMod(profile.Tier, 15); weaponOffense = GetMaxDamageMod(profile.Tier, 25); damage = GetMeleeMaxDamage(wieldSkillType, wieldDiff, LootWeaponType.Spear); damageVariance = GetVariance(wieldSkillType, LootWeaponType.Spear); break; case 13: case 14: weaponDefense = GetMaxDamageMod(profile.Tier, 25); weaponOffense = GetMaxDamageMod(profile.Tier, 15); damage = GetMeleeMaxDamage(wieldSkillType, wieldDiff, LootWeaponType.Staff); damageVariance = GetVariance(wieldSkillType, LootWeaponType.Staff); break; case 15: case 16: case 17: case 18: case 19: case 20: weaponDefense = GetMaxDamageMod(profile.Tier, 20); weaponOffense = GetMaxDamageMod(profile.Tier, 20); damage = GetMeleeMaxDamage(wieldSkillType, wieldDiff, LootWeaponType.Sword); damageVariance = GetVariance(wieldSkillType, LootWeaponType.Sword); if (subtype == 15) { damage = GetMeleeMaxDamage(wieldSkillType, wieldDiff, LootWeaponType.SwordMulti); damageVariance = GetVariance(wieldSkillType, LootWeaponType.SwordMulti); } break; case 21: default: weaponDefense = GetMaxDamageMod(profile.Tier, 20); weaponOffense = GetMaxDamageMod(profile.Tier, 20); damage = GetMeleeMaxDamage(wieldSkillType, wieldDiff, LootWeaponType.UA); damageVariance = GetVariance(wieldSkillType, LootWeaponType.UA); break; } break; default: // Two handed wieldSkillType = Skill.TwoHandedCombat; damage = GetMeleeMaxDamage(wieldSkillType, wieldDiff, LootWeaponType.Cleaving); damageVariance = GetVariance(wieldSkillType, LootWeaponType.TwoHanded); switch (subtype) { case 0: case 1: case 2: weaponDefense = GetMaxDamageMod(profile.Tier, 20); weaponOffense = GetMaxDamageMod(profile.Tier, 20); break; case 3: case 4: case 5: case 6: weaponDefense = GetMaxDamageMod(profile.Tier, 22); weaponOffense = GetMaxDamageMod(profile.Tier, 18); break; case 7: weaponDefense = GetMaxDamageMod(profile.Tier, 18); weaponOffense = GetMaxDamageMod(profile.Tier, 22); break; case 8: case 9: case 10: default: weaponDefense = GetMaxDamageMod(profile.Tier, 15); weaponOffense = GetMaxDamageMod(profile.Tier, 25); damage = GetMeleeMaxDamage(wieldSkillType, wieldDiff, LootWeaponType.Spears); break; } break; } // Description wo.AppraisalLongDescDecoration = AppraisalLongDescDecorations.PrependWorkmanship | AppraisalLongDescDecorations.AppendGemInfo; wo.LongDesc = wo.Name; // GemTypes, Material, Workmanship wo.GemCount = gemCount; wo.GemType = (MaterialType)gemType; int materialType = GetMaterialType(wo, profile.Tier); if (materialType > 0) { wo.MaterialType = (MaterialType)materialType; } wo.ItemWorkmanship = workmanship; // Burden MutateBurden(wo, profile.Tier, true); // Weapon Stats wo.Damage = damage; wo.DamageVariance = damageVariance; wo.WeaponDefense = weaponDefense; wo.WeaponOffense = weaponOffense; wo.WeaponMissileDefense = missileD; wo.WeaponMagicDefense = magicD; // Adding Wield Reqs if required if (wieldDiff > 0) { wo.WieldDifficulty = wieldDiff; wo.WieldRequirements = wieldRequirments; wo.WieldSkillType = (int)wieldSkillType; } else { // If no wield, remove wield reqs wo.WieldDifficulty = null; wo.WieldRequirements = WieldRequirement.Invalid; wo.WieldSkillType = null; } // Adding Magic Spells if (isMagical) { wo = AssignMagic(wo, profile); } else { // If no spells remove magic properites wo.ItemManaCost = null; wo.ItemMaxMana = null; wo.ItemCurMana = null; wo.ItemSpellcraft = null; wo.ItemDifficulty = null; } double materialMod = LootTables.getMaterialValueModifier(wo); double gemMaterialMod = LootTables.getGemMaterialValueModifier(wo); var value = GetValue(profile.Tier, workmanship, gemMaterialMod, materialMod); wo.Value = value; RandomizeColor(wo); }
private static bool CanRandomize(ExportEntry export) => !export.IsDefaultObject && export.ClassName == @"InterpTrackMove" && ThreadSafeRandom.Next(1) == 0;
public async Task StartAsync(CancellationToken cancellationToken) { if (!gatewayListProviderInitialized) { await this.gatewayListProvider.InitializeGatewayListProvider(); gatewayListProviderInitialized = true; } this.gatewayRefreshTimer = new AsyncTaskSafeTimer( this.timerLogger, RefreshSnapshotLiveGateways_TimerCallback, null, this.gatewayOptions.GatewayListRefreshPeriod, this.gatewayOptions.GatewayListRefreshPeriod); var knownGateways = await this.gatewayListProvider.GetGateways(); if (knownGateways.Count == 0) { var err = $"Could not find any gateway in {this.gatewayListProvider.GetType().FullName}. Orleans client cannot initialize."; this.logger.LogError((int)ErrorCode.GatewayManager_NoGateways, err); throw new SiloUnavailableException(err); } this.logger.LogInformation( (int)ErrorCode.GatewayManager_FoundKnownGateways, "Found {GatewayCount} gateways: {Gateways}", knownGateways.Count, Utils.EnumerableToString(knownGateways)); this.roundRobinCounter = this.gatewayOptions.PreferedGatewayIndex >= 0 ? this.gatewayOptions.PreferedGatewayIndex : ThreadSafeRandom.Next(knownGateways.Count); this.knownGateways = this.cachedLiveGateways = knownGateways.Select(gw => gw.ToGatewayAddress()).ToList(); this.cachedLiveGatewaysSet = new HashSet <SiloAddress>(cachedLiveGateways); this.lastRefreshTime = DateTime.UtcNow; }
/// <summary> /// Set seed of the random numbers generator. /// </summary> /// /// <param name="seed">Seed value.</param> /// /// <remarks>Resets random numbers generator initializing it with /// specified seed value.</remarks> /// public void SetSeed( int seed ) { rand = new ThreadSafeRandom( seed ); }
private static WorldObject CreateArmor(int tier, bool isMagical, LootBias lootBias = LootBias.UnBiased) { int lowSpellTier = 0; int highSpellTier = 0; int equipSetId = 0; int materialType = 0; int armorPiece = 0; int armorType = 0; int armorWeenie = 0; switch (tier) { case 1: lowSpellTier = 1; highSpellTier = 3; armorType = ThreadSafeRandom.Next((int)LootTables.ArmorType.MiscClothing, (int)LootTables.ArmorType.ChainmailArmor); break; case 2: lowSpellTier = 3; highSpellTier = 5; armorType = ThreadSafeRandom.Next((int)LootTables.ArmorType.MiscClothing, (int)LootTables.ArmorType.DiforsaArmor); break; case 3: lowSpellTier = 4; highSpellTier = 6; armorType = ThreadSafeRandom.Next((int)LootTables.ArmorType.MiscClothing, (int)LootTables.ArmorType.CovenantArmor); break; case 4: lowSpellTier = 5; highSpellTier = 6; armorType = ThreadSafeRandom.Next((int)LootTables.ArmorType.MiscClothing, (int)LootTables.ArmorType.CovenantArmor); break; case 5: lowSpellTier = 5; highSpellTier = 7; armorType = ThreadSafeRandom.Next((int)LootTables.ArmorType.MiscClothing, (int)LootTables.ArmorType.AlduressaArmor); break; case 6: lowSpellTier = 6; highSpellTier = 7; armorType = ThreadSafeRandom.Next((int)LootTables.ArmorType.MiscClothing, (int)LootTables.ArmorType.HaebreanArmor); break; case 7: lowSpellTier = 6; highSpellTier = 8; armorType = ThreadSafeRandom.Next((int)LootTables.ArmorType.MiscClothing, (int)LootTables.ArmorType.OlthoiAlduressaArmor); break; default: lowSpellTier = 7; highSpellTier = 8; if (lootBias == LootBias.Armor) // Armor Mana Forge Chests don't include clothing type items { armorType = ThreadSafeRandom.Next((int)LootTables.ArmorType.Helms, (int)LootTables.ArmorType.OlthoiAlduressaArmor); } else { armorType = ThreadSafeRandom.Next((int)LootTables.ArmorType.MiscClothing, (int)LootTables.ArmorType.OlthoiAlduressaArmor); } break; } switch (armorType) { case (int)LootTables.ArmorType.MiscClothing: armorPiece = ThreadSafeRandom.Next(0, 47); armorWeenie = LootTables.MiscClothing[armorPiece]; break; case (int)LootTables.ArmorType.Helms: armorPiece = ThreadSafeRandom.Next(0, 8); armorWeenie = LootTables.Helms[armorPiece]; break; case (int)LootTables.ArmorType.Shields: armorPiece = ThreadSafeRandom.Next(0, 4); armorWeenie = LootTables.Shields[armorPiece]; break; case (int)LootTables.ArmorType.LeatherArmor: armorPiece = ThreadSafeRandom.Next(0, 15); armorWeenie = LootTables.LeatherArmor[armorPiece]; break; case (int)LootTables.ArmorType.StuddedLeatherArmor: armorPiece = ThreadSafeRandom.Next(0, 14); armorWeenie = LootTables.StuddedLeatherArmor[armorPiece]; break; case (int)LootTables.ArmorType.ChainmailArmor: armorPiece = ThreadSafeRandom.Next(0, 12); armorWeenie = LootTables.ChainmailArmor[armorPiece]; break; case (int)LootTables.ArmorType.PlatemailArmor: armorPiece = ThreadSafeRandom.Next(0, 10); armorWeenie = LootTables.PlatemailArmor[armorPiece]; break; case (int)LootTables.ArmorType.ScalemailArmor: armorPiece = ThreadSafeRandom.Next(0, 13); armorWeenie = LootTables.ScalemailArmor[armorPiece]; break; case (int)LootTables.ArmorType.YoroiArmor: armorPiece = ThreadSafeRandom.Next(0, 7); armorWeenie = LootTables.YoroiArmor[armorPiece]; break; case (int)LootTables.ArmorType.DiforsaArmor: armorPiece = ThreadSafeRandom.Next(0, 12); armorWeenie = LootTables.DiforsaArmor[armorPiece]; break; case (int)LootTables.ArmorType.CeldonArmor: armorPiece = ThreadSafeRandom.Next(0, 3); armorWeenie = LootTables.CeldonArmor[armorPiece]; break; case (int)LootTables.ArmorType.AmuliArmor: armorPiece = ThreadSafeRandom.Next(0, 1); armorWeenie = LootTables.AmuliArmor[armorPiece]; break; case (int)LootTables.ArmorType.KoujiaArmor: armorPiece = ThreadSafeRandom.Next(0, 2); armorWeenie = LootTables.KoujiaArmor[armorPiece]; break; case (int)LootTables.ArmorType.TenassaArmor: armorPiece = ThreadSafeRandom.Next(0, 2); armorWeenie = LootTables.TenassaArmor[armorPiece]; break; case (int)LootTables.ArmorType.CovenantArmor: armorPiece = ThreadSafeRandom.Next(0, 9); armorWeenie = LootTables.CovenantArmor[armorPiece]; break; case (int)LootTables.ArmorType.LoricaArmor: armorPiece = ThreadSafeRandom.Next(0, 5); armorWeenie = LootTables.LoricaArmor[armorPiece]; break; case (int)LootTables.ArmorType.NariyidArmor: armorPiece = ThreadSafeRandom.Next(0, 6); armorWeenie = LootTables.NariyidArmor[armorPiece]; break; case (int)LootTables.ArmorType.ChiranArmor: armorPiece = ThreadSafeRandom.Next(0, 4); armorWeenie = LootTables.ChiranArmor[armorPiece]; break; case (int)LootTables.ArmorType.AlduressaArmor: armorPiece = ThreadSafeRandom.Next(0, 4); armorWeenie = LootTables.AlduressaArmor[armorPiece]; break; case (int)LootTables.ArmorType.KnorrAcademyArmor: armorPiece = ThreadSafeRandom.Next(0, 7); armorWeenie = LootTables.KnorrAcademyArmor[armorPiece]; break; case (int)LootTables.ArmorType.SedgemailLeatherArmor: armorPiece = ThreadSafeRandom.Next(0, 5); armorWeenie = LootTables.SedgemailLeatherArmor[armorPiece]; break; case (int)LootTables.ArmorType.HaebreanArmor: armorPiece = ThreadSafeRandom.Next(0, 8); armorWeenie = LootTables.HaebreanArmor[armorPiece]; break; case (int)LootTables.ArmorType.OlthoiArmor: armorPiece = ThreadSafeRandom.Next(0, 9); armorWeenie = LootTables.OlthoiArmor[armorPiece]; break; case (int)LootTables.ArmorType.OlthoiAmuliArmor: armorPiece = ThreadSafeRandom.Next(0, 4); armorWeenie = LootTables.OlthoiAmuliArmor[armorPiece]; break; case (int)LootTables.ArmorType.OlthoiCeldonArmor: armorPiece = ThreadSafeRandom.Next(0, 6); armorWeenie = LootTables.OlthoiCeldonArmor[armorPiece]; break; case (int)LootTables.ArmorType.OlthoiKoujiaArmor: armorPiece = ThreadSafeRandom.Next(0, 4); armorWeenie = LootTables.OlthoiKoujiaArmor[armorPiece]; break; default: // Olthoi Alduressa armorPiece = ThreadSafeRandom.Next(0, 4); armorWeenie = LootTables.OlthoiAlduressaArmor[armorPiece]; break; } WorldObject wo = WorldObjectFactory.CreateNewWorldObject((uint)armorWeenie); if (wo == null) { return(null); } wo.SetProperty(PropertyString.LongDesc, wo.GetProperty(PropertyString.Name)); wo.SetProperty(PropertyInt.AppraisalItemSkill, 7); wo.SetProperty(PropertyInt.AppraisalLongDescDecoration, 1); materialType = GetMaterialType(wo, tier); if (materialType > 0) { wo.MaterialType = (MaterialType)materialType; } int gemCount = ThreadSafeRandom.Next(1, 6); int gemType = ThreadSafeRandom.Next(10, 50); wo.SetProperty(PropertyInt.GemCount, gemCount); wo.SetProperty(PropertyInt.GemType, gemType); int workmanship = GetWorkmanship(tier); wo.SetProperty(PropertyInt.ItemWorkmanship, workmanship); double materialMod = LootTables.getMaterialValueModifier(wo); double gemMaterialMod = LootTables.getGemMaterialValueModifier(wo); var value = GetValue(tier, workmanship, gemMaterialMod, materialMod); wo.Value = value; int wield; if (tier > 6 && armorType != (int)LootTables.ArmorType.CovenantArmor) { wo.SetProperty(PropertyInt.WieldRequirements, (int)WieldRequirement.Level); wo.SetProperty(PropertyInt.WieldSkillType, (int)Skill.Axe); // Set by examples from PCAP data switch (tier) { case 7: wield = 150; // In this instance, used for indicating player level, rather than skill level break; default: wield = 180; // In this instance, used for indicating player level, rather than skill level break; } wo.SetProperty(PropertyInt.WieldDifficulty, wield); } if (armorType == (int)LootTables.ArmorType.CovenantArmor) { Skill wieldSkill; int chance = ThreadSafeRandom.Next(1, 3); switch (chance) { case 1: // Magic Def wieldSkill = Skill.MagicDefense; break; case 2: // Missile Def wieldSkill = Skill.MissileDefense; break; default: // Melee Def wieldSkill = Skill.MeleeDefense; break; } wield = GetCovenantWieldReq(tier, wieldSkill); wo.SetProperty(PropertyInt.WieldRequirements, (int)WieldRequirement.RawSkill); wo.SetProperty(PropertyInt.WieldSkillType, (int)wieldSkill); wo.SetProperty(PropertyInt.WieldDifficulty, wield); } // Setting random color wo.SetProperty(PropertyInt.PaletteTemplate, ThreadSafeRandom.Next(1, 2047)); double shade = .1 * ThreadSafeRandom.Next(0, 9); wo.SetProperty(PropertyFloat.Shade, shade); var baseArmorLevel = wo.GetProperty(PropertyInt.ArmorLevel) ?? 0; if (baseArmorLevel > 0) { int adjustedArmorLevel = baseArmorLevel + GetArmorLevelModifier(tier, armorType); wo.SetProperty(PropertyInt.ArmorLevel, adjustedArmorLevel); } wo.SetProperty(PropertyInt.EquipmentSetId, equipSetId); if (isMagical) { wo.SetProperty(PropertyInt.UiEffects, (int)UiEffects.Magical); int numSpells = GetNumSpells(tier); int spellcraft = GetSpellcraft(numSpells, tier); wo.SetProperty(PropertyInt.ItemSpellcraft, spellcraft); wo.SetProperty(PropertyInt.ItemDifficulty, GetDifficulty(tier, spellcraft)); int maxMana = GetMaxMana(numSpells, tier); wo.SetProperty(PropertyInt.ItemMaxMana, maxMana); wo.SetProperty(PropertyInt.ItemCurMana, maxMana); int[][] spells; int[][] cantrips; spells = LootTables.ArmorSpells; cantrips = LootTables.ArmorCantrips; int[] shuffledValues = new int[spells.Length]; for (int i = 0; i < spells.Length; i++) { shuffledValues[i] = i; } Shuffle(shuffledValues); int minorCantrips = GetNumMinorCantrips(tier); int majorCantrips = GetNumMajorCantrips(tier); int epicCantrips = GetNumEpicCantrips(tier); int legendaryCantrips = GetNumLegendaryCantrips(tier); int numCantrips = minorCantrips + majorCantrips + epicCantrips + legendaryCantrips; if (numSpells - numCantrips > 0) { for (int a = 0; a < numSpells - numCantrips; a++) { int col = ThreadSafeRandom.Next(lowSpellTier - 1, highSpellTier - 1); int spellID = spells[shuffledValues[a]][col]; wo.Biota.GetOrAddKnownSpell(spellID, wo.BiotaDatabaseLock, wo.BiotaPropertySpells, out _); } } if (numCantrips > 0) { shuffledValues = new int[cantrips.Length]; for (int i = 0; i < cantrips.Length; i++) { shuffledValues[i] = i; } Shuffle(shuffledValues); int shuffledPlace = 0; //minor cantripps for (int a = 0; a < minorCantrips; a++) { int spellID = cantrips[shuffledValues[shuffledPlace]][0]; shuffledPlace++; wo.Biota.GetOrAddKnownSpell(spellID, wo.BiotaDatabaseLock, wo.BiotaPropertySpells, out _); } //major cantrips for (int a = 0; a < majorCantrips; a++) { int spellID = cantrips[shuffledValues[shuffledPlace]][1]; shuffledPlace++; wo.Biota.GetOrAddKnownSpell(spellID, wo.BiotaDatabaseLock, wo.BiotaPropertySpells, out _); } // epic cantrips for (int a = 0; a < epicCantrips; a++) { int spellID = cantrips[shuffledValues[shuffledPlace]][2]; shuffledPlace++; wo.Biota.GetOrAddKnownSpell(spellID, wo.BiotaDatabaseLock, wo.BiotaPropertySpells, out _); } //legendary cantrips for (int a = 0; a < legendaryCantrips; a++) { int spellID = cantrips[shuffledValues[shuffledPlace]][3]; shuffledPlace++; wo.Biota.GetOrAddKnownSpell(spellID, wo.BiotaDatabaseLock, wo.BiotaPropertySpells, out _); } } } else { wo.RemoveProperty(PropertyInt.ItemManaCost); wo.RemoveProperty(PropertyInt.ItemMaxMana); wo.RemoveProperty(PropertyInt.ItemCurMana); wo.RemoveProperty(PropertyInt.ItemSpellcraft); wo.RemoveProperty(PropertyInt.ItemDifficulty); } wo = RandomizeColor(wo); return(wo); }
/// <summary> /// Initializes a new instance of the <see cref="UniformOneGenerator"/> class. /// </summary> /// /// <param name="seed">Seed value to initialize random numbers generator.</param> /// public UniformOneGenerator( int seed ) { rand = new ThreadSafeRandom( seed ); }
private static int GetCovenantWieldReq(int tier, Skill skill) { int index, wield; switch (tier) { case 3: index = ThreadSafeRandom.Next(1, 3); break; case 4: index = ThreadSafeRandom.Next(1, 4); break; case 5: index = ThreadSafeRandom.Next(1, 5); break; case 6: index = ThreadSafeRandom.Next(1, 6); break; case 7: index = ThreadSafeRandom.Next(1, 7); break; default: index = ThreadSafeRandom.Next(1, 8); break; } switch (skill) { case Skill.MagicDefense: switch (index) { case 1: wield = 145; break; case 2: wield = 185; break; case 3: wield = 225; break; case 4: wield = 245; break; case 5: wield = 270; break; case 6: wield = 290; break; case 7: wield = 310; break; default: wield = 320; break; } break; case Skill.MissileDefense: switch (index) { case 1: wield = 160; break; case 2: wield = 205; break; case 3: wield = 245; break; case 4: wield = 270; break; case 5: wield = 290; break; case 6: wield = 305; break; case 7: wield = 330; break; default: wield = 340; break; } break; default: switch (index) { case 1: wield = 200; break; case 2: wield = 250; break; case 3: wield = 300; break; case 4: wield = 325; break; case 5: wield = 350; break; case 6: wield = 370; break; case 7: wield = 400; break; default: wield = 410; break; } break; } return(wield); }