DragonDice

            0
        Some (attr, delta)
      )
    else
      None
      
  static let (|Skill|_|) s =


    Skill.tryParse s










    
  static let DifficultyPattern = Regex(@"^(?:dc|difficulty)\s+(.+)$", RegexOptions.CultureInvariant ||| RegexOptions.IgnoreCase)
  static let parsePassiveOption _ s =
    let it = DifficultyPattern.Match(s)
    if it.Success then
      Difficulty.ofString it.Groups.[1].Value
    else
................................................................................
/estimate <i>N</i>d<i>S</i> [+- <i>D</i>] — Estimate the result of rolling <i>N</i> <i>S</i>-sided dice and adding / subtracting <i>D</i> to / from the total.

<b>Ability Checks:</b>
/roll <i>ABILITY</i> [+- <i>D</i>] [, <i>OPTION</i>] — Roll a 20-sided die, add / subtract the ability modifier and <i>D</i>, and compare with <i>DC</i>.
/estimate <i>ABILITY</i> [+- <i>D</i>] [, <i>OPTION</i>] — Estimate the result of rolling a 20-sided die, adding / subtracting the ability modifier and <i>D</i>, and comparing with <i>DC</i>.

<b>Skill Checks:</b>
/roll <i>SKILL</i> [, <i>OPTION</i>] — Roll a 20-sided die, add / subtract the skill and ability modifiers, and compare with <i>DC</i>.
/passive <i>SKILL</i> [, dc|difficulty <i>DC</i>] — Determine the passive score using the skill and ability modifiers, and compare with <i>DC</i>.
/estimate <i>SKILL</i> [, <i>OPTION</i>] — Estimate the result of rolling a 20-sided die, adding / subtracting the skill and ability modifiers, and comparing with <i>DC</i>.
/spellsave <i>SKILL</i> — Determine the spell save DC using the skill and ability modifiers of a magic skill.
/proficiency — Determine the proficiency bonus of the active character.

<b>Check Options:</b>
dc|difficulty <i>DC</i> — The <i>DC</i> of an ability or skill check may be specified as a number or it may be one of the adjectives <i>Very Easy</i>, <i>Easy</i>, <i>Medium</i>, <i>Hard</i>, <i>Very Hard</i>, or <i>Impossible</i>.
ins[piration] d<i>S</i> — An <i>S</i>-sided inspiration die may be added to a check. If multiple of these options are given, the highest <i>S</i> is used.
adv[antage]|dis[advantage]|normal — Checks may be performed at advantage, disadvantage or normal conditions. If multiple of these options are specified, the majority of advantage or disadvantage options determines the conditions.
................................................................................
            .Append(if result.IsSuccess then "Success" else "Failure")
            .Append("</b>")
          |> ignore
        else
          buffer.Append("<b>").Append(result.Score).Append("</b>") |> ignore
        return Markup (buffer.ToString(), List.empty)
        
      | "/roll" :: "?skill" :: Skill skill :: opts
      | "/roll" :: Skill skill :: opts ->
        let chr = selectedCharacter user
        let check = (chr.GetCheck(skill, 0), opts) ||> List.fold parseCheckOption
        let result = lock random (fun () -> Check.simulate random check)
        let buffer =
          Text.StringBuilder("<i>").Append(HttpUtility.HtmlEncode chr.Name).Append("</i> : ")
            .Append(Check.toDiceString check)
        if check.Difficulty > 0 then
          buffer.Append(" ≥ ").Append(check.Difficulty) |> ignore
        buffer.Append(" → ") |> ignore
................................................................................
            plotCheckEstimates check,
            sprintf "<i>%s</i> : %s ∈ [%d, %d] → E = <b>%.2f</b>\nP[Critical] = <b>%.1f%%</b>\n" <|
            (HttpUtility.HtmlEncode chr.Name) <|
            (Check.toDiceString check) <| check.Minimum <| check.Maximum <|
            result.Score <| result.IsCritical * 100.0
          )
        
      | "/estimate" :: "?skill" :: Skill skill :: opts
      | "/estimate" :: Skill skill :: opts ->
        let chr = selectedCharacter user
        let check = (chr.GetCheck(skill, 0), opts) ||> List.fold parseCheckOption
        if check.Difficulty > 0 then
          let result = Check.estimate check
          return Markup (
            sprintf "<i>%s</i> : %s ∈ [%d, %d] ≥ %d → E = %.2f\nP[Critical] = <b>%.1f%%</b>\nP[Success] = <b>%.1f%%</b>\n" <|
            (HttpUtility.HtmlEncode chr.Name) <|
            (Check.toDiceString check) <| check.Minimum <| check.Maximum <| check.Difficulty <|
            result.Score <| result.IsCritical * 100.0 <| result.IsSuccess * 100.0,
................................................................................
                None
            )
            >> Seq.toList
          )
          |> Seq.toList
        )
        
      | ["/spellsave"; Skill skill] ->
        let chr = selectedCharacter user

        let score = chr.GetSpellSave(skill)
        return Markup (
          sprintf "<i>%s</i> : DC = <b>%d</b>" (HttpUtility.HtmlEncode chr.Name) score,
          List.empty
        )
        
      | ["/proficiency"] ->
................................................................................
        for KeyValue (sense, v) in chr.Senses do
          if v > 0<ft> then
            if buffer.Length > pos then buffer.Append(", ") |> ignore
            buffer.Append(Sense.toString sense).Append(' ').Append(v).Append(" ft") |> ignore
        if buffer.Length = pos then buffer.Append("None") |> ignore
        return Markup (buffer.ToString(), List.empty)

      | ["/set"; Assignment (Skill skill, op, v)] ->
        let chr = selectedCharacter user
        let v = int v
        chr.Skills <-
          chr.Skills.With(
            match op with
            | '+' -> [skill, chr.Skills.[skill] + v]
            | '-' -> [skill, chr.Skills.[skill] - v]
            | _   -> [skill, v]
          )
        let buffer = Text.StringBuilder("<i>").Append(HttpUtility.HtmlEncode chr.Name).Append("</i> : ")
        let pos = buffer.Append("Skills = ").Length
        for KeyValue (skill, v) in chr.Skills do
          if v > 0 then
            let v = v + Ability.modifier chr.Abilities.[Skill.ability skill]
            if buffer.Length > pos then buffer.Append(", ") |> ignore
            buffer.Append(Skill.toString skill)
              .AppendFormat(CultureInfo.InvariantCulture, " {0:+0;-#}", v)
            |> ignore
        if buffer.Length = pos then buffer.Append("None") |> ignore
        return Markup (buffer.ToString(), List.empty)

      | ["/set"; Assignment (attr, op, v)] ->
        let chr = selectedCharacter user
        let attr = Ability.ofString attr
        let v = int v
        chr.Abilities <-
          chr.Abilities.With(
            match op with
            | '+' -> [attr, max 0 (chr.Abilities.[attr] + v)]
            | '-' -> [attr, max 0 (chr.Abilities.[attr] - v)]
            | _   -> [attr, max 0 v]
          )
        let buffer = Text.StringBuilder("<i>").Append(HttpUtility.HtmlEncode chr.Name).Append("</i> : ")
        let pos = buffer.Append("Abilities = ").Length
        for KeyValue (attr, v) in chr.Abilities do
          if buffer.Length > pos then buffer.Append(", ") |> ignore
          buffer.Append(Ability.toString attr)
            .AppendFormat(CultureInfo.InvariantCulture, " {0:D} ({1:+0;-#})", v, Ability.modifier v)

            0
        Some (attr, delta)
      )
    else
      None
      
  static let (|Skill|_|) s =
    let it = AbilityPattern.Match(s)
    if it.Success then
      Skill.tryParse it.Groups.[1].Value
      |> Option.bind (fun skill ->
        let delta =
          if it.Groups.[2].Success then
            int (it.Groups.[3].Value + it.Groups.[4].Value)
          else
            0
        Some (skill, delta)
      )
    else
      None
    
  static let DifficultyPattern = Regex(@"^(?:dc|difficulty)\s+(.+)$", RegexOptions.CultureInvariant ||| RegexOptions.IgnoreCase)
  static let parsePassiveOption _ s =
    let it = DifficultyPattern.Match(s)
    if it.Success then
      Difficulty.ofString it.Groups.[1].Value
    else
................................................................................
/estimate <i>N</i>d<i>S</i> [+- <i>D</i>] — Estimate the result of rolling <i>N</i> <i>S</i>-sided dice and adding / subtracting <i>D</i> to / from the total.

<b>Ability Checks:</b>
/roll <i>ABILITY</i> [+- <i>D</i>] [, <i>OPTION</i>] — Roll a 20-sided die, add / subtract the ability modifier and <i>D</i>, and compare with <i>DC</i>.
/estimate <i>ABILITY</i> [+- <i>D</i>] [, <i>OPTION</i>] — Estimate the result of rolling a 20-sided die, adding / subtracting the ability modifier and <i>D</i>, and comparing with <i>DC</i>.

<b>Skill Checks:</b>
/roll <i>SKILL</i> [+- <i>D</i>] [, <i>OPTION</i>] — Roll a 20-sided die, add / subtract the skill and ability modifiers and <i>D</i>, and compare with <i>DC</i>.
/estimate <i>SKILL</i> [+- <i>D</i>] [, <i>OPTION</i>] — Estimate the result of rolling a 20-sided die, adding / subtracting the skill and ability modifiers and <i>D</i>, and comparing with <i>DC</i>.
/passive <i>SKILL</i> [, <i>OPTION</i>] — Determine the passive score using the skill and ability modifiers, and compare with <i>DC</i>.
/spellsave <i>SKILL</i> — Determine the spell save DC using the skill and ability modifiers of a magic skill.
/proficiency — Determine the proficiency bonus of the active character.

<b>Check Options:</b>
dc|difficulty <i>DC</i> — The <i>DC</i> of an ability or skill check may be specified as a number or it may be one of the adjectives <i>Very Easy</i>, <i>Easy</i>, <i>Medium</i>, <i>Hard</i>, <i>Very Hard</i>, or <i>Impossible</i>.
ins[piration] d<i>S</i> — An <i>S</i>-sided inspiration die may be added to a check. If multiple of these options are given, the highest <i>S</i> is used.
adv[antage]|dis[advantage]|normal — Checks may be performed at advantage, disadvantage or normal conditions. If multiple of these options are specified, the majority of advantage or disadvantage options determines the conditions.
................................................................................
            .Append(if result.IsSuccess then "Success" else "Failure")
            .Append("</b>")
          |> ignore
        else
          buffer.Append("<b>").Append(result.Score).Append("</b>") |> ignore
        return Markup (buffer.ToString(), List.empty)
        
      | "/roll" :: "?skill" :: Skill (skill, delta) :: opts
      | "/roll" :: Skill (skill, delta) :: opts ->
        let chr = selectedCharacter user
        let check = (chr.GetCheck(skill, 0) + delta, opts) ||> List.fold parseCheckOption
        let result = lock random (fun () -> Check.simulate random check)
        let buffer =
          Text.StringBuilder("<i>").Append(HttpUtility.HtmlEncode chr.Name).Append("</i> : ")
            .Append(Check.toDiceString check)
        if check.Difficulty > 0 then
          buffer.Append(" ≥ ").Append(check.Difficulty) |> ignore
        buffer.Append(" → ") |> ignore
................................................................................
            plotCheckEstimates check,
            sprintf "<i>%s</i> : %s ∈ [%d, %d] → E = <b>%.2f</b>\nP[Critical] = <b>%.1f%%</b>\n" <|
            (HttpUtility.HtmlEncode chr.Name) <|
            (Check.toDiceString check) <| check.Minimum <| check.Maximum <|
            result.Score <| result.IsCritical * 100.0
          )
        
      | "/estimate" :: "?skill" :: Skill (skill, delta) :: opts
      | "/estimate" :: Skill (skill, delta) :: opts ->
        let chr = selectedCharacter user
        let check = (chr.GetCheck(skill, 0) + delta, opts) ||> List.fold parseCheckOption
        if check.Difficulty > 0 then
          let result = Check.estimate check
          return Markup (
            sprintf "<i>%s</i> : %s ∈ [%d, %d] ≥ %d → E = %.2f\nP[Critical] = <b>%.1f%%</b>\nP[Success] = <b>%.1f%%</b>\n" <|
            (HttpUtility.HtmlEncode chr.Name) <|
            (Check.toDiceString check) <| check.Minimum <| check.Maximum <| check.Difficulty <|
            result.Score <| result.IsCritical * 100.0 <| result.IsSuccess * 100.0,
................................................................................
                None
            )
            >> Seq.toList
          )
          |> Seq.toList
        )
        
      | ["/spellsave"; skill] ->
        let chr = selectedCharacter user
        let skill = Skill.ofString skill
        let score = chr.GetSpellSave(skill)
        return Markup (
          sprintf "<i>%s</i> : DC = <b>%d</b>" (HttpUtility.HtmlEncode chr.Name) score,
          List.empty
        )
        
      | ["/proficiency"] ->
................................................................................
        for KeyValue (sense, v) in chr.Senses do
          if v > 0<ft> then
            if buffer.Length > pos then buffer.Append(", ") |> ignore
            buffer.Append(Sense.toString sense).Append(' ').Append(v).Append(" ft") |> ignore
        if buffer.Length = pos then buffer.Append("None") |> ignore
        return Markup (buffer.ToString(), List.empty)

      | ["/set"; Assignment (Skill (skill, delta), op, v)] ->
        let chr = selectedCharacter user
        let v = int v
        chr.Skills <-
          chr.Skills.With(
            match op with
            | '+' -> [skill, chr.Skills.[skill] + v]
            | '-' -> [skill, chr.Skills.[skill] - v]
            | _   -> [skill, v - delta]
          )
        let buffer = Text.StringBuilder("<i>").Append(HttpUtility.HtmlEncode chr.Name).Append("</i> : ")
        let pos = buffer.Append("Skills = ").Length
        for KeyValue (skill, v) in chr.Skills do
          if v > 0 then
            let v = v + Ability.modifier chr.Abilities.[Skill.ability skill]
            if buffer.Length > pos then buffer.Append(", ") |> ignore
            buffer.Append(Skill.toString skill)
              .AppendFormat(CultureInfo.InvariantCulture, " {0:+0;-#}", v)
            |> ignore
        if buffer.Length = pos then buffer.Append("None") |> ignore
        return Markup (buffer.ToString(), List.empty)

      | ["/set"; Assignment (Ability (attr, delta), op, v)] ->
        let chr = selectedCharacter user

        let v = int v
        chr.Abilities <-
          chr.Abilities.With(
            match op with
            | '+' -> [attr, max 0 (chr.Abilities.[attr] + v)]
            | '-' -> [attr, max 0 (chr.Abilities.[attr] - v)]
            | _   -> [attr, max 0 (v - delta)]
          )
        let buffer = Text.StringBuilder("<i>").Append(HttpUtility.HtmlEncode chr.Name).Append("</i> : ")
        let pos = buffer.Append("Abilities = ").Length
        for KeyValue (attr, v) in chr.Abilities do
          if buffer.Length > pos then buffer.Append(", ") |> ignore
          buffer.Append(Ability.toString attr)
            .AppendFormat(CultureInfo.InvariantCulture, " {0:D} ({1:+0;-#})", v, Ability.modifier v)