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)