Project Chimera
Меню

Исходники

666 строк · 33 КиБ

code/crates/chl-core/src/state.rs

1//! Состояние запусков: что и когда игра использовала в прошлый раз.
2//!
3//! Нужно ровно для одного: заметить, что условия запуска изменились, и
4//! сделать снимок префикса **до** того, как изменение будет применено.
5//! Смена сборки Wine или применение патча реестра — самые частые способы
6//! сломать работавшую игру, и «откатиться» без снимка означает собирать
7//! префикс заново.
8//!
9//! Лежит в каталоге состояния, а не данных: потеря этого файла ничем не
10//! грозит — в худшем случае лаунчер сделает лишний снимок.
11
12use std::collections::BTreeMap;
13use std::path::Path;
14
15use anyhow::Result;
16use serde::{Deserialize, Serialize};
17
18/// Что игра использовала в прошлый запуск.
19/// Сессия короче минуты — это не игра, а падение на старте или проверка:
20/// в среднюю сессию она не входит.
21pub const MIN_SESSION_SECS: u64 = 60;
22
23#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
24pub struct GameState {
25 /// Сборка Wine прошлого запуска.
26 #[serde(default)]
27 pub wine: String,
28 /// Префикс прошлого запуска.
29 #[serde(default)]
30 pub prefix: String,
31 /// Когда запускали в последний раз — секунды эпохи Unix.
32 #[serde(default)]
33 pub last_run: u64,
34 /// Сколько раз запускали. Полезно, чтобы не снимать снимок на самом
35 /// первом запуске: там ещё нечего терять.
36 #[serde(default)]
37 pub runs: u64,
38 /// Сколько всего наиграно, в секундах.
39 ///
40 /// Считается по времени жизни процесса игры. Для игр, которые запускает
41 /// внешний лончер и сразу отдают управление, число будет заниженным — но
42 /// «примерно столько» полезнее, чем ничего.
43 #[serde(default)]
44 pub played_secs: u64,
45 /// Сколько длился **последний** сеанс, в секундах.
46 ///
47 /// Не то же, что [`Self::played_secs`]: там сумма за всё время, здесь —
48 /// одна последняя сессия. Нужно ряду «Продолжить» в шапке библиотеки:
49 /// на вопрос «во что я вчера играл и сколько просидел» отвечает именно
50 /// длина последнего сеанса, а общий налёт за год — нет.
51 ///
52 /// Ноль у игры с непустым `runs` — законное состояние, а не пропажа
53 /// данных: так выглядят и запуски до появления этого поля, и игры,
54 /// которые запускает внешний лончер и сразу отдаёт управление (там
55 /// процесс живёт секунды). Показывать в таком случае нечего, и подпись
56 /// это учитывает.
57 #[serde(default)]
58 pub last_session_secs: u64,
59 /// Сессии не короче [`MIN_SESSION_SECS`]: сколько их и сколько они
60 /// длились вместе. Из них считается «средняя сессия» на странице
61 /// статистики. По всем запускам среднее выходило «12 с»: его тянули вниз
62 /// мгновенные выходы — падения на старте, проверки и отладка.
63 #[serde(default)]
64 pub long_runs: u64,
65 #[serde(default)]
66 pub long_secs: u64,
67 /// Отпечаток последнего применённого патча реестра: имя и содержимое.
68 ///
69 /// Именно содержимое, а не только имя: патч правят руками, и «тот же
70 /// файл» после правки — уже другой патч. Пустая строка означает, что
71 /// патч не задан.
72 #[serde(default)]
73 pub registry_patch: String,
74 /// Сколько запусков с HDR подряд кончились в первую минуту — так
75 /// «HDR сам» узнаёт, что HDR с этой игрой не работает (см.
76 /// `chl_wine::hdr::verdict_from_runs`). Долгий сеанс с HDR обнуляет.
77 #[serde(default)]
78 pub hdr_short_runs: u32,
79}
80
81/// Состояние всех игр.
82#[derive(Debug, Clone, Default, Serialize, Deserialize)]
83pub struct State {
84 #[serde(default)]
85 pub games: BTreeMap<String, GameState>,
86}
87
88impl State {
89 pub fn load(path: &Path) -> Self {
90 std::fs::read_to_string(path)
91 .ok()
92 .and_then(|t| toml::from_str(&t).ok())
93 .unwrap_or_default()
94 }
95
96 pub fn save(&self, path: &Path) -> Result<()> {
97 let text = toml::to_string_pretty(self)?;
98 crate::paths::write_atomically(path, &text)
99 }
100
101 pub fn get(&self, game: &str) -> Option<&GameState> {
102 self.games.get(game)
103 }
104
105 /// Переносит наигранное и статистику под новое имя — переименование в
106 /// библиотеке ([`crate::library::Library::rename`]) не должно обнулять
107 /// историю игры. Без записи под старым именем — тихий no-op: нечего
108 /// переносить, и это не ошибка.
109 pub fn rename(&mut self, old: &str, new: &str) {
110 if old == new {
111 return;
112 }
113 if let Some(entry) = self.games.remove(old) {
114 self.games.insert(new.to_string(), entry);
115 }
116 }
117
118 /// Сливает историю одной записи в другую и убирает исходную.
119 ///
120 /// Нужно при слиянии дубликатов ([`crate::repair::apply_dedupe`]): две
121 /// записи, оказавшиеся одной игрой, наиграны одним человеком, и часы
122 /// поэтому складываются, а не выбираются — выбрать значило бы стереть
123 /// часть настоящей истории. «Последний запуск» — самый поздний из двух;
124 /// сборка Wine и префикс берутся у той записи, что остаётся, а от
125 /// исходной — только если у остающейся их не было.
126 pub fn merge_into(&mut self, from: &str, into: &str) {
127 if from == into {
128 return;
129 }
130 let Some(gone) = self.games.remove(from) else {
131 return;
132 };
133 let entry = self.games.entry(into.to_string()).or_default();
134 entry.played_secs += gone.played_secs;
135 entry.runs += gone.runs;
136 entry.last_run = entry.last_run.max(gone.last_run);
137 if entry.wine.is_empty() {
138 entry.wine = gone.wine;
139 }
140 if entry.prefix.is_empty() {
141 entry.prefix = gone.prefix;
142 }
143 if entry.registry_patch.is_empty() {
144 entry.registry_patch = gone.registry_patch;
145 }
146 }
147
148 /// Добавляет время, проведённое в игре, и запоминает длину этого сеанса.
149 ///
150 /// Зовётся ровно один раз за запуск — после выхода из игры (см.
151 /// `chl-cli`), поэтому `secs` и есть длина последнего сеанса, а не
152 /// слагаемое посреди него.
153 pub fn add_playtime(&mut self, game: &str, secs: u64) {
154 if let Some(entry) = self.games.get_mut(game) {
155 entry.played_secs += secs;
156 entry.last_session_secs = secs;
157 if secs >= MIN_SESSION_SECS {
158 entry.long_runs += 1;
159 entry.long_secs += secs;
160 }
161 }
162 }
163
164 /// Итог запуска с HDR: короткий сеанс копится, долгий обнуляет счёт.
165 pub fn note_hdr_run(&mut self, game: &str, secs: u64) {
166 if let Some(entry) = self.games.get_mut(game) {
167 entry.hdr_short_runs =
168 if secs < MIN_SESSION_SECS { entry.hdr_short_runs.saturating_add(1) } else { 0 };
169 }
170 }
171
172 /// Отмечает запуск, который сделали не мы: игру запускает Steam, а
173 /// лаунчер только просит его об этом.
174 ///
175 /// Сборку Wine и префикс не трогает намеренно: их выбирает Proton, и
176 /// записать сюда свои значения значило бы соврать логике снимков —
177 /// она сравнивает эти поля, чтобы поймать смену сборки.
178 ///
179 /// Один старт такой игры проходит через две точки: команду
180 /// `steam://rungameid` и слой совместимости, который Steam вызывает
181 /// уже сам. Обе зовут этот метод, поэтому повторный вызов в пределах
182 /// [`EXTERNAL_LAUNCH_WINDOW`] считается тем же самым запуском — иначе
183 /// счётчик рос бы вдвое. Цена — потерянный запуск у того, кто закрыл
184 /// игру и тут же открыл заново; «последний запуск» при этом всё равно
185 /// обновляется, а ряд «Продолжить» смотрит именно на него.
186 pub fn record_external(&mut self, game: &str) {
187 let now = unix_now();
188 let entry = self.games.entry(game.to_string()).or_default();
189 if entry.last_run == 0 || now.saturating_sub(entry.last_run) > EXTERNAL_LAUNCH_WINDOW {
190 entry.runs += 1;
191 }
192 entry.last_run = now;
193 }
194
195 /// Записывает состояние после успешного запуска.
196 pub fn record(&mut self, game: &str, wine: &str, prefix: &str, registry_patch: &str) {
197 let entry = self.games.entry(game.to_string()).or_default();
198 entry.wine = wine.to_string();
199 entry.prefix = prefix.to_string();
200 entry.registry_patch = registry_patch.to_string();
201 entry.runs += 1;
202 entry.last_run = unix_now();
203 }
204}
205
206/// Окно, внутри которого два сообщения о внешнем запуске считаются одним.
207///
208/// Три минуты — с запасом на то, что между командой Steam и настоящим
209/// стартом игры он успевает докачать обновление или показать свой лончер.
210const EXTERNAL_LAUNCH_WINDOW: u64 = 180;
211
212fn unix_now() -> u64 {
213 std::time::SystemTime::now()
214 .duration_since(std::time::UNIX_EPOCH)
215 .map(|d| d.as_secs())
216 .unwrap_or(0)
217}
218
219/// Причина, по которой стоит снять снимок перед запуском.
220#[derive(Debug, Clone, PartialEq, Eq)]
221pub enum SnapshotReason {
222 /// Сборка Wine отличается от прошлого запуска.
223 WineChanged { from: String, to: String },
224 /// Патч реестра появился или изменился с прошлого запуска.
225 ///
226 /// Патч правит реестр префикса необратимо: откатить его, не имея
227 /// снимка, можно только пересборкой префикса.
228 RegistryPatch { name: String },
229 /// Запускается winetricks: ставит и убирает библиотеки и шрифты прямо в
230 /// префиксе, часто необратимо (сам winetricks истории изменений не
231 /// ведёт).
232 Winetricks,
233 /// Открывается служебный инструмент Wine, который правит префикс
234 /// вручную: winecfg (в том числе вкладка Libraries — ручные
235 /// DLL-оверрайды, в отличие от настройки `dll_overrides`, которая живёт
236 /// только в переменной окружения и префикс не трогает), regedit,
237 /// uninstaller, cmd.
238 PrefixTool { tool: String },
239}
240
241impl SnapshotReason {
242 /// Метка снимка.
243 pub fn label(&self) -> String {
244 match self {
245 SnapshotReason::WineChanged { from, .. } => format!("до смены Wine с {from}"),
246 SnapshotReason::RegistryPatch { name } => format!("до патча реестра {name}"),
247 SnapshotReason::Winetricks => "до winetricks".to_string(),
248 SnapshotReason::PrefixTool { tool } => format!("до {tool}"),
249 }
250 }
251
252 /// Объяснение для человека.
253 pub fn explain(&self) -> String {
254 match self {
255 SnapshotReason::WineChanged { from, to } => format!(
256 "сборка Wine меняется с {from} на {to} — делаю снимок префикса, \
257 чтобы можно было вернуться"
258 ),
259 SnapshotReason::RegistryPatch { name } => format!(
260 "патч реестра {name} новый или изменился с прошлого запуска — \
261 делаю снимок префикса, чтобы можно было вернуться"
262 ),
263 SnapshotReason::Winetricks => "запускается winetricks — он ставит и убирает \
264 библиотеки прямо в префиксе, часто необратимо — делаю снимок \
265 префикса, чтобы можно было вернуться"
266 .to_string(),
267 SnapshotReason::PrefixTool { tool } => format!(
268 "открывается {tool} — он умеет менять префикс вручную — делаю \
269 снимок префикса, чтобы можно было вернуться"
270 ),
271 }
272 }
273}
274
275/// Начала меток, которые лончер ставит снимкам сам.
276///
277/// Список ровно тот, что рождает [`SnapshotReason::label`] — второй копии
278/// правды нет, и тест `все_метки_автоснимков_узнаются` это сторожит. Нужен
279/// он уборке снимков: она удаляет только автоматические, а снятый человеком
280/// не трогает никогда. Метки снимков, снятых до появления поля `origin` в
281/// `.chl-snapshot`, узнаются только так, по началу строки, поэтому здесь
282/// перечислены целые начала («до смены Wine с »), а не одно слово «до»:
283/// ручной снимок с меткой «до поездки» под правило попадать не должен.
284pub const AUTOMATIC_LABEL_PREFIXES: &[&str] = &[
285 "до смены Wine с ",
286 "до патча реестра ",
287 "до winetricks",
288 "до winecfg",
289 "до regedit",
290 "до uninstaller",
291 "до cmd",
292 // `chl deps --install`: без этой строки снимок считался ручным и не
293 // убирался политикой хранения никогда.
294 "до установки пакетов",
295 "автобэкап сохранений",
296];
297
298/// Похожа ли метка на ту, что лончер ставит сам.
299pub fn is_automatic_label(label: &str) -> bool {
300 AUTOMATIC_LABEL_PREFIXES.iter().any(|p| label.starts_with(p))
301}
302
303/// Нужен ли снимок перед тем, как открыть служебный инструмент Wine в
304/// префиксе (`chl tool …`, кнопки «Инструменты префикса» на странице игры).
305///
306/// В отличие от [`snapshot_needed`], здесь не с чем сравнить «было — стало»:
307/// такие инструменты открывают не на каждом запуске игры, а по явному
308/// действию человека, и снимок делается каждый раз, когда инструмент
309/// способен поменять префикс — открытие не настолько частое действие, чтобы
310/// экономить на нём снимками.
311///
312/// `explorer` намеренно не входит: это просто файловый менеджер, открытый на
313/// каталоге префикса — тот же риск, что и уже существующая кнопка «Открыть
314/// префикс» на странице игры, перед которой снимок никогда не делался.
315pub fn snapshot_before_tool(tool: &str) -> Option<SnapshotReason> {
316 match tool {
317 "winetricks" => Some(SnapshotReason::Winetricks),
318 "winecfg" | "regedit" | "uninstaller" | "cmd" => {
319 Some(SnapshotReason::PrefixTool { tool: tool.to_string() })
320 }
321 _ => None,
322 }
323}
324
325/// Нужен ли снимок перед этим запуском.
326///
327/// Снимок делается **только при изменении условий** и только если игра уже
328/// запускалась: на первом запуске терять нечего, а снимать префикс при
329/// каждом старте значило бы засорять диск и раздражать.
330pub fn snapshot_needed(
331 state: Option<&GameState>,
332 wine: &str,
333 prefix: &str,
334 registry_patch: &str,
335) -> Option<SnapshotReason> {
336 let prev = state?;
337 if prev.runs == 0 {
338 return None;
339 }
340 // Префикс другой — это другая «установка Windows», и снимать текущую
341 // незачем: изменение её не коснётся.
342 if prev.prefix != prefix {
343 return None;
344 }
345 if !prev.wine.is_empty() && prev.wine != wine {
346 return Some(SnapshotReason::WineChanged {
347 from: prev.wine.clone(),
348 to: wine.to_string(),
349 });
350 }
351 // Патч реестра правит префикс необратимо. Снимаем, когда он появился
352 // или изменился, а не при каждом запуске: применение того же патча
353 // второй раз ничего нового не делает.
354 if !registry_patch.is_empty() && prev.registry_patch != registry_patch {
355 return Some(SnapshotReason::RegistryPatch {
356 name: patch_name(registry_patch),
357 });
358 }
359 None
360}
361
362/// Отпечаток патча реестра: имя файла и содержимое.
363///
364/// Содержимое учитывается, потому что патч правят руками, и «тот же файл»
365/// после правки — уже другой патч, который стоит снять до применения.
366pub fn patch_fingerprint(name: &str, path: &std::path::Path) -> String {
367 let Ok(bytes) = std::fs::read(path) else {
368 return String::new();
369 };
370 // FNV-1a: нам нужна не криптостойкость, а «изменилось или нет».
371 let mut hash: u64 = 0xcbf2_9ce4_8422_2325;
372 for b in &bytes {
373 hash ^= u64::from(*b);
374 hash = hash.wrapping_mul(0x1000_0000_01b3);
375 }
376 format!("{name}:{hash:016x}")
377}
378
379fn patch_name(fingerprint: &str) -> String {
380 fingerprint
381 .rsplit_once(':')
382 .map_or_else(|| fingerprint.to_string(), |(name, _)| name.to_string())
383}
384
385#[cfg(test)]
386mod tests {
387 #[test]
388 fn средняя_сессия_без_мгновенных_выходов() {
389 let mut st = State::default();
390 st.record("G", "w", "p", "");
391 st.add_playtime("G", 3);
392 st.record("G", "w", "p", "");
393 st.add_playtime("G", 600);
394 st.record("G", "w", "p", "");
395 st.add_playtime("G", 1200);
396 let g = st.get("G").unwrap();
397 assert_eq!((g.runs, g.played_secs), (3, 1803));
398 assert_eq!((g.long_runs, g.long_secs), (2, 1800));
399 }
400
401 use super::*;
402
403 fn state(wine: &str, prefix: &str, runs: u64) -> GameState {
404 GameState {
405 wine: wine.into(),
406 prefix: prefix.into(),
407 runs,
408 last_run: 0,
409 played_secs: 0,
410 last_session_secs: 0,
411 long_runs: 0,
412 long_secs: 0,
413 registry_patch: String::new(),
414 hdr_short_runs: 0,
415 }
416 }
417
418 #[test]
419 fn переименование_переносит_историю_под_новое_имя() {
420 let mut st = State::default();
421 st.games.insert("Старое".to_string(), state("wine-11", "pfx_default", 5));
422 st.rename("Старое", "Новое");
423 assert!(st.get("Старое").is_none());
424 assert_eq!(st.get("Новое").unwrap().runs, 5);
425 }
426
427 #[test]
428 fn переименование_без_записи_ничего_не_делает() {
429 let mut st = State::default();
430 st.rename("Нет-такой", "Тоже-нет");
431 assert!(st.games.is_empty());
432 }
433
434 #[test]
435 fn на_первом_запуске_снимок_не_нужен() {
436 assert_eq!(snapshot_needed(None, "wine-11", "pfx_default", ""), None);
437 let s = state("", "pfx_default", 0);
438 assert_eq!(snapshot_needed(Some(&s), "wine-11", "pfx_default", ""), None);
439 }
440
441 #[test]
442 fn без_изменений_снимок_не_нужен() {
443 let s = state("wine-11", "pfx_default", 5);
444 assert_eq!(snapshot_needed(Some(&s), "wine-11", "pfx_default", ""), None);
445 }
446
447 #[test]
448 fn смена_сборки_wine_требует_снимка() {
449 let s = state("wine-11", "pfx_default", 5);
450 let reason = snapshot_needed(Some(&s), "GE-Proton10-34", "pfx_default", "").unwrap();
451 assert!(reason.label().contains("wine-11"));
452 assert!(reason.explain().contains("GE-Proton10-34"));
453 }
454
455 #[test]
456 fn другой_префикс_не_повод_снимать_текущий() {
457 // Изменение не коснётся префикса, снимок которого мы бы сделали.
458 let s = state("wine-11", "pfx_default", 5);
459 assert_eq!(snapshot_needed(Some(&s), "GE-Proton10-34", "pfx_игра", ""), None);
460 }
461
462 #[test]
463 fn наигранное_время_копится() {
464 let mut s = State::default();
465 s.record("Игра", "wine-11", "pfx_default", "");
466 s.add_playtime("Игра", 600);
467 s.record("Игра", "wine-11", "pfx_default", "");
468 s.add_playtime("Игра", 300);
469 assert_eq!(s.get("Игра").unwrap().played_secs, 900);
470 // Общий налёт копится, а длина последнего сеанса — заменяется:
471 // ряд «Продолжить» показывает «сколько играл в прошлый раз», а не
472 // сумму за всё время.
473 assert_eq!(s.get("Игра").unwrap().last_session_secs, 300);
474 // Незнакомой игре время не приписываем.
475 s.add_playtime("Другая", 100);
476 assert!(s.get("Другая").is_none());
477 }
478
479 #[test]
480 fn длина_сеанса_читается_из_старого_файла_как_ноль() {
481 // Поле появилось позже самого runs.toml: у записей, сделанных до
482 // него, его в файле нет — это ноль, а не отказ читать файл.
483 let old = "[games.\"Игра\"]\nlast_run = 100\nruns = 3\nplayed_secs = 7200\n";
484 let st: State = toml::from_str(old).unwrap();
485 let g = st.get("Игра").unwrap();
486 assert_eq!(g.played_secs, 7200);
487 assert_eq!(g.last_session_secs, 0);
488 }
489
490 #[test]
491 fn запись_и_чтение() {
492 let d = std::env::temp_dir().join("chl-test-state");
493 std::fs::remove_dir_all(&d).ok();
494 let p = d.join("state.toml");
495
496 let mut s = State::default();
497 s.record("Игра", "wine-11", "pfx_default", "");
498 s.record("Игра", "wine-11", "pfx_default", "");
499 s.save(&p).unwrap();
500
501 let back = State::load(&p);
502 let g = back.get("Игра").unwrap();
503 assert_eq!(g.runs, 2);
504 assert_eq!(g.wine, "wine-11");
505 assert!(g.last_run > 0);
506 std::fs::remove_dir_all(&d).ok();
507 }
508
509 #[test]
510 fn новый_патч_реестра_требует_снимка() {
511 // Патч правит реестр префикса необратимо: без снимка откатить его
512 // можно только пересборкой префикса.
513 let s = state("wine-11", "pfx_default", 5);
514 let reason =
515 snapshot_needed(Some(&s), "wine-11", "pfx_default", "fix.reg:abc").unwrap();
516 assert!(reason.label().contains("fix.reg"), "{}", reason.label());
517 assert!(!reason.explain().contains("abc"), "хеш человеку не нужен");
518 }
519
520 #[test]
521 fn тот_же_патч_второй_раз_снимка_не_требует() {
522 let mut s = state("wine-11", "pfx_default", 5);
523 s.registry_patch = "fix.reg:abc".into();
524 assert_eq!(
525 snapshot_needed(Some(&s), "wine-11", "pfx_default", "fix.reg:abc"),
526 None
527 );
528 // А правка того же файла — уже другой патч.
529 assert!(
530 snapshot_needed(Some(&s), "wine-11", "pfx_default", "fix.reg:xyz").is_some(),
531 "изменённый патч должен снова требовать снимка"
532 );
533 }
534
535 #[test]
536 fn отпечаток_меняется_вместе_с_файлом() {
537 let d = std::env::temp_dir().join("chl-test-patch-fp");
538 std::fs::create_dir_all(&d).unwrap();
539 let p = d.join("fix.reg");
540 std::fs::write(&p, "первое").unwrap();
541 let a = patch_fingerprint("fix.reg", &p);
542 std::fs::write(&p, "второе").unwrap();
543 let b = patch_fingerprint("fix.reg", &p);
544 assert_ne!(a, b, "правка файла должна менять отпечаток");
545 assert!(a.starts_with("fix.reg:"));
546 assert!(patch_fingerprint("нет", &d.join("нет")).is_empty());
547 std::fs::remove_dir_all(&d).ok();
548 }
549
550 #[test]
551 fn winetricks_и_редакторы_реестра_требуют_снимка() {
552 for tool in ["winetricks", "winecfg", "regedit", "uninstaller", "cmd"] {
553 assert!(
554 snapshot_before_tool(tool).is_some(),
555 "{tool} должен требовать снимка"
556 );
557 }
558 }
559
560 #[test]
561 fn explorer_снимка_не_требует() {
562 // Файловый менеджер на префиксе — не опаснее уже существующей
563 // кнопки «Открыть префикс», перед которой снимок никогда не делался.
564 assert_eq!(snapshot_before_tool("explorer"), None);
565 assert_eq!(snapshot_before_tool("неизвестный-инструмент"), None);
566 }
567
568 #[test]
569 fn причины_для_инструментов_объяснены_человеку() {
570 let reason = snapshot_before_tool("winetricks").unwrap();
571 assert_eq!(reason.label(), "до winetricks");
572 assert!(reason.explain().contains("winetricks"));
573
574 let reason = snapshot_before_tool("regedit").unwrap();
575 assert_eq!(reason.label(), "до regedit");
576 assert!(reason.explain().contains("regedit"));
577 }
578
579 #[test]
580 fn все_метки_автоснимков_узнаются() {
581 // Уборка снимков решает по метке, автоматический снимок перед ней
582 // или снятый человеком. Разойдись этот список с `label()` — уборка
583 // перестанет видеть свои же снимки и накопит их снова.
584 let reasons = [
585 SnapshotReason::WineChanged { from: "wine-11".into(), to: "GE-Proton10-34".into() },
586 SnapshotReason::RegistryPatch { name: "ags.reg".into() },
587 SnapshotReason::Winetricks,
588 SnapshotReason::PrefixTool { tool: "winecfg".into() },
589 SnapshotReason::PrefixTool { tool: "regedit".into() },
590 SnapshotReason::PrefixTool { tool: "uninstaller".into() },
591 SnapshotReason::PrefixTool { tool: "cmd".into() },
592 ];
593 for reason in reasons {
594 let label = reason.label();
595 assert!(is_automatic_label(&label), "метка {label:?} должна узнаваться");
596 }
597 }
598
599 #[test]
600 fn ручные_метки_за_автоматические_не_принимаются() {
601 assert!(!is_automatic_label("вручную"));
602 assert!(!is_automatic_label("бэкап"));
603 // Начало «до » само по себе ничего не значит: человек тоже вправе
604 // назвать снимок «до чего-то».
605 assert!(!is_automatic_label("до поездки"));
606 assert!(!is_automatic_label("до установки мода"));
607 }
608
609 #[test]
610 fn запуск_через_steam_попадает_в_последние() {
611 // Без этой записи игра из Steam никогда не появлялась в ряду
612 // «Продолжить»: он строится по `last_run`, а его ставил только наш
613 // собственный запуск.
614 let mut st = State::default();
615 st.record_external("Helldivers 2");
616 let entry = st.get("Helldivers 2").unwrap();
617 assert_eq!(entry.runs, 1);
618 assert!(entry.last_run > 0);
619 // Сборку Wine и префикс выбирает Proton — врать о них нельзя.
620 assert!(entry.wine.is_empty());
621 assert!(entry.prefix.is_empty());
622 }
623
624 #[test]
625 fn один_старт_через_две_точки_считается_одним_запуском() {
626 // Команда `steam://rungameid` и слой совместимости сообщают об
627 // одном и том же старте. Считать их за два — завысить статистику
628 // ровно вдвое у всех игр Steam.
629 let mut st = State::default();
630 st.record_external("Helldivers 2");
631 st.record_external("Helldivers 2");
632 assert_eq!(st.get("Helldivers 2").unwrap().runs, 1);
633 }
634
635 #[test]
636 fn старый_запуск_окно_не_склеивает() {
637 let mut st = State::default();
638 st.record_external("Helldivers 2");
639 // Сеанс закончился давно — следующий старт обязан считаться новым.
640 st.games.get_mut("Helldivers 2").unwrap().last_run -= EXTERNAL_LAUNCH_WINDOW + 1;
641 st.record_external("Helldivers 2");
642 assert_eq!(st.get("Helldivers 2").unwrap().runs, 2);
643 }
644
645 #[test]
646 fn битый_файл_не_ломает_запуск() {
647 let d = std::env::temp_dir().join("chl-test-state2");
648 std::fs::create_dir_all(&d).unwrap();
649 let p = d.join("state.toml");
650 std::fs::write(&p, "не toml {{{").unwrap();
651 assert!(State::load(&p).games.is_empty());
652 std::fs::remove_dir_all(&d).ok();
653 }
654
655 #[test]
656 fn короткие_запуски_с_hdr_копятся_долгий_обнуляет() {
657 let mut st = State::default();
658 st.record("Игра", "w", "p", "");
659 st.note_hdr_run("Игра", 10);
660 st.note_hdr_run("Игра", 20);
661 assert_eq!(st.get("Игра").unwrap().hdr_short_runs, 2);
662 st.note_hdr_run("Игра", MIN_SESSION_SECS + 1);
663 assert_eq!(st.get("Игра").unwrap().hdr_short_runs, 0);
664 }
665}
666