/// <summary>Выбирает случайную схему монстра среди доступных.</summary> /// <param name="availableMonsterSchemes"> /// Доступные схемы монстров. /// Расчитываются исходя из схемы сектора и выбранной редкости. /// </param> /// <returns>Возвращает схему монстра.</returns> public IMonsterScheme RollMonsterScheme(IEnumerable <IMonsterScheme> availableMonsterSchemes) { var count = availableMonsterSchemes.Count(); var rollIndex = _dice.Roll(0, count - 1); return(availableMonsterSchemes.ElementAt(rollIndex)); }
public int RollChestCount(int maxCount) { if (maxCount <= 0) { throw new ArgumentException($"Значение {maxCount} не может быть меньше или равно 0.", nameof(maxCount)); } var currentProbability = _startChestProbability; var sum = 0; for (var i = 0; i < maxCount; i++) { var hasChestRoll = _dice.Roll(100); var successHasChest = 100 - currentProbability; if (hasChestRoll >= successHasChest) { sum++; } else { break; } currentProbability = currentProbability * _probabilityDividor; if (currentProbability <= 0) { break; } } return(sum); }
private IEnumerable <DiseaseSymptom> RolledSymptoms() { var symptomCount = _dice.Roll(3, 5); var rolledSymptoms = _dice.RollFromList(DiseaseSymptoms.Symptoms, symptomCount); return(rolledSymptoms); }
public ITroll GetTroll() { var troll = new Troll(_dice.Roll(_baseStrength), _dice.Roll(_baseHealth), _logger); _baseHealth += _healthChangePerInstance; _baseStrength += _strengthChangePerInstance; return(troll); }
public int MagicMissile(Player player, Player target, Room room) { var damage = _dice.Roll(1, 1, 4) + 1; _skillManager.DamagePlayer("magic missile", damage, player, target, room); return(damage); }
public int Haggle(Player player, Player target) { var foundSkill = player.Skills.FirstOrDefault(x => x.SkillName.StartsWith("haggle", StringComparison.CurrentCultureIgnoreCase)); if (foundSkill == null) { return(0); } var getSkill = _cache.GetSkill(foundSkill.SkillId); if (getSkill == null) { var skill = _cache.GetAllSkills().FirstOrDefault(x => x.Name.Equals("haggle", StringComparison.CurrentCultureIgnoreCase)); foundSkill.SkillId = skill.Id; getSkill = skill; } var proficiency = foundSkill.Proficiency; var success = _dice.Roll(1, 1, 100); if (success == 1 || success == 101) { return(0); } //TODO Charisma Check if (proficiency >= success) { _writer.WriteLine($"<p>You charm {target.Name} in offering you favourable prices.</p>", player.ConnectionId); return(25); } _writer.WriteLine("<p>Your haggle attempts fail.</p>", player.ConnectionId); if (foundSkill.Proficiency == 100) { return(0); } var increase = _dice.Roll(1, 1, 5); foundSkill.Proficiency += increase; _gain.GainExperiencePoints(player, 100 * foundSkill.Level / 4, false); _updateClientUi.UpdateExp(player); _writer.WriteLine( $"<p class='improve'>You learn from your mistakes and gain {100 * foundSkill.Level / 4} experience points.</p>" + $"<p class='improve'>Your knowledge of {foundSkill.SkillName} increases by {increase}%.</p>", player.ConnectionId, 0); return(0); }
public static int Roll2D6(this IDice dice) { if (dice is null) { throw new ArgumentNullException(nameof(dice)); } return(dice.Roll(6) + dice.Roll(6)); }
public int CalculateDamage(Player player, Player target, Item.Item weapon) { var damage = 0; if (weapon != null) { var skill = player.Skills.FirstOrDefault(x => x.SkillName.Replace(" ", string.Empty) .Equals(Enum.GetName(typeof(Item.Item.WeaponTypes), weapon.WeaponType))); damage = _dice.Roll(1, weapon.Damage.Minimum, weapon.Damage.Maximum); if (skill != null) { damage = (int)(damage * (skill.Proficiency + 1) / 100) + _dice.Roll(1, 1, 3); // 1-3 to stop hand to hand being OP earlier levels if weapon dam is less than 1d6 } else { damage /= 2; } } else { //Hand to hand damage = _dice.Roll(1, 1, 6); } // Enhanced Damage Skill check // increase damage is player has enhanced damage skill if (false) { } // calculate damage reduction based on target armour var strengthMod = Math.Round((double)(player.Attributes.Attribute[EffectLocation.Strength] - 20) / 2, MidpointRounding.ToEven); var levelDif = player.Level - target.Level <= 0 ? 0 : player.Level - target.Level; var totalDamage = damage + strengthMod + levelDif + player.Attributes.Attribute[EffectLocation.DamageRoll]; var criticalHit = 1; if (target.Status == CharacterStatus.Status.Sleeping || target.Status == CharacterStatus.Status.Stunned || target.Status == CharacterStatus.Status.Resting) { criticalHit = 2; } totalDamage *= criticalHit; // calculate damage reduction based on target armour var DamageAfterArmourReduction = DamageReduction(target, (int)totalDamage); return(DamageAfterArmourReduction); }
public void RollAndCreateUnityGroupIntoSector(ISector sector) { if (Globe is null) { return; } if (sector.ActorManager.Items.Any()) { return; } // Interventionists spawns first. // If globe has no interventionists then spawn they. // Next randomly spawns interventionists or militia. var interventionistsCount = Globe.SectorNodes.Select(x => x.Sector) .Where(x => x != null) .Select(x => x !) .SelectMany(x => x.ActorManager.Items) .Where(x => x.Person.Fraction == Fractions.InterventionistFraction) .Count(); if (interventionistsCount <= 0) { var count = _dice.Roll(2, 5); for (var i = 0; i < count; i++) { var person = _personFactory.Create("human-person", Fractions.InterventionistFraction); var nodes = sector.Map.Nodes.ToArray(); var startNode = _dice.RollFromList(nodes); var actor = new Actor(person, _actorTaskSource, startNode); sector.ActorManager.Add(actor); } } else { var faction = _dice.RollFromList(new[] { Fractions.InterventionistFraction, Fractions.MilitiaFraction, Fractions.TroublemakerFraction }); var count = _dice.Roll(2, 5); for (var i = 0; i < count; i++) { var person = _personFactory.Create("human-person", faction); var nodes = sector.Map.Nodes.ToArray(); var startNode = _dice.RollFromList(nodes); var actor = new Actor(person, _actorTaskSource, startNode); sector.ActorManager.Add(actor); } } }
public void TestUtilityRentWhenOneIsOwnedIs4TimesDiceRoll() { electric.LandedOnBy(playerOneId); dice.Roll(); electric.LandedOnBy(playerTwoId); Assert.That(banker.GetBalanceFor(playerTwoId), Is.EqualTo(1460)); Assert.That(banker.GetBalanceFor(playerOneId), Is.EqualTo(1390)); }
public static void WalkWithChanceOfStrengthIncrease(this IPlayableCharacter player, IDice dice, int sides) { var meters = dice.Roll(sides); player.Walk(meters); if (meters % 3 == 0) { player.IncreaseStrength(dice.Roll(5)); } }
private float RollDiseaseProgressSpeed() { const int BASE_DURABLE = 20_000; const float DIFF_DURABLE_PERCENTAGE = 0.1f; const int DIFF_DURABLE = (int)(BASE_DURABLE * DIFF_DURABLE_PERCENTAGE); var rolledDiff = _dice.Roll(-DIFF_DURABLE, DIFF_DURABLE); var factDurable = BASE_DURABLE + rolledDiff; return(1f / factDurable); }
public bool Hit(Unit attacker, Unit defender) { int HitRoll = _dice.Roll(); if (HitRoll >= attacker.BallisticSkill) { return(true); } else { return(false); } }
public int CalculateDamage(Player player, Player target, Item.Item weapon) { var damage = 0; if (weapon != null) { damage = _dice.Roll(1, weapon.Damage.Minimum, weapon.Damage.Maximum); } else { //Hand to hand damage = _dice.Roll(1, 1, 6); } // Enhanced Damage Skill check // increase damage is player has enhanced damage skill if (false) { } // calculate damage reduction based on target armour var armourReduction = DamageReduction(target, damage); //refactor this shit var strengthMod = 0.5 + player.Attributes.Attribute[EffectLocation.Strength] / (double)100; var levelDif = player.Level - target.Level <= 0 ? 1 : player.Level - target.Level; var levelMod = levelDif / 2 <= 0 ? 1 : levelDif / 2; var enduranceMod = player.Attributes.Attribute[EffectLocation.Moves] / (double)player.MaxAttributes.Attribute[EffectLocation.Moves]; var criticalHit = 1; if (target.Status == CharacterStatus.Status.Sleeping || target.Status == CharacterStatus.Status.Stunned || target.Status == CharacterStatus.Status.Resting) { criticalHit = 2; } int totalDamage = (int)(damage * strengthMod * criticalHit * levelMod); if (armourReduction > 0) { totalDamage = totalDamage / armourReduction; } if (totalDamage <= 0) { totalDamage = 1; } return(totalDamage); }
private void CreateRegionsAndTranstions(ISectorMap map, int mapSize, HexNode centerNode, IEnumerable <SectorTransition> transitions) { var availableNodes = map.Nodes.OfType <HexNode>().ToList(); // start region var startX = _dice.Roll(mapSize / 2) + centerNode.OffsetCoords.X; var startY = _dice.Roll(mapSize / 2) + centerNode.OffsetCoords.Y; var startRegionNodes = new[] { availableNodes.Single(x => x.OffsetCoords.CompsEqual(startX, startY)) }; var startRegion = new MapRegion(START_REGION_ID, startRegionNodes) { IsStart = true }; map.Regions.Add(startRegion); foreach (var node in startRegionNodes) { availableNodes.Remove(node); } // transition regions var transitionsList = transitions.ToArray(); for (var i = 0; i < transitionsList.Length; i++) { var roundPart = Math.PI * 2 * i / transitionsList.Length; var x = (int)(Math.Cos(roundPart) * mapSize) + centerNode.OffsetCoords.X; var y = (int)(Math.Sin(roundPart) * mapSize) + centerNode.OffsetCoords.Y; var transitionRegionNodes = new[] { availableNodes.Single(node => node.OffsetCoords.CompsEqual(x, y)) }; var transitionRegionId = START_REGION_ID + i + 1; var transitionRegion = new MapRegion(transitionRegionId, transitionRegionNodes); transitionRegion.ExitNodes = transitionRegion.Nodes; map.Regions.Add(transitionRegion); foreach (var node in transitionRegionNodes) { availableNodes.Remove(node); map.Transitions[node] = transitionsList[i]; } } // main region var mainRegion = new MapRegion(1000, availableNodes.ToArray()); map.Regions.Add(mainRegion); }
private void TakeTurn(ISuperPerson offenseFighter, ISuperPerson defenseFighter) { int damage = 0; // Determine if fighter1 gets a hit int speed = dice.Roll(); if (speed <= offenseFighter.Speed) { damage = offenseFighter.Strength; //Determine if fighter2 blocks and reduces damage by 50% bool wasBlocked = false; int resistance = dice.Roll(); if (resistance <= defenseFighter.Resistance) { damage = damage / 2; wasBlocked = true; } this.DispatchDamage(defenseFighter, damage); if (!wasBlocked) { this.DispatchLog(string.Format("{0} hits {1} with {2} damage.", offenseFighter.Name, defenseFighter.Name, damage)); } else { this.DispatchLog(string.Format("{0} hits {1} with {2} partially blocked damage.", offenseFighter.Name, defenseFighter.Name, damage)); } // Verify fighter2 is alive if (defenseFighter.IsAlive) { // Determine if fighter2 does counterdamage of 50% int intellect = dice.Roll(); if (intellect <= defenseFighter.Intellect) { int counterDamage = damage / 2; this.DispatchDamage(offenseFighter, counterDamage); this.DispatchLog(string.Format("{0} counters {1} with {2} damage.", defenseFighter.Name, offenseFighter.Name, counterDamage)); } } } else { this.DispatchLog(string.Format("{0} misses {1}.", offenseFighter.Name, defenseFighter.Name)); } }
public void Play() { var tokenIncrement = 1; if (Status == Status.Playing) { tokenIncrement = _dice.Roll(); } else { Status = Status.Playing; } _board.Move(this, tokenIncrement); }
public static T RollRandom <T>(List <T> list, IDice dice, Predicate <T> predicate) where T : class { if (list is null) { throw new ArgumentNullException(nameof(list)); } if (dice is null) { throw new ArgumentNullException(nameof(dice)); } if (predicate is null) { throw new ArgumentNullException(nameof(predicate)); } var count = list.Count; var currentIndex = dice.Roll(0, count - 1); var foundIndex = list.FindIndex(currentIndex, predicate); if (foundIndex > -1) { return(list[foundIndex]); } if (foundIndex >= 0) { foundIndex = list.FindIndex(0, currentIndex, predicate); return(list[foundIndex]); } return(null); }
public void TestInitialize() { dice = new Dice(); banker = new Banker(); board = new Board(banker, dice); player = new Player("test"); owner = new Player("Owner"); banker.AddAccount(owner, 1500); railRoad1 = new RailRoadProperty(5, banker, "railRoad1", 200); railRoad2 = new RailRoadProperty(15, banker, "railRoad2", 200); railRoad3 = new RailRoadProperty(25, banker, "railRoad3", 200); railRoad4 = new RailRoadProperty(35, banker, "railRoad4", 200); var groupedSpaces = new List <IOwnableProperty>() { railRoad1, railRoad2, railRoad3, railRoad4 }; railRoad1.GroupedSpaces = groupedSpaces; railRoad2.GroupedSpaces = groupedSpaces; railRoad3.GroupedSpaces = groupedSpaces; railRoad4.GroupedSpaces = groupedSpaces; dice.Roll(); }
public MoveResult Move(PlayerToken playerToken) { var diceResult = _dice.Roll(); if (!ValidateMove(playerToken, diceResult)) { return new MoveResult { NewSquare = playerToken.GetCurrentSquare(), Status = MoveStatus.Rejected } } ; playerToken.Move(diceResult); if (IsPlayerWon(playerToken)) { return new MoveResult { NewSquare = playerToken.GetCurrentSquare(), Status = MoveStatus.GameWon } } ; return(new MoveResult { NewSquare = playerToken.GetCurrentSquare(), Status = MoveStatus.Moved }); }
private void RollDiceAndPayOwnerTenTimesTheRoll(Int32 playerId) { dice.Roll(); var rent = dice.GetCurrentRoll() * 10; banker.TransferMoney(playerId, OwnerId, rent); }
public IRoll Roll() { var roll = _decoratedDice.Roll(); _lastRoll = roll; return(roll); }
public void WhenPlayerRolls4_ThenTokenShouldMove4Spaces(GameEngine gameEngine, Player player, IDice dice, int diceRollResult, int positionBeforeMove) { "Given the player rolls a 4" .x(() => { dice = A.Fake <IDice>(); A.CallTo(() => dice.Roll()).Returns(4); player = new Player(1, "Player 1", dice); int totalSquares = 100; gameEngine = new GameEngine(totalSquares); gameEngine.AddPlayer(player); gameEngine.Start(); }); "When they move their token" .x(() => { positionBeforeMove = gameEngine.CurrentSquareForPlayer(player); gameEngine.MovePlayer(player, player.RollDice()); }); "Then the token should move 4 space" .x(() => { int positionAfterMove = gameEngine.CurrentSquareForPlayer(player); int result = positionAfterMove - positionBeforeMove; result.Should().Be(4); }); }
public MoveResult Move() { var squaresToMove = _dice.Roll(); if (!_board.ValidateMove(_playingToken.CurrentPosition + squaresToMove)) { return(new MoveResult { Message = $"Move Rejected", MoveStatus = MoveResult.Status.Rejected, NewSquare = _playingToken.CurrentPosition }); } var newPosition = _playingToken.Move(squaresToMove); var boardResult = _board.GetEffectOfSquare(newPosition); if (boardResult.MoveStatus == MoveResult.Status.Victory) { return(boardResult); } return(new MoveResult { Message = $"You moved {squaresToMove} squares to {newPosition}", MoveStatus = MoveResult.Status.Moved, NewSquare = newPosition }); }
public int RollDiceForPlayOrder(IDice dice) { dice.Roll(); this.PlayOrderDiceRoll = dice.Result; this.DiceRolledForPlayOrder = true; return(this.PlayOrderDiceRoll); }
public void RollDice() { int d = dice.Roll(); OnDiceRolled?.Invoke(d); movePlayer(d); }
public IPerk[] Generate() { var allBuildInPerks = _schemeService.GetSchemes <IPerkScheme>().Where(x => x.IsBuildIn).ToArray(); var maxPerkCount = Math.Min(allBuildInPerks.Length, START_TRAIT_MAX_COUNT); var minPerkCount = Math.Min(maxPerkCount, START_TRAIT_MIN_COUNT); var startPerkCount = _dice.Roll(minPerkCount, maxPerkCount); var traitList = new List <IPerk>(); var openTraitSchemeList = new List <IPerkScheme>(allBuildInPerks); for (var i = 0; i < startPerkCount; i++) { var rolledTraitScheme = _dice.RollFromList(openTraitSchemeList); openTraitSchemeList.Remove(rolledTraitScheme); var traitPerk = new Perk { Scheme = rolledTraitScheme }; traitList.Add(traitPerk); } return(traitList.ToArray()); }
public int Roll() { var rolledNumber = _dice.Roll(); _logger.Log("We just rolled an awesome random number {0}", rolledNumber); return(rolledNumber); }
public override int RollDice(IDice dice, int noOfDice = 2) { int rollResult = dice.Roll(noOfDice); Console.WriteLine("You have rolled " + rollResult); return(rollResult); }
public IPerk[] Generate() { //TODO Mark *-immunity traits as test. var allBuildInPerks = _schemeService.GetSchemes <IPerkScheme>() .Where(x => x.IsBuildIn && x.Sid != "thrist-immunity" && x.Sid != "hunger-immunity").ToArray(); var maxPerkCount = Math.Min(allBuildInPerks.Length, START_TRAIT_MAX_COUNT); var minPerkCount = Math.Min(maxPerkCount, START_TRAIT_MIN_COUNT); var startPerkCount = _dice.Roll(minPerkCount, maxPerkCount); var traitList = new List <IPerk>(); var openTraitSchemeList = new List <IPerkScheme>(allBuildInPerks); for (var i = 0; i < startPerkCount; i++) { var rolledTraitScheme = _dice.RollFromList(openTraitSchemeList); openTraitSchemeList.Remove(rolledTraitScheme); var traitPerk = new Perk(rolledTraitScheme); traitList.Add(traitPerk); } return(traitList.ToArray()); }
public EffectOutcome Execute(IDice dice, Combatant attacker, Combatant defender) { var damage = (int) Math.Round(dice.Roll(Magnitude) * (1 + ((double)attacker.Intelligence.GetStatModifier() / 9)), MidpointRounding.AwayFromZero); defender.LowerHealth(damage); return new EffectOutcome() { Description = string.Format("{0} takes {1} points of damage!", defender.Name, damage), Damage = damage }; }
public override EffectOutcome Execute(IDice dice, Combatant combatant) { int energyBeforeHeal = combatant.CurrentEnergy; var restoreAmount = (int)Math.Round(dice.Roll(Magnitude) * (1 + ((double)combatant.Wisdom.GetStatModifier() / 9)), MidpointRounding.AwayFromZero); combatant.RestoreEnergy(restoreAmount); int actualRestoreAmount = combatant.CurrentHitPoints - energyBeforeHeal; return new EffectOutcome() { Healing = actualRestoreAmount, Description = string.Format("{0} regained {1} energy points", combatant.Name, actualRestoreAmount) }; }
public override EffectOutcome Execute(IDice dice, Combatant combatant) { int healthBeforeHeal = combatant.CurrentHitPoints; var healAmount = (int)Math.Round(dice.Roll(Magnitude) * (1 + ((double)combatant.Wisdom.GetStatModifier() / 9)), MidpointRounding.AwayFromZero); combatant.RestoreHealth(healAmount); int actualHealAmount = combatant.CurrentHitPoints - healthBeforeHeal; return new EffectOutcome() { Healing = actualHealAmount, Description = string.Format("{0} healed for {1} hit points", combatant.Name, actualHealAmount) }; }
public void MoveToNearestUtility(IPlayer player, IDice dice) { ILocation closestUtility = realtor.GetClosest(player.PlayerLocation.SpaceNumber, PropertyGroup.Utility); MovePlayerToLocation(player, closestUtility); if (realtor.SpaceIsForSale(player.PlayerLocation.SpaceNumber)) { HandlePurchasing(player); } else { dice.Roll(); realtor.ChargeTenTimesRollValueRent(player, dice.Score); } }
public int GetAttackDamage(IDice dice) { return Strength.GetStatModifier() + DamageModifiers.Sum() + (dice.Roll(Weapon.Damage) * (Weapon.Level + 1)); }
Guid RollDiceUntilWinner(IEnumerable<Guid> players, IDice dice) { var playerRolls = players .Select(p => new { Player = p, Roll = dice.Roll() }) .ToList(); var highestRollers = playerRolls .Where(p => p.Roll == playerRolls.Max(r => r.Roll)) .Select(p => p.Player) .ToList(); return highestRollers.Count() == 1 ? highestRollers.Single() : RollDiceUntilWinner(highestRollers, dice); }
public void SetRequiredNumberOfMonstersInCurrentDungeonLevelBeforeBoss(IDice dice) { NumberOfMonstersDefeatedInCurrentDungeonLevel = 0; RequiredNumberOfMonstersInCurrentDungeonLevelBeforeBoss = Player.Level + dice.Roll(1, 6); }