feat: totals

src/app/tools/session/page.tsx

@@ -25,6 +25,7 @@ import {
   generateStats,
   prettifyStats,
   STAT_NAMES,
+  sumStats,
 } from '../../../core/blitz/generateStats';
 import {
   getAccountInfo,
@@ -75,12 +76,30 @@ export default function Page() {
   const delta = useMemo(
     () =>
       session.tracking && tankStatsB
-        ? deltaTankStats(session.player.stats, tankStatsB).sort(
+        ? deltaTankStats(session.player.stats, tankStatsB)
-            (a, b) => b.last_battle_time - a.last_battle_time,
+            .sort((a, b) => b.last_battle_time - a.last_battle_time)
-          )
+            .map((entry) => {
+              const tank = awaitedTankDefinitions[entry.tank_id];
+              const average = awaitedTankAvearges[tank.id];
+              const stats = generateStats(entry.all, average?.all);
+              const statsPretty = prettifyStats(stats);
+
+              return {
+                tank,
+                stats,
+                statsPretty,
+              };
+            })
         : undefined,
     [session.tracking && session.player, tankStatsB],
   );
+  const total = useMemo(
+    () =>
+      delta
+        ? prettifyStats(sumStats(delta.map(({ stats }) => stats)))
+        : undefined,
+    [delta],
+  );
 
   const search = debounce(async () => {
     if (!input.current) return;
@@ -338,13 +357,28 @@ export default function Page() {
           </Table.Header>
 
           <Table.Body>
-            {delta.map((entry) => {
+            <Table.Row
-              const tank = awaitedTankDefinitions[entry.tank_id];
+              style={{
-              const average = awaitedTankAvearges[tank.id];
+                overflow: 'hidden',
-              const stats = prettifyStats(
+              }}
-                generateStats(entry.all, average?.all),
+            >
-              );
+              <Table.RowHeaderCell
+                style={{
+                  paddingLeft: 32,
+                  position: 'relative',
+                  overflowY: 'hidden',
+                }}
+              >
+                Total
+              </Table.RowHeaderCell>
+              {session.columns.map((column) => (
+                <Table.Cell key={column} align="right">
+                  {total![column]}
+                </Table.Cell>
+              ))}
+            </Table.Row>
 
+            {delta.map(({ statsPretty, tank }) => {
               return (
                 <Table.Row
                   key={tank.id}
@@ -402,7 +436,7 @@ export default function Page() {
                   </Table.RowHeaderCell>
                   {session.columns.map((column) => (
                     <Table.Cell key={column} align="right">
-                      {stats[column]}
+                      {statsPretty[column]}
                     </Table.Cell>
                   ))}
                 </Table.Row>

src/core/blitz/generateStats.ts

@@ -7,23 +7,50 @@ export const STAT_NAMES: Record<Stat, string> = {
   battles: 'Battles',
   winrate: 'Winrate',
   wn8: 'WN8',
+  averageDamage: 'Damage',
   damage: 'Damage',
+  wins: 'Wins',
 };
 
 export function generateStats(s: AllStats, e?: AllStats) {
   return {
     battles: s.battles,
+    wins: s.wins,
     winrate: s.wins / s.battles,
     wn8: e ? calculateWN8(e, s) : null,
-    damage: s.damage_dealt / s.battles,
+    damage: s.damage_dealt,
+    averageDamage: s.damage_dealt / s.battles,
   };
 }
 
 export function prettifyStats(s: ReturnType<typeof generateStats>) {
   return {
     battles: `${s.battles}`,
+    wins: `${s.wins}`,
     winrate: `${(s.winrate * 100).toFixed(0)}%`,
     wn8: s.wn8 ? s.wn8.toFixed(0) : '--',
-    damage: s.damage.toFixed(0),
+    damage: `${s.damage}`,
+    averageDamage: s.averageDamage.toFixed(0),
   } satisfies Record<Stat, string>;
 }
+
+export function sumStats(s: ReturnType<typeof generateStats>[]) {
+  function sum(slice: (stat: ReturnType<typeof generateStats>) => number) {
+    return s.reduce((a, b) => a + slice(b), 0);
+  }
+
+  const battles = sum((s) => s.battles);
+  const wins = sum((s) => s.wins);
+  const damage = sum((s) => s.damage);
+
+  return {
+    battles,
+    wins,
+    winrate: wins / battles,
+    damage,
+    averageDamage: damage / battles,
+    wn8:
+      sum((s) => (s.wn8 ? s.wn8 * s.battles : 0)) /
+      sum((s) => (s.wn8 ? s.battles : 0)),
+  } satisfies ReturnType<typeof generateStats>;
+}

src/stores/session.ts

@@ -29,7 +29,7 @@ type Session = SessionTracking | SessionNotTracking;
 export const useSession = create<Session>()(
   persist(
     (set) => ({
-      columns: ['battles', 'winrate', 'wn8', 'damage'],
+      columns: ['battles', 'winrate', 'wn8', 'averageDamage'],
       tracking: false,
     }),
     { name: 'session-2', merge: (a, b) => merge(b, a) },