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