Commit: 8ef92b30e9d6b6f99d878d198a107b8d76885cc8 - flitter-nix (git)

A Nix-friendly SQLite-enhanced fork of Flitter, a speedrunning split timer for Unix-style terminals

Commit MetaInfo

• Révision: 8ef92b30e9d6b6f99d878d198a107b8d76885cc8 (tree)
• l'heure: 2022-12-20 08:55:14
• Auteur: Corbin <cds@corb...>
• Commiter: Corbin

Message de Log

Add command for summarizing splits.

So that I don't have to run the entire timer just to look at a single
split file.

Change Summary

• modified: bin/dune
• add: bin/summary_main.ml
• modified: shell.nix
• modified: src/display.mli
• modified: src/duration.mli
• modified: src/event_loop.mli
• modified: src/hotkeys.mli
• modified: src/loadsave.ml
• modified: src/loadsave.mli
• add: src/summary.ml

Modification

--- a/bin/dune
+++ b/bin/dune
@@ -1,9 +1,6 @@
 (executables
- (names main)
+ (names main summary_main)
+ (public_names flitter flitter-summary)
  (libraries flitter))
 
-(install
- (section bin)
- (files (main.exe as flitter)))
-
  ; vim:ft=scheme

--- /dev/null
+++ b/bin/summary_main.ml
@@ -0,0 +1,10 @@
+let usage =
+  "Usage:\n" ^ "flitter-summary <splits_path>\n"
+  ^ "Summarize the splits file pointed to by `splits_path`.\n"
+
+let () =
+  match Sys.argv with
+  | [| _; path |] ->
+      let summary = Loadsave.load_summary path in
+      Summary.print_summary summary
+  | _ -> print_string usage

--- a/shell.nix
+++ b/shell.nix
@@ -7,6 +7,6 @@ in pkgs.stdenv.mkDerivation {
     # working with S-expressions
     ocamlPackages.sexp
     # maintaining OCaml code
-    ocamlformat
+    ocamlformat ocamlPackages.utop
   ];
 }

--- a/src/display.mli
+++ b/src/display.mli
@@ -2,4 +2,4 @@ type t
 
 val make : unit -> t
 val draw : t -> Timer_types.timer -> unit
-val close : t -> unit
\ No newline at end of file
+val close : t -> unit

--- a/src/duration.mli
+++ b/src/duration.mli
@@ -4,11 +4,9 @@ type t = int (* Milliseconds *)
 
 val t_of_sexp : Sexp.t -> t
 val sexp_of_t : t -> Sexp.t
-
 val of_string : string -> t option
 val to_string : t -> int -> string (* int is # of decimal places *)
 val to_string_plus : t -> int -> string
 val string_valid : string -> bool
-
 val between : float -> float -> t
 val since : float -> t

--- a/src/event_loop.mli
+++ b/src/event_loop.mli
@@ -1,4 +1,4 @@
 type t
 
 val make : Timer_types.timer -> t Lwt.t
-val loop : t -> unit Lwt.t
\ No newline at end of file
+val loop : t -> unit Lwt.t

--- a/src/hotkeys.mli
+++ b/src/hotkeys.mli
@@ -1,4 +1,4 @@
 type keypress = float * string
 type t = keypress Lwt_stream.t
 
-val make_stream : unit -> t Lwt.t
\ No newline at end of file
+val make_stream : unit -> t Lwt.t

--- a/src/loadsave.ml
+++ b/src/loadsave.ml
@@ -12,6 +12,12 @@ type split = {
 type gold = { title : string; duration : Duration.t } [@@deriving sexp]
 type archived_run = { attempt : int; splits : split array } [@@deriving sexp]
 
+let time_of_split segment { splits } =
+  Array.find_map splits ~f:(fun { title; time } ->
+      if String.equal segment title then Some time else None)
+
+let times_for_segment segment = List.filter_map ~f:(time_of_split segment)
+
 type game = {
   title : string;
   category : string;
@@ -55,6 +61,18 @@ let game_of_sexp sexp =
         "Not all history runs have same number of splits as split_names" sexp
     else game
 
+let relativize run =
+  let rel =
+    Array.folding_map run.splits ~init:0 ~f:(fun offset sp ->
+        (sp.time, { sp with time = sp.time - offset }))
+  in
+  { run with splits = rel }
+
+let times_for_game_history { split_names; history } =
+  let relative_history = List.map ~f:relativize history in
+  Array.map split_names ~f:(fun title ->
+      (title, times_for_segment title relative_history))
+
 let load_golds parsed_game =
   if Array.length parsed_game.golds = 0 then
     Array.map parsed_game.split_names ~f:(fun name ->
@@ -99,6 +117,20 @@ let load filepath =
     splits_file = filepath;
   }
 
+let load_summary filepath =
+  let game = Sexp.load_sexp_conv_exn filepath game_of_sexp in
+  (* let pb = load_run_opt game.personal_best in
+     let golds = load_golds game in *)
+  let times = times_for_game_history game in
+
+  {
+    Summary.title = game.title;
+    category = game.category;
+    attempts = game.attempts;
+    completed = game.completed;
+    splits = times;
+  }
+
 let export_run (run : Timer_types.archived_run) =
   {
     attempt = run.attempt;

--- a/src/loadsave.mli
+++ b/src/loadsave.mli
@@ -1,2 +1,6 @@
+(* Load and prepare to run. *)
 val load : string -> Timer_types.timer
-val save : Timer_types.timer -> unit
\ No newline at end of file
+val save : Timer_types.timer -> unit
+
+(* Load and summarize. *)
+val load_summary : string -> Summary.t

--- /dev/null
+++ b/src/summary.ml
@@ -0,0 +1,52 @@
+open Core
+
+type welford = { n : int; m1 : float; m2 : float }
+
+let do_welford =
+  List.fold
+    ~f:(fun { n; m1; m2 } d ->
+      let delta = Float.of_int d -. m1 in
+      let dn = delta /. Float.of_int (n + 1) in
+      let t = delta *. dn *. Float.of_int n in
+      { n = n + 1; m1 = m1 +. dn; m2 = m2 +. t })
+    ~init:{ n = 0; m1 = 0.0; m2 = 0.0 }
+
+let mean { m1; _ } = m1
+
+let variance { n; m2; _ } =
+  if n < 2 then None else Some (m2 /. Float.of_int (n - 1))
+
+let stddev s = Option.value_map (variance s) ~default:0.0 ~f:Float.sqrt
+let best = List.fold ~f:Int.min ~init:Int.max_value
+
+let print_summary_segment width segment times =
+  let w = do_welford times in
+  (* NB: 12 digits is a reasonable width for durations; it would take over a
+     week for a segment to surpass it! *)
+  Printf.printf "%*s: %12s %12s %12s (best/mean/stddev)\n" (width + 2) segment
+    (Duration.to_string (best times) 3)
+    (Duration.to_string (Float.to_int (mean w)) 3)
+    (Duration.to_string (Float.to_int (stddev w)) 3)
+
+type t = {
+  title : string;
+  category : string;
+  attempts : int;
+  completed : int;
+  splits : (string * Duration.t list) array;
+}
+
+let print_completion completed attempts =
+  let percentage = completed * 100 / attempts in
+  Printf.printf "Completion rate: %d/%d (%d%%)\n" completed attempts percentage
+
+let print_summary (summary : t) =
+  let titlewidth =
+    Array.fold summary.splits ~init:0 ~f:(fun x (title, _) ->
+        Int.max x (String.length title))
+  in
+  print_endline ("Title: " ^ summary.title);
+  print_endline ("Category: " ^ summary.category);
+  print_completion summary.completed summary.attempts;
+  Array.iter summary.splits ~f:(fun (title, times) ->
+      print_summary_segment titlewidth title times)