Commit dbbdf39b: Commit initial code merge for dicenotation data types.

DiceResult.cs

+105

/D20Tek.Common/DataTypes/DiceNotation/DiceResult.cs

View

// <copyright file="DiceResult.cs" company="DarthPedro">

// </copyright>

//-----------------------------------------------------------------------

// <summary>

// This project is licensed under the MIT license.

//

// D20Tek.CommonDataTypes is an open source project that parses,

// evalutes, and rolls dice that conform to the defined Dice notiation.

// This notation is usable in any form of random dice games and role-playing

// games like D&D and d20.

// </summary>

//-----------------------------------------------------------------------

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text.Json.Serialization;

namespace D20Tek.DiceNotation

{

/// <summary>

/// Class the represents the results for any dice expression calculation.

/// </summary>

public class DiceResult

{

private const string FudgeDiceIdentifier = "f";

private static readonly TermResultListConverter Converter = new TermResultListConverter();

/// <summary>

/// Initializes a new instance of the <see cref="DiceResult"/> class.

/// </summary>

/// <param name="expression">dice expression rolled.</param>

/// <param name="results">List for results for each term in dice expression.</param>

/// <param name="rollerUsed">Define die roller used to get the results.</param>

/// <param name="config">Dice config to tell whether this result will be bounded or unbounded.</param>

public DiceResult(string expression, List<TermResult> results, string rollerUsed, IDiceConfiguration config)

: this(expression, results.Sum(r => (int)Math.Round(r.AppliesToResultCalculation ? r.Value * r.Scalar : 0)), results, rollerUsed, config)

{

}

/// <summary>

/// Initializes a new instance of the <see cref="DiceResult"/> class.

/// </summary>

/// <param name="expression">dice expression rolled.</param>

/// <param name="value">calculated value of the results.</param>

/// <param name="results">List for results for each term in dice expression.</param>

/// <param name="rollerUsed">Define die roller used to get the results.</param>

/// <param name="config">Dice config to tell whether this result will be bounded or unbounded.</param>

public DiceResult(string expression, int value, List<TermResult> results, string rollerUsed, IDiceConfiguration config)

{

this.DiceExpression = expression;

this.DieRollerUsed = rollerUsed;

this.Results = results.ToList();

bool boundedResult = expression.Contains(FudgeDiceIdentifier) ? false : config.HasBoundedResult;

this.Value = boundedResult ? Math.Max(value, config.BoundedResultMinimum) : value;

}

/// <summary>

/// Initializes a new instance of the <see cref="DiceResult"/> class.

/// </summary>

public DiceResult()

{

}

/// <summary>

/// Gets or sets the dice expression that was evaluated.

/// </summary>

public string DiceExpression { get; set; }

/// <summary>

/// Gets or sets the die roller used to generate this result.

/// </summary>

public string DieRollerUsed { get; set; }

/// <summary>

/// Gets the display text representation of the Results list.

/// </summary>

[JsonIgnore]

public string RollsDisplayText

{

get

{

if (this.Results == null)

{

return string.Empty;

}

return Converter.Convert(new List<TermResult>(this.Results), typeof(string), null, "en-us") as string;

}

/// <summary>

/// Gets or sets the results list for all of the terms in this dice expression.

/// </summary>

public IReadOnlyList<TermResult> Results { get; set; }

/// <summary>

/// Gets or sets the numeric value for this result.

/// </summary>

public int Value { get; set; }

}

DiceResultConverter.cs

+67

/D20Tek.Common/DataTypes/DiceNotation/DiceResultConverter.cs

View

// <copyright file="DiceResultConverter.cs" company="DarthPedro">

// </copyright>

//-----------------------------------------------------------------------

// <summary>

// This project is licensed under the MIT license.

//

// D20Tek.CommonDataTypes is an open source project that parses,

// evalutes, and rolls dice that conform to the defined Dice notiation.

// This notation is usable in any form of random dice games and role-playing

// games like D&D and d20.

// </summary>

//-----------------------------------------------------------------------

using System;

namespace D20Tek.DiceNotation

{

/// <summary>

/// Value converter to change a DiceResult into a display string.

/// </summary>

public class DiceResultConverter

{

/// <summary>

/// Converts the DiceResult into a string respresentation.

/// </summary>

/// <param name="value">value to convert.</param>

/// <param name="targetType">target type of the conversion.</param>

/// <param name="parameter">converter parameter.</param>

/// <param name="language">language.</param>

/// <returns>Converted value.</returns>

public virtual object Convert(object value, Type targetType, object parameter, string language)

{

if (targetType != typeof(string))

{

throw new ArgumentException("Unexpected type passed to converter.", nameof(targetType));

}

if (value == null)

{

throw new ArgumentNullException(nameof(value));

}

if (!(value is DiceResult dr))

{

throw new ArgumentException("Object not of type DiceResult.", nameof(value));

}

return string.Format("{0} ({1})", dr.Value, dr.DiceExpression);

}

/// <summary>

/// Converts back from string representation to a DiceResult.

/// </summary>

/// <param name="value">value to convert.</param>

/// <param name="targetType">target type of the conversion.</param>

/// <param name="parameter">converter parameter.</param>

/// <param name="language">language.</param>

/// <returns>Converted value.</returns>

public virtual object ConvertBack(object value, Type targetType, object parameter, string language)

{

// the reverse conversion is not supported.

throw new NotSupportedException();

}

IDice.cs

+81

/D20Tek.Common/DataTypes/DiceNotation/IDice.cs

View

// <copyright file="IDice.cs" company="DarthPedro">

// </copyright>

//-----------------------------------------------------------------------

// <summary>

// This project is licensed under the MIT license.

//

// D20Tek.CommonDataTypes is an open source project that parses,

// evalutes, and rolls dice that conform to the defined Dice notiation.

// This notation is usable in any form of random dice games and role-playing

// games like D&D and d20.

// </summary>

//-----------------------------------------------------------------------

namespace D20Tek.DiceNotation

{

/// <summary>

/// Interface that defines operations on dice.

/// </summary>

public interface IDice

{

/// <summary>

/// Gets the current configuration for this set of Dice.

/// </summary>

IDiceConfiguration Configuration { get; }

/// <summary>

/// Clears the current dice expression.

/// </summary>

void Clear();

/// <summary>

/// Creates a DiceTerm with specified values for this dice expression.

/// </summary>

/// <param name="sides">sides of die.</param>

/// <param name="numberDice">number of dice.</param>

/// <param name="scalar">scalar multiplier.</param>

/// <param name="choose">choose how many results to return.</param>

/// <param name="exploding">Exploding threshold for dice re-rolls.</param>

/// <returns>IDice representing the current terms.</returns>

IDice Dice(int sides, int numberDice = 1, double scalar = 1, int? choose = null, int? exploding = null);

/// <summary>

/// Creates a FudgeDiceTerm with specified values for this dice expression.

/// </summary>

/// <param name="numberDice">number of dice.</param>

/// <param name="choose">choose how many results to return.</param>

/// <returns>IDice representing the current terms.</returns>

IDice FudgeDice(int numberDice = 1, int? choose = null);

/// <summary>

/// Creates a ConstantTerm with the specified value for this dice expression.

/// </summary>

/// <param name="constant">Constant value.</param>

/// <returns>IDice representing the current terms.</returns>

IDice Constant(int constant);

/// <summary>

/// Concatenates the terms of another Dice expression into this Dice expression.

/// </summary>

/// <param name="otherDice">Other IDice terms to concatentate.</param>

/// <returns>IDice representing the current terms.</returns>

IDice Concat(IDice otherDice);

/// <summary>

/// Rolls the dice for all of the terms in this expression.

/// </summary>

/// <param name="dieRoller">Die roller to use in calculations.</param>

/// <returns>Dice results.</returns>

DiceResult Roll(IDieRoller dieRoller);

/// <summary>

/// Rolls the dice for the dice expression as a string.

/// </summary>

/// <param name="expression">Expression string to parse.</param>

/// <param name="dieRoller">Die roller to use in calculations.</param>

/// <returns>Dice results.</returns>

DiceResult Roll(string expression, IDieRoller dieRoller);

}

IDiceConfiguration.cs

+38

/D20Tek.Common/DataTypes/DiceNotation/IDiceConfiguration.cs

View

// <copyright file="IDiceConfiguration.cs" company="DarthPedro">

// </copyright>

//-----------------------------------------------------------------------

// <summary>

// This project is licensed under the MIT license.

//

// D20Tek.CommonDataTypes is an open source project that parses,

// evalutes, and rolls dice that conform to the defined Dice notiation.

// This notation is usable in any form of random dice games and role-playing

// games like D&D and d20.

// </summary>

//-----------------------------------------------------------------------

namespace D20Tek.DiceNotation

{

/// <summary>

/// Interface for dice configuration which allows users to customize

/// some of the default behavior of the DiceNotation system.

/// </summary>

public interface IDiceConfiguration

{

/// <summary>

/// Gets or sets the defualt sides of dice to use when it's omitted from dice notation.

/// </summary>

int DefaultDieSides { get; set; }

/// <summary>

/// Gets or sets a value indicating whether these dice have their results bounded to 1 or greater.

/// </summary>

bool HasBoundedResult { get; set; }

/// <summary>

/// Gets or sets the value for the bounded minimum.

/// </summary>

int BoundedResultMinimum { get; set; }

}

IDieRoller.cs

+31

/D20Tek.Common/DataTypes/DiceNotation/IDieRoller.cs

View

// <copyright file="IDieRoller.cs" company="DarthPedro">

// </copyright>

//-----------------------------------------------------------------------

// <summary>

// This project is licensed under the MIT license.

//

// D20Tek.CommonDataTypes is an open source project that parses,

// evalutes, and rolls dice that conform to the defined Dice notiation.

// This notation is usable in any form of random dice games and role-playing

// games like D&D and d20.

// </summary>

//-----------------------------------------------------------------------

namespace D20Tek.DiceNotation

{

/// <summary>

/// Interface defining the random die roller.

/// </summary>

public interface IDieRoller

{

/// <summary>

/// Rolls the die with the specified number of sides.

/// </summary>

/// <param name="sides">Number of sides on the die (also its max value).</param>

/// <param name="factor">Provide a factor to impact the roll (defaults to nothing, but used for fudge dice).</param>

/// <returns>Random value between 1 and sides.</returns>

int Roll(int sides, int? factor = null);

}

TermResult.cs

+44

/D20Tek.Common/DataTypes/DiceNotation/TermResult.cs

View

// <copyright file="TermResult.cs" company="DarthPedro">

// </copyright>

//-----------------------------------------------------------------------

// <summary>

// This project is licensed under the MIT license.

//

// D20Tek.CommonDataTypes is an open source project that parses,

// evalutes, and rolls dice that conform to the defined Dice notiation.

// This notation is usable in any form of random dice games and role-playing

// games like D&D and d20.

// </summary>

//-----------------------------------------------------------------------

namespace D20Tek.DiceNotation

{

/// <summary>

/// The resulting role for a single term in dice notation.

/// </summary>

public class TermResult

{

/// <summary>

/// Gets or sets the scalar multiplier of this result.

/// </summary>

public double Scalar { get; set; }

/// <summary>

/// Gets or sets the result value.

/// </summary>

public int Value { get; set; }

/// <summary>

/// Gets or sets the type of the term.

/// </summary>

public string Type { get; set; }

/// <summary>

/// Gets or sets a value indicating whether this term applies to

/// the final result calculation.

/// </summary>

public bool AppliesToResultCalculation { get; set; } = true;

}

TermResultListConverter.cs

/D20Tek.Common/DataTypes/DiceNotation/TermResultListConverter.cs

View

D20Tek.Common.csproj

/D20Tek.Common/D20Tek.Common.csproj

View

D20Tek.Common.xml

/D20Tek.Common/D20Tek.Common.xml

View

stylecop.json

/D20Tek.Common/stylecop.json

View

DiceResultConverterTests.cs

/D20Tek.Common.UnitTests/DataTypes/DiceNotation/DiceResultConverterTests.cs

View

DiceResultTests.cs

/D20Tek.Common.UnitTests/DataTypes/DiceNotation/DiceResultTests.cs

View

TermResultListConverterTests.cs

/D20Tek.Common.UnitTests/DataTypes/DiceNotation/TermResultListConverterTests.cs

View

TermResultTests.cs

/D20Tek.Common.UnitTests/DataTypes/DiceNotation/TermResultTests.cs

View

D20Tek.Common.UnitTests.csproj

/D20Tek.Common.UnitTests/D20Tek.Common.UnitTests.csproj

View

azure-pipelines.yml

/azure-pipelines.yml

View

D20Tek.Common.sln

/D20Tek.Common.sln

View



	D20Tek.Common
	DataTypes/DiceNotation
	DiceResult.cs +
	DiceResultConverter.cs +
	IDice.cs +
	IDiceConfiguration.cs +
	IDieRoller.cs +
	TermResult.cs +
	TermResultListConverter.cs +
	D20Tek.Common.csproj +
	D20Tek.Common.xml +
	stylecop.json +
	D20Tek.Common.UnitTests
	DataTypes/DiceNotation
	DiceResultConverterTests.cs +
	DiceResultTests.cs +
	TermResultListConverterTests.cs +
	TermResultTests.cs +
	D20Tek.Common.UnitTests.csproj +
	azure-pipelines.yml +
	D20Tek.Common.sln +