bwc9876.dev
Live location tracking and playback for the game "manhunt"
Better testing, better transport handling
+4
.rustfmt.toml
+4
.rustfmt.toml
+109
-115
Cargo.lock
+109
-115
Cargo.lock
···
540
"http-body-util",
541
"hyper",
542
"hyper-util",
543
-
"itoa 1.0.15",
544
"matchit",
545
"memchr",
546
"mime",
···
730
731
[[package]]
732
name = "brotli"
733
-
version = "7.0.0"
734
source = "registry+https://github.com/rust-lang/crates.io-index"
735
-
checksum = "cc97b8f16f944bba54f0433f07e30be199b6dc2bd25937444bbad560bcea29bd"
736
dependencies = [
737
"alloc-no-stdlib",
738
"alloc-stdlib",
···
741
742
[[package]]
743
name = "brotli-decompressor"
744
-
version = "4.0.3"
745
source = "registry+https://github.com/rust-lang/crates.io-index"
746
-
checksum = "a334ef7c9e23abf0ce748e8cd309037da93e606ad52eb372e4ce327a0dcfbdfd"
747
dependencies = [
748
"alloc-no-stdlib",
749
"alloc-stdlib",
···
751
752
[[package]]
753
name = "bumpalo"
754
-
version = "3.18.1"
755
source = "registry+https://github.com/rust-lang/crates.io-index"
756
-
checksum = "793db76d6187cd04dff33004d8e6c9cc4e05cd330500379d2394209271b4aeee"
757
758
[[package]]
759
name = "byte-unit"
···
1167
1168
[[package]]
1169
name = "cssparser"
1170
-
version = "0.27.2"
1171
source = "registry+https://github.com/rust-lang/crates.io-index"
1172
-
checksum = "754b69d351cdc2d8ee09ae203db831e005560fc6030da058f86ad60c92a9cb0a"
1173
dependencies = [
1174
"cssparser-macros",
1175
"dtoa-short",
1176
-
"itoa 0.4.8",
1177
"matches",
1178
-
"phf 0.8.0",
1179
"proc-macro2",
1180
"quote",
1181
"smallvec",
···
2243
"futures-core",
2244
"futures-sink",
2245
"http",
2246
-
"indexmap 2.9.0",
2247
"slab",
2248
"tokio",
2249
"tokio-util",
···
2309
2310
[[package]]
2311
name = "html5ever"
2312
-
version = "0.26.0"
2313
source = "registry+https://github.com/rust-lang/crates.io-index"
2314
-
checksum = "bea68cab48b8459f17cf1c944c67ddc572d272d9f2b274140f223ecb1da4a3b7"
2315
dependencies = [
2316
"log",
2317
"mac",
2318
"markup5ever",
2319
-
"proc-macro2",
2320
-
"quote",
2321
-
"syn 1.0.109",
2322
]
2323
2324
[[package]]
···
2329
dependencies = [
2330
"bytes",
2331
"fnv",
2332
-
"itoa 1.0.15",
2333
]
2334
2335
[[package]]
···
2381
"http-body",
2382
"httparse",
2383
"httpdate",
2384
-
"itoa 1.0.15",
2385
"pin-project-lite",
2386
"smallvec",
2387
"tokio",
···
2591
2592
[[package]]
2593
name = "indexmap"
2594
-
version = "2.9.0"
2595
source = "registry+https://github.com/rust-lang/crates.io-index"
2596
-
checksum = "cea70ddb795996207ad57735b50c5982d8844f38ba9ee5f1aedcfb708a2aa11e"
2597
dependencies = [
2598
"equivalent",
2599
"hashbrown 0.15.4",
···
2682
2683
[[package]]
2684
name = "itoa"
2685
-
version = "0.4.8"
2686
-
source = "registry+https://github.com/rust-lang/crates.io-index"
2687
-
checksum = "b71991ff56294aa922b450139ee08b3bfc70982c6b2c7562771375cf73542dd4"
2688
-
2689
-
[[package]]
2690
-
name = "itoa"
2691
version = "1.0.15"
2692
source = "registry+https://github.com/rust-lang/crates.io-index"
2693
checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
···
2806
2807
[[package]]
2808
name = "kuchikiki"
2809
-
version = "0.8.2"
2810
source = "registry+https://github.com/rust-lang/crates.io-index"
2811
-
checksum = "f29e4755b7b995046f510a7520c42b2fed58b77bd94d5a87a8eb43d2fd126da8"
2812
dependencies = [
2813
"cssparser",
2814
"html5ever",
2815
-
"indexmap 1.9.3",
2816
-
"matches",
2817
"selectors",
2818
]
2819
···
2874
2875
[[package]]
2876
name = "libredox"
2877
-
version = "0.1.3"
2878
source = "registry+https://github.com/rust-lang/crates.io-index"
2879
-
checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d"
2880
dependencies = [
2881
"bitflags 2.9.1",
2882
"libc",
···
2974
"serde",
2975
"specta",
2976
"tokio",
2977
"uuid",
2978
]
2979
···
3014
3015
[[package]]
3016
name = "markup5ever"
3017
-
version = "0.11.0"
3018
source = "registry+https://github.com/rust-lang/crates.io-index"
3019
-
checksum = "7a2629bb1404f3d34c2e921f21fd34ba00b206124c81f65c50b43b6aaefeb016"
3020
dependencies = [
3021
"log",
3022
-
"phf 0.10.1",
3023
-
"phf_codegen 0.10.0",
3024
"string_cache",
3025
"string_cache_codegen",
3026
"tendril",
3027
]
3028
3029
[[package]]
3030
name = "matchbox_protocol"
3031
version = "0.12.0"
3032
source = "registry+https://github.com/rust-lang/crates.io-index"
···
3173
3174
[[package]]
3175
name = "muda"
3176
-
version = "0.16.1"
3177
source = "registry+https://github.com/rust-lang/crates.io-index"
3178
-
checksum = "4de14a9b5d569ca68d7c891d613b390cf5ab4f851c77aaa2f9e435555d3d9492"
3179
dependencies = [
3180
"crossbeam-channel",
3181
"dpi",
···
3758
source = "registry+https://github.com/rust-lang/crates.io-index"
3759
checksum = "3dfb61232e34fcb633f43d12c58f83c1df82962dcdfa565a4e866ffc17dafe12"
3760
dependencies = [
3761
-
"phf_macros 0.8.0",
3762
"phf_shared 0.8.0",
3763
-
"proc-macro-hack",
3764
]
3765
3766
[[package]]
···
3769
source = "registry+https://github.com/rust-lang/crates.io-index"
3770
checksum = "fabbf1ead8a5bcbc20f5f8b939ee3f5b0f6f281b6ad3468b84656b658b455259"
3771
dependencies = [
3772
"phf_shared 0.10.0",
3773
]
3774
3775
[[package]]
···
3794
3795
[[package]]
3796
name = "phf_codegen"
3797
-
version = "0.10.0"
3798
source = "registry+https://github.com/rust-lang/crates.io-index"
3799
-
checksum = "4fb1c3a8bc4dd4e5cfce29b44ffc14bedd2ee294559a294e2a4d4c9e9a6a13cd"
3800
dependencies = [
3801
-
"phf_generator 0.10.0",
3802
-
"phf_shared 0.10.0",
3803
]
3804
3805
[[package]]
···
3834
3835
[[package]]
3836
name = "phf_macros"
3837
-
version = "0.8.0"
3838
source = "registry+https://github.com/rust-lang/crates.io-index"
3839
-
checksum = "7f6fde18ff429ffc8fe78e2bf7f8b7a5a5a6e2a8b58bc5a9ac69198bbda9189c"
3840
dependencies = [
3841
-
"phf_generator 0.8.0",
3842
-
"phf_shared 0.8.0",
3843
"proc-macro-hack",
3844
"proc-macro2",
3845
"quote",
···
3932
checksum = "3d77244ce2d584cd84f6a15f86195b8c9b2a0dfbfd817c09e0464244091a58ed"
3933
dependencies = [
3934
"base64 0.22.1",
3935
-
"indexmap 2.9.0",
3936
"quick-xml",
3937
"serde",
3938
"time",
···
4817
4818
[[package]]
4819
name = "selectors"
4820
-
version = "0.22.0"
4821
source = "registry+https://github.com/rust-lang/crates.io-index"
4822
-
checksum = "df320f1889ac4ba6bc0cdc9c9af7af4bd64bb927bccdf32d81140dc1f9be12fe"
4823
dependencies = [
4824
"bitflags 1.3.2",
4825
"cssparser",
4826
"derive_more 0.99.20",
4827
"fxhash",
4828
"log",
4829
-
"matches",
4830
"phf 0.8.0",
4831
"phf_codegen 0.8.0",
4832
"precomputed-hash",
4833
"servo_arc",
4834
"smallvec",
4835
-
"thin-slice",
4836
]
4837
4838
[[package]]
···
4915
source = "registry+https://github.com/rust-lang/crates.io-index"
4916
checksum = "20068b6e96dc6c9bd23e01df8827e6c7e1f2fddd43c21810382803c136b99373"
4917
dependencies = [
4918
-
"itoa 1.0.15",
4919
"memchr",
4920
"ryu",
4921
"serde",
···
4927
source = "registry+https://github.com/rust-lang/crates.io-index"
4928
checksum = "59fab13f937fa393d08645bf3a84bdfe86e296747b506ada67bb15f10f218b2a"
4929
dependencies = [
4930
-
"itoa 1.0.15",
4931
"serde",
4932
]
4933
···
4958
checksum = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd"
4959
dependencies = [
4960
"form_urlencoded",
4961
-
"itoa 1.0.15",
4962
"ryu",
4963
"serde",
4964
]
···
4973
"chrono",
4974
"hex",
4975
"indexmap 1.9.3",
4976
-
"indexmap 2.9.0",
4977
"schemars 0.9.0",
4978
"serde",
4979
"serde_derive",
···
5018
5019
[[package]]
5020
name = "servo_arc"
5021
-
version = "0.1.1"
5022
source = "registry+https://github.com/rust-lang/crates.io-index"
5023
-
checksum = "d98238b800e0d1576d8b6e3de32827c2d74bee68bb97748dcf5071fb53965432"
5024
dependencies = [
5025
"nodrop",
5026
"stable_deref_trait",
···
5399
5400
[[package]]
5401
name = "tao"
5402
-
version = "0.33.0"
5403
source = "registry+https://github.com/rust-lang/crates.io-index"
5404
-
checksum = "1e59c1f38e657351a2e822eadf40d6a2ad4627b9c25557bc1180ec1b3295ef82"
5405
dependencies = [
5406
"bitflags 2.9.1",
5407
"core-foundation 0.10.1",
···
5461
5462
[[package]]
5463
name = "tauri"
5464
-
version = "2.5.1"
5465
source = "registry+https://github.com/rust-lang/crates.io-index"
5466
-
checksum = "e7b0bc1aec81bda6bc455ea98fcaed26b3c98c1648c627ad6ff1c704e8bf8cbc"
5467
dependencies = [
5468
"anyhow",
5469
"bytes",
5470
"dirs",
5471
"dunce",
5472
"embed_plist",
5473
-
"futures-util",
5474
-
"getrandom 0.2.16",
5475
"glob",
5476
"gtk",
5477
"heck 0.5.0",
···
5513
5514
[[package]]
5515
name = "tauri-build"
5516
-
version = "2.2.0"
5517
source = "registry+https://github.com/rust-lang/crates.io-index"
5518
-
checksum = "d7a0350f0df1db385ca5c02888a83e0e66655c245b7443db8b78a70da7d7f8fc"
5519
dependencies = [
5520
"anyhow",
5521
"cargo_toml",
···
5535
5536
[[package]]
5537
name = "tauri-codegen"
5538
-
version = "2.2.0"
5539
source = "registry+https://github.com/rust-lang/crates.io-index"
5540
-
checksum = "f93f035551bf7b11b3f51ad9bc231ebbe5e085565527991c16cf326aa38cdf47"
5541
dependencies = [
5542
"base64 0.22.1",
5543
"brotli",
···
5562
5563
[[package]]
5564
name = "tauri-macros"
5565
-
version = "2.2.0"
5566
source = "registry+https://github.com/rust-lang/crates.io-index"
5567
-
checksum = "8db4df25e2d9d45de0c4c910da61cd5500190da14ae4830749fee3466dddd112"
5568
dependencies = [
5569
"heck 0.5.0",
5570
"proc-macro2",
···
5576
5577
[[package]]
5578
name = "tauri-plugin"
5579
-
version = "2.2.0"
5580
source = "registry+https://github.com/rust-lang/crates.io-index"
5581
-
checksum = "37a5ebe6a610d1b78a94650896e6f7c9796323f408800cef436e0fa0539de601"
5582
dependencies = [
5583
"anyhow",
5584
"glob",
···
5593
5594
[[package]]
5595
name = "tauri-plugin-dialog"
5596
-
version = "2.2.2"
5597
source = "registry+https://github.com/rust-lang/crates.io-index"
5598
-
checksum = "a33318fe222fc2a612961de8b0419e2982767f213f54a4d3a21b0d7b85c41df8"
5599
dependencies = [
5600
"log",
5601
"raw-window-handle",
···
5611
5612
[[package]]
5613
name = "tauri-plugin-fs"
5614
-
version = "2.3.0"
5615
source = "registry+https://github.com/rust-lang/crates.io-index"
5616
-
checksum = "33ead0daec5d305adcefe05af9d970fc437bcc7996052d564e7393eb291252da"
5617
dependencies = [
5618
"anyhow",
5619
"dunce",
···
5633
5634
[[package]]
5635
name = "tauri-plugin-geolocation"
5636
-
version = "2.2.5"
5637
source = "registry+https://github.com/rust-lang/crates.io-index"
5638
-
checksum = "3dc06e23cb12d17533aca6001252f7f0fdbd295868194748821d0f0e6fbfbb59"
5639
dependencies = [
5640
"log",
5641
"serde",
···
5647
5648
[[package]]
5649
name = "tauri-plugin-log"
5650
-
version = "2.5.0"
5651
source = "registry+https://github.com/rust-lang/crates.io-index"
5652
-
checksum = "1063890b541877c4367d0ee9b1758360d86398862fbaafdd99aac02a55e28bf8"
5653
dependencies = [
5654
"android_logger",
5655
"byte-unit",
···
5669
5670
[[package]]
5671
name = "tauri-plugin-notification"
5672
-
version = "2.2.3"
5673
source = "registry+https://github.com/rust-lang/crates.io-index"
5674
-
checksum = "d1c87f171cdb35c3aa8f17e8dfd84c1b9f68eb4086ec16a5a1b9f13b5541c574"
5675
dependencies = [
5676
"log",
5677
"notify-rust",
···
5688
5689
[[package]]
5690
name = "tauri-plugin-opener"
5691
-
version = "2.3.0"
5692
source = "registry+https://github.com/rust-lang/crates.io-index"
5693
-
checksum = "2c8983f50326d34437142a6d560b5c3426e91324297519b6eeb32ed0a1d1e0f2"
5694
dependencies = [
5695
"dunce",
5696
"glob",
···
5710
5711
[[package]]
5712
name = "tauri-plugin-store"
5713
-
version = "2.2.1"
5714
source = "registry+https://github.com/rust-lang/crates.io-index"
5715
-
checksum = "ada7e7aeea472dec9b8d09d25301e59fe3e8330dc11dbcf903d6388126cb3722"
5716
dependencies = [
5717
"dunce",
5718
"serde",
···
5726
5727
[[package]]
5728
name = "tauri-runtime"
5729
-
version = "2.6.0"
5730
source = "registry+https://github.com/rust-lang/crates.io-index"
5731
-
checksum = "00f004905d549854069e6774533d742b03cacfd6f03deb08940a8677586cbe39"
5732
dependencies = [
5733
"cookie",
5734
"dpi",
···
5748
5749
[[package]]
5750
name = "tauri-runtime-wry"
5751
-
version = "2.6.0"
5752
source = "registry+https://github.com/rust-lang/crates.io-index"
5753
-
checksum = "f85d056f4d4b014fe874814034f3416d57114b617a493a4fe552580851a3f3a2"
5754
dependencies = [
5755
"gtk",
5756
"http",
···
5803
5804
[[package]]
5805
name = "tauri-utils"
5806
-
version = "2.4.0"
5807
source = "registry+https://github.com/rust-lang/crates.io-index"
5808
-
checksum = "b2900399c239a471bcff7f15c4399eb1a8c4fe511ba2853e07c996d771a5e0a4"
5809
dependencies = [
5810
"anyhow",
5811
"brotli",
···
5846
checksum = "e8d321dbc6f998d825ab3f0d62673e810c861aac2d0de2cc2c395328f1d113b4"
5847
dependencies = [
5848
"embed-resource",
5849
-
"indexmap 2.9.0",
5850
"toml",
5851
]
5852
···
5885
"mac",
5886
"utf-8",
5887
]
5888
-
5889
-
[[package]]
5890
-
name = "thin-slice"
5891
-
version = "0.1.1"
5892
-
source = "registry+https://github.com/rust-lang/crates.io-index"
5893
-
checksum = "8eaa81235c7058867fa8c0e7314f33dcce9c215f535d1913822a2b3f5e289f3c"
5894
5895
[[package]]
5896
name = "thiserror"
···
5939
checksum = "8a7619e19bc266e0f9c5e6686659d394bc57973859340060a69221e57dbc0c40"
5940
dependencies = [
5941
"deranged",
5942
-
"itoa 1.0.15",
5943
"libc",
5944
"num-conv",
5945
"num_threads",
···
6094
source = "registry+https://github.com/rust-lang/crates.io-index"
6095
checksum = "1b5bb770da30e5cbfde35a2d7b9b8a2c4b8ef89548a7a6aeab5c9a576e3e7421"
6096
dependencies = [
6097
-
"indexmap 2.9.0",
6098
"toml_datetime",
6099
"winnow 0.5.40",
6100
]
···
6105
source = "registry+https://github.com/rust-lang/crates.io-index"
6106
checksum = "70f427fce4d84c72b5b732388bf4a9f4531b53f74e2887e3ecb2481f68f66d81"
6107
dependencies = [
6108
-
"indexmap 2.9.0",
6109
"toml_datetime",
6110
"winnow 0.5.40",
6111
]
···
6116
source = "registry+https://github.com/rust-lang/crates.io-index"
6117
checksum = "41fe8c660ae4257887cf66394862d21dbca4a6ddd26f04a3560410406a2f819a"
6118
dependencies = [
6119
-
"indexmap 2.9.0",
6120
"serde",
6121
"serde_spanned",
6122
"toml_datetime",
···
6211
6212
[[package]]
6213
name = "tray-icon"
6214
-
version = "0.20.1"
6215
source = "registry+https://github.com/rust-lang/crates.io-index"
6216
-
checksum = "9f7eee98ec5c90daf179d55c20a49d8c0d043054ce7c26336c09a24d31f14fa0"
6217
dependencies = [
6218
"crossbeam-channel",
6219
"dirs",
···
6907
6908
[[package]]
6909
name = "webview2-com"
6910
-
version = "0.37.0"
6911
source = "registry+https://github.com/rust-lang/crates.io-index"
6912
-
checksum = "b542b5cfbd9618c46c2784e4d41ba218c336ac70d44c55e47b251033e7d85601"
6913
dependencies = [
6914
"webview2-com-macros",
6915
"webview2-com-sys",
···
6932
6933
[[package]]
6934
name = "webview2-com-sys"
6935
-
version = "0.37.0"
6936
source = "registry+https://github.com/rust-lang/crates.io-index"
6937
-
checksum = "8ae2d11c4a686e4409659d7891791254cf9286d3cfe0eef54df1523533d22295"
6938
dependencies = [
6939
"thiserror 2.0.12",
6940
"windows",
···
7073
7074
[[package]]
7075
name = "windows-registry"
7076
-
version = "0.5.2"
7077
source = "registry+https://github.com/rust-lang/crates.io-index"
7078
-
checksum = "b3bab093bdd303a1240bb99b8aba8ea8a69ee19d34c9e2ef9594e708a4878820"
7079
dependencies = [
7080
"windows-link",
7081
"windows-result",
···
7384
7385
[[package]]
7386
name = "wry"
7387
-
version = "0.51.2"
7388
source = "registry+https://github.com/rust-lang/crates.io-index"
7389
-
checksum = "c886a0a9d2a94fd90cfa1d929629b79cfefb1546e2c7430c63a47f0664c0e4e2"
7390
dependencies = [
7391
"base64 0.22.1",
7392
"block2 0.6.1",
···
540
"http-body-util",
541
"hyper",
542
"hyper-util",
543
+
"itoa",
544
"matchit",
545
"memchr",
546
"mime",
···
730
731
[[package]]
732
name = "brotli"
733
+
version = "8.0.1"
734
source = "registry+https://github.com/rust-lang/crates.io-index"
735
+
checksum = "9991eea70ea4f293524138648e41ee89b0b2b12ddef3b255effa43c8056e0e0d"
736
dependencies = [
737
"alloc-no-stdlib",
738
"alloc-stdlib",
···
741
742
[[package]]
743
name = "brotli-decompressor"
744
+
version = "5.0.0"
745
source = "registry+https://github.com/rust-lang/crates.io-index"
746
+
checksum = "874bb8112abecc98cbd6d81ea4fa7e94fb9449648c93cc89aa40c81c24d7de03"
747
dependencies = [
748
"alloc-no-stdlib",
749
"alloc-stdlib",
···
751
752
[[package]]
753
name = "bumpalo"
754
+
version = "3.19.0"
755
source = "registry+https://github.com/rust-lang/crates.io-index"
756
+
checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43"
757
758
[[package]]
759
name = "byte-unit"
···
1167
1168
[[package]]
1169
name = "cssparser"
1170
+
version = "0.29.6"
1171
source = "registry+https://github.com/rust-lang/crates.io-index"
1172
+
checksum = "f93d03419cb5950ccfd3daf3ff1c7a36ace64609a1a8746d493df1ca0afde0fa"
1173
dependencies = [
1174
"cssparser-macros",
1175
"dtoa-short",
1176
+
"itoa",
1177
"matches",
1178
+
"phf 0.10.1",
1179
"proc-macro2",
1180
"quote",
1181
"smallvec",
···
2243
"futures-core",
2244
"futures-sink",
2245
"http",
2246
+
"indexmap 2.10.0",
2247
"slab",
2248
"tokio",
2249
"tokio-util",
···
2309
2310
[[package]]
2311
name = "html5ever"
2312
+
version = "0.29.1"
2313
source = "registry+https://github.com/rust-lang/crates.io-index"
2314
+
checksum = "3b7410cae13cbc75623c98ac4cbfd1f0bedddf3227afc24f370cf0f50a44a11c"
2315
dependencies = [
2316
"log",
2317
"mac",
2318
"markup5ever",
2319
+
"match_token",
2320
]
2321
2322
[[package]]
···
2327
dependencies = [
2328
"bytes",
2329
"fnv",
2330
+
"itoa",
2331
]
2332
2333
[[package]]
···
2379
"http-body",
2380
"httparse",
2381
"httpdate",
2382
+
"itoa",
2383
"pin-project-lite",
2384
"smallvec",
2385
"tokio",
···
2589
2590
[[package]]
2591
name = "indexmap"
2592
+
version = "2.10.0"
2593
source = "registry+https://github.com/rust-lang/crates.io-index"
2594
+
checksum = "fe4cd85333e22411419a0bcae1297d25e58c9443848b11dc6a86fefe8c78a661"
2595
dependencies = [
2596
"equivalent",
2597
"hashbrown 0.15.4",
···
2680
2681
[[package]]
2682
name = "itoa"
2683
version = "1.0.15"
2684
source = "registry+https://github.com/rust-lang/crates.io-index"
2685
checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
···
2798
2799
[[package]]
2800
name = "kuchikiki"
2801
+
version = "0.8.8-speedreader"
2802
source = "registry+https://github.com/rust-lang/crates.io-index"
2803
+
checksum = "02cb977175687f33fa4afa0c95c112b987ea1443e5a51c8f8ff27dc618270cc2"
2804
dependencies = [
2805
"cssparser",
2806
"html5ever",
2807
+
"indexmap 2.10.0",
2808
"selectors",
2809
]
2810
···
2865
2866
[[package]]
2867
name = "libredox"
2868
+
version = "0.1.4"
2869
source = "registry+https://github.com/rust-lang/crates.io-index"
2870
+
checksum = "1580801010e535496706ba011c15f8532df6b42297d2e471fec38ceadd8c0638"
2871
dependencies = [
2872
"bitflags 2.9.1",
2873
"libc",
···
2965
"serde",
2966
"specta",
2967
"tokio",
2968
+
"tokio-util",
2969
"uuid",
2970
]
2971
···
3006
3007
[[package]]
3008
name = "markup5ever"
3009
+
version = "0.14.1"
3010
source = "registry+https://github.com/rust-lang/crates.io-index"
3011
+
checksum = "c7a7213d12e1864c0f002f52c2923d4556935a43dec5e71355c2760e0f6e7a18"
3012
dependencies = [
3013
"log",
3014
+
"phf 0.11.3",
3015
+
"phf_codegen 0.11.3",
3016
"string_cache",
3017
"string_cache_codegen",
3018
"tendril",
3019
]
3020
3021
[[package]]
3022
+
name = "match_token"
3023
+
version = "0.1.0"
3024
+
source = "registry+https://github.com/rust-lang/crates.io-index"
3025
+
checksum = "88a9689d8d44bf9964484516275f5cd4c9b59457a6940c1d5d0ecbb94510a36b"
3026
+
dependencies = [
3027
+
"proc-macro2",
3028
+
"quote",
3029
+
"syn 2.0.104",
3030
+
]
3031
+
3032
+
[[package]]
3033
name = "matchbox_protocol"
3034
version = "0.12.0"
3035
source = "registry+https://github.com/rust-lang/crates.io-index"
···
3176
3177
[[package]]
3178
name = "muda"
3179
+
version = "0.17.0"
3180
source = "registry+https://github.com/rust-lang/crates.io-index"
3181
+
checksum = "58b89bf91c19bf036347f1ab85a81c560f08c0667c8601bece664d860a600988"
3182
dependencies = [
3183
"crossbeam-channel",
3184
"dpi",
···
3761
source = "registry+https://github.com/rust-lang/crates.io-index"
3762
checksum = "3dfb61232e34fcb633f43d12c58f83c1df82962dcdfa565a4e866ffc17dafe12"
3763
dependencies = [
3764
"phf_shared 0.8.0",
3765
]
3766
3767
[[package]]
···
3770
source = "registry+https://github.com/rust-lang/crates.io-index"
3771
checksum = "fabbf1ead8a5bcbc20f5f8b939ee3f5b0f6f281b6ad3468b84656b658b455259"
3772
dependencies = [
3773
+
"phf_macros 0.10.0",
3774
"phf_shared 0.10.0",
3775
+
"proc-macro-hack",
3776
]
3777
3778
[[package]]
···
3797
3798
[[package]]
3799
name = "phf_codegen"
3800
+
version = "0.11.3"
3801
source = "registry+https://github.com/rust-lang/crates.io-index"
3802
+
checksum = "aef8048c789fa5e851558d709946d6d79a8ff88c0440c587967f8e94bfb1216a"
3803
dependencies = [
3804
+
"phf_generator 0.11.3",
3805
+
"phf_shared 0.11.3",
3806
]
3807
3808
[[package]]
···
3837
3838
[[package]]
3839
name = "phf_macros"
3840
+
version = "0.10.0"
3841
source = "registry+https://github.com/rust-lang/crates.io-index"
3842
+
checksum = "58fdf3184dd560f160dd73922bea2d5cd6e8f064bf4b13110abd81b03697b4e0"
3843
dependencies = [
3844
+
"phf_generator 0.10.0",
3845
+
"phf_shared 0.10.0",
3846
"proc-macro-hack",
3847
"proc-macro2",
3848
"quote",
···
3935
checksum = "3d77244ce2d584cd84f6a15f86195b8c9b2a0dfbfd817c09e0464244091a58ed"
3936
dependencies = [
3937
"base64 0.22.1",
3938
+
"indexmap 2.10.0",
3939
"quick-xml",
3940
"serde",
3941
"time",
···
4820
4821
[[package]]
4822
name = "selectors"
4823
+
version = "0.24.0"
4824
source = "registry+https://github.com/rust-lang/crates.io-index"
4825
+
checksum = "0c37578180969d00692904465fb7f6b3d50b9a2b952b87c23d0e2e5cb5013416"
4826
dependencies = [
4827
"bitflags 1.3.2",
4828
"cssparser",
4829
"derive_more 0.99.20",
4830
"fxhash",
4831
"log",
4832
"phf 0.8.0",
4833
"phf_codegen 0.8.0",
4834
"precomputed-hash",
4835
"servo_arc",
4836
"smallvec",
4837
]
4838
4839
[[package]]
···
4916
source = "registry+https://github.com/rust-lang/crates.io-index"
4917
checksum = "20068b6e96dc6c9bd23e01df8827e6c7e1f2fddd43c21810382803c136b99373"
4918
dependencies = [
4919
+
"itoa",
4920
"memchr",
4921
"ryu",
4922
"serde",
···
4928
source = "registry+https://github.com/rust-lang/crates.io-index"
4929
checksum = "59fab13f937fa393d08645bf3a84bdfe86e296747b506ada67bb15f10f218b2a"
4930
dependencies = [
4931
+
"itoa",
4932
"serde",
4933
]
4934
···
4959
checksum = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd"
4960
dependencies = [
4961
"form_urlencoded",
4962
+
"itoa",
4963
"ryu",
4964
"serde",
4965
]
···
4974
"chrono",
4975
"hex",
4976
"indexmap 1.9.3",
4977
+
"indexmap 2.10.0",
4978
"schemars 0.9.0",
4979
"serde",
4980
"serde_derive",
···
5019
5020
[[package]]
5021
name = "servo_arc"
5022
+
version = "0.2.0"
5023
source = "registry+https://github.com/rust-lang/crates.io-index"
5024
+
checksum = "d52aa42f8fdf0fed91e5ce7f23d8138441002fa31dca008acf47e6fd4721f741"
5025
dependencies = [
5026
"nodrop",
5027
"stable_deref_trait",
···
5400
5401
[[package]]
5402
name = "tao"
5403
+
version = "0.34.0"
5404
source = "registry+https://github.com/rust-lang/crates.io-index"
5405
+
checksum = "49c380ca75a231b87b6c9dd86948f035012e7171d1a7c40a9c2890489a7ffd8a"
5406
dependencies = [
5407
"bitflags 2.9.1",
5408
"core-foundation 0.10.1",
···
5462
5463
[[package]]
5464
name = "tauri"
5465
+
version = "2.6.1"
5466
source = "registry+https://github.com/rust-lang/crates.io-index"
5467
+
checksum = "773663ec28d911ac02f3a478c55f7f2fa581368d9e16ce9dff8d650b3666f91e"
5468
dependencies = [
5469
"anyhow",
5470
"bytes",
5471
"dirs",
5472
"dunce",
5473
"embed_plist",
5474
+
"getrandom 0.3.3",
5475
"glob",
5476
"gtk",
5477
"heck 0.5.0",
···
5513
5514
[[package]]
5515
name = "tauri-build"
5516
+
version = "2.3.0"
5517
source = "registry+https://github.com/rust-lang/crates.io-index"
5518
+
checksum = "12f025c389d3adb83114bec704da973142e82fc6ec799c7c750c5e21cefaec83"
5519
dependencies = [
5520
"anyhow",
5521
"cargo_toml",
···
5535
5536
[[package]]
5537
name = "tauri-codegen"
5538
+
version = "2.3.0"
5539
source = "registry+https://github.com/rust-lang/crates.io-index"
5540
+
checksum = "f5df493a1075a241065bc865ed5ef8d0fbc1e76c7afdc0bf0eccfaa7d4f0e406"
5541
dependencies = [
5542
"base64 0.22.1",
5543
"brotli",
···
5562
5563
[[package]]
5564
name = "tauri-macros"
5565
+
version = "2.3.1"
5566
source = "registry+https://github.com/rust-lang/crates.io-index"
5567
+
checksum = "f237fbea5866fa5f2a60a21bea807a2d6e0379db070d89c3a10ac0f2d4649bbc"
5568
dependencies = [
5569
"heck 0.5.0",
5570
"proc-macro2",
···
5576
5577
[[package]]
5578
name = "tauri-plugin"
5579
+
version = "2.3.0"
5580
source = "registry+https://github.com/rust-lang/crates.io-index"
5581
+
checksum = "1d9a0bd00bf1930ad1a604d08b0eb6b2a9c1822686d65d7f4731a7723b8901d3"
5582
dependencies = [
5583
"anyhow",
5584
"glob",
···
5593
5594
[[package]]
5595
name = "tauri-plugin-dialog"
5596
+
version = "2.3.0"
5597
source = "registry+https://github.com/rust-lang/crates.io-index"
5598
+
checksum = "1aefb14219b492afb30b12647b5b1247cadd2c0603467310c36e0f7ae1698c28"
5599
dependencies = [
5600
"log",
5601
"raw-window-handle",
···
5611
5612
[[package]]
5613
name = "tauri-plugin-fs"
5614
+
version = "2.4.0"
5615
source = "registry+https://github.com/rust-lang/crates.io-index"
5616
+
checksum = "c341290d31991dbca38b31d412c73dfbdb070bb11536784f19dd2211d13b778f"
5617
dependencies = [
5618
"anyhow",
5619
"dunce",
···
5633
5634
[[package]]
5635
name = "tauri-plugin-geolocation"
5636
+
version = "2.3.0"
5637
source = "registry+https://github.com/rust-lang/crates.io-index"
5638
+
checksum = "d3e5d020065f33a6590a5fbf7bdd508845399fbe644c2daeb51be319df99fdd7"
5639
dependencies = [
5640
"log",
5641
"serde",
···
5647
5648
[[package]]
5649
name = "tauri-plugin-log"
5650
+
version = "2.6.0"
5651
source = "registry+https://github.com/rust-lang/crates.io-index"
5652
+
checksum = "a59139183e0907cec1499dddee4e085f5a801dc659efa0848ee224f461371426"
5653
dependencies = [
5654
"android_logger",
5655
"byte-unit",
···
5669
5670
[[package]]
5671
name = "tauri-plugin-notification"
5672
+
version = "2.3.0"
5673
source = "registry+https://github.com/rust-lang/crates.io-index"
5674
+
checksum = "cfe06ed89cff6d0ec06ff4f544fb961e4718348a33309f56ccb2086e77bc9116"
5675
dependencies = [
5676
"log",
5677
"notify-rust",
···
5688
5689
[[package]]
5690
name = "tauri-plugin-opener"
5691
+
version = "2.4.0"
5692
source = "registry+https://github.com/rust-lang/crates.io-index"
5693
+
checksum = "ecee219f11cdac713ab32959db5d0cceec4810ba4f4458da992292ecf9660321"
5694
dependencies = [
5695
"dunce",
5696
"glob",
···
5710
5711
[[package]]
5712
name = "tauri-plugin-store"
5713
+
version = "2.3.0"
5714
source = "registry+https://github.com/rust-lang/crates.io-index"
5715
+
checksum = "5916c609664a56c82aeaefffca9851fd072d4d41f73d63f22ee3ee451508194f"
5716
dependencies = [
5717
"dunce",
5718
"serde",
···
5726
5727
[[package]]
5728
name = "tauri-runtime"
5729
+
version = "2.7.0"
5730
source = "registry+https://github.com/rust-lang/crates.io-index"
5731
+
checksum = "9e7bb73d1bceac06c20b3f755b2c8a2cb13b20b50083084a8cf3700daf397ba4"
5732
dependencies = [
5733
"cookie",
5734
"dpi",
···
5748
5749
[[package]]
5750
name = "tauri-runtime-wry"
5751
+
version = "2.7.0"
5752
source = "registry+https://github.com/rust-lang/crates.io-index"
5753
+
checksum = "fe52ed0ef40fd7ad51a620ecb3018e32eba3040bb95025216a962a37f6f050c5"
5754
dependencies = [
5755
"gtk",
5756
"http",
···
5803
5804
[[package]]
5805
name = "tauri-utils"
5806
+
version = "2.5.0"
5807
source = "registry+https://github.com/rust-lang/crates.io-index"
5808
+
checksum = "41743bbbeb96c3a100d234e5a0b60a46d5aa068f266160862c7afdbf828ca02e"
5809
dependencies = [
5810
"anyhow",
5811
"brotli",
···
5846
checksum = "e8d321dbc6f998d825ab3f0d62673e810c861aac2d0de2cc2c395328f1d113b4"
5847
dependencies = [
5848
"embed-resource",
5849
+
"indexmap 2.10.0",
5850
"toml",
5851
]
5852
···
5885
"mac",
5886
"utf-8",
5887
]
5888
5889
[[package]]
5890
name = "thiserror"
···
5933
checksum = "8a7619e19bc266e0f9c5e6686659d394bc57973859340060a69221e57dbc0c40"
5934
dependencies = [
5935
"deranged",
5936
+
"itoa",
5937
"libc",
5938
"num-conv",
5939
"num_threads",
···
6088
source = "registry+https://github.com/rust-lang/crates.io-index"
6089
checksum = "1b5bb770da30e5cbfde35a2d7b9b8a2c4b8ef89548a7a6aeab5c9a576e3e7421"
6090
dependencies = [
6091
+
"indexmap 2.10.0",
6092
"toml_datetime",
6093
"winnow 0.5.40",
6094
]
···
6099
source = "registry+https://github.com/rust-lang/crates.io-index"
6100
checksum = "70f427fce4d84c72b5b732388bf4a9f4531b53f74e2887e3ecb2481f68f66d81"
6101
dependencies = [
6102
+
"indexmap 2.10.0",
6103
"toml_datetime",
6104
"winnow 0.5.40",
6105
]
···
6110
source = "registry+https://github.com/rust-lang/crates.io-index"
6111
checksum = "41fe8c660ae4257887cf66394862d21dbca4a6ddd26f04a3560410406a2f819a"
6112
dependencies = [
6113
+
"indexmap 2.10.0",
6114
"serde",
6115
"serde_spanned",
6116
"toml_datetime",
···
6205
6206
[[package]]
6207
name = "tray-icon"
6208
+
version = "0.21.0"
6209
source = "registry+https://github.com/rust-lang/crates.io-index"
6210
+
checksum = "2da75ec677957aa21f6e0b361df0daab972f13a5bee3606de0638fd4ee1c666a"
6211
dependencies = [
6212
"crossbeam-channel",
6213
"dirs",
···
6901
6902
[[package]]
6903
name = "webview2-com"
6904
+
version = "0.38.0"
6905
source = "registry+https://github.com/rust-lang/crates.io-index"
6906
+
checksum = "d4ba622a989277ef3886dd5afb3e280e3dd6d974b766118950a08f8f678ad6a4"
6907
dependencies = [
6908
"webview2-com-macros",
6909
"webview2-com-sys",
···
6926
6927
[[package]]
6928
name = "webview2-com-sys"
6929
+
version = "0.38.0"
6930
source = "registry+https://github.com/rust-lang/crates.io-index"
6931
+
checksum = "36695906a1b53a3bf5c4289621efedac12b73eeb0b89e7e1a89b517302d5d75c"
6932
dependencies = [
6933
"thiserror 2.0.12",
6934
"windows",
···
7067
7068
[[package]]
7069
name = "windows-registry"
7070
+
version = "0.5.3"
7071
source = "registry+https://github.com/rust-lang/crates.io-index"
7072
+
checksum = "5b8a9ed28765efc97bbc954883f4e6796c33a06546ebafacbabee9696967499e"
7073
dependencies = [
7074
"windows-link",
7075
"windows-result",
···
7378
7379
[[package]]
7380
name = "wry"
7381
+
version = "0.52.1"
7382
source = "registry+https://github.com/rust-lang/crates.io-index"
7383
+
checksum = "12a714d9ba7075aae04a6e50229d6109e3d584774b99a6a8c60de1698ca111b9"
7384
dependencies = [
7385
"base64 0.22.1",
7386
"block2 0.6.1",
+2
-2
TODO.md
+2
-2
TODO.md
···
23
- [x] Transport : Handle transport cancellation better
24
- [x] Backend : Add checks for when the `powerup_locations` field is an empty array in settings
25
- [ ] Backend : More tests
26
-
- [ ] Lobby tests
27
-
- [ ] Game end test for actual return from loop
28
- [ ] Testing crate for integration testing from a DSL
29
- [ ] NixOS VM tests wrapping the testing crate
30
- [ ] Nix : Cheat the dependency nightmare and use crane
···
23
- [x] Transport : Handle transport cancellation better
24
- [x] Backend : Add checks for when the `powerup_locations` field is an empty array in settings
25
- [ ] Backend : More tests
26
+
- [x] Lobby tests
27
+
- [x] Game end test for actual return from loop
28
- [ ] Testing crate for integration testing from a DSL
29
- [ ] NixOS VM tests wrapping the testing crate
30
- [ ] Nix : Cheat the dependency nightmare and use crane
+1
-1
backend/Cargo.toml
+1
-1
backend/Cargo.toml
+3
-1
backend/src/export_types.rs
+3
-1
backend/src/export_types.rs
···
8
let path = args.get(1).expect("Usage: export-types path");
9
let specta = mk_specta();
10
let mut lang = Typescript::new();
11
-
lang.header = Cow::Borrowed("/* eslint @typescript-eslint/no-unused-vars: 0 */\n/* eslint @typescript-eslint/no-explicit-any: 0 */");
12
specta.export(lang, path).expect("Failed to export types");
13
println!("Successfully exported types, events, and commands to {path}",);
14
}
···
8
let path = args.get(1).expect("Usage: export-types path");
9
let specta = mk_specta();
10
let mut lang = Typescript::new();
11
+
lang.header = Cow::Borrowed(
12
+
"/* eslint @typescript-eslint/no-unused-vars: 0 */\n/* eslint @typescript-eslint/no-explicit-any: 0 */",
13
+
);
14
specta.export(lang, path).expect("Failed to export types");
15
println!("Successfully exported types, events, and commands to {path}",);
16
}
+4
-4
backend/src/lib.rs
+4
-4
backend/src/lib.rs
···
6
7
use anyhow::Context;
8
use location::TauriLocation;
9
-
use log::{error, info, warn, LevelFilter};
10
use manhunt_logic::{
11
Game as BaseGame, GameSettings, GameUiState, Lobby as BaseLobby, LobbyState, PlayerProfile,
12
StartGameInfo, StateUpdateSender,
13
};
14
-
use manhunt_transport::{generate_join_code, room_exists, MatchboxTransport};
15
use serde::{Deserialize, Serialize};
16
use tauri::{AppHandle, Manager, State};
17
use tauri_plugin_dialog::{DialogExt, MessageDialogKind};
18
-
use tauri_specta::{collect_commands, collect_events, ErrorHandlingMode, Event};
19
use tokio::sync::RwLock;
20
use uuid::Uuid;
21
···
213
let mut state = state_handle.write().await;
214
match res {
215
Ok(Some(start)) => {
216
-
info!("Starting game as");
217
state.start_game(app_game, start).await;
218
}
219
Ok(None) => {
···
6
7
use anyhow::Context;
8
use location::TauriLocation;
9
+
use log::{LevelFilter, error, info, warn};
10
use manhunt_logic::{
11
Game as BaseGame, GameSettings, GameUiState, Lobby as BaseLobby, LobbyState, PlayerProfile,
12
StartGameInfo, StateUpdateSender,
13
};
14
+
use manhunt_transport::{MatchboxTransport, generate_join_code, room_exists};
15
use serde::{Deserialize, Serialize};
16
use tauri::{AppHandle, Manager, State};
17
use tauri_plugin_dialog::{DialogExt, MessageDialogKind};
18
+
use tauri_specta::{ErrorHandlingMode, Event, collect_commands, collect_events};
19
use tokio::sync::RwLock;
20
use uuid::Uuid;
21
···
213
let mut state = state_handle.write().await;
214
match res {
215
Ok(Some(start)) => {
216
+
info!("Starting Game");
217
state.start_game(app_game, start).await;
218
}
219
Ok(None) => {
+6
-6
flake.lock
+6
-6
flake.lock
···
36
},
37
"nixpkgs_2": {
38
"locked": {
39
-
"lastModified": 1750731501,
40
-
"narHash": "sha256-Ah4qq+SbwMaGkuXCibyg+Fwn00el4KmI3XFX6htfDuk=",
41
"owner": "NixOS",
42
"repo": "nixpkgs",
43
-
"rev": "69dfebb3d175bde602f612915c5576a41b18486b",
44
"type": "github"
45
},
46
"original": {
···
62
"nixpkgs": ["nixpkgs"]
63
},
64
"locked": {
65
-
"lastModified": 1750732748,
66
-
"narHash": "sha256-HR2b3RHsPeJm+Fb+1ui8nXibgniVj7hBNvUbXEyz0DU=",
67
"owner": "oxalica",
68
"repo": "rust-overlay",
69
-
"rev": "4b4494b2ba7e8a8041b2e28320b2ee02c115c75f",
70
"type": "github"
71
},
72
"original": {
···
36
},
37
"nixpkgs_2": {
38
"locked": {
39
+
"lastModified": 1750811787,
40
+
"narHash": "sha256-rD/978c35JXz6JLAzciTIOCMenPumF6zrQOj4rVZeHE=",
41
"owner": "NixOS",
42
"repo": "nixpkgs",
43
+
"rev": "992f916556fcfaa94451ebc7fc6e396134bbf5b1",
44
"type": "github"
45
},
46
"original": {
···
62
"nixpkgs": ["nixpkgs"]
63
},
64
"locked": {
65
+
"lastModified": 1750819193,
66
+
"narHash": "sha256-XvkupGPZqD54HuKhN/2WhbKjAHeTl1UEnWspzUzRFfA=",
67
"owner": "oxalica",
68
"repo": "rust-overlay",
69
+
"rev": "1ba3b9c59b68a4b00156827ad46393127b51b808",
70
"type": "github"
71
},
72
"original": {
+1
-1
flake.nix
+1
-1
flake.nix
+2
-1
manhunt-logic/Cargo.toml
+2
-1
manhunt-logic/Cargo.toml
···
10
rand_chacha = "0.9.0"
11
serde = { version = "1.0.219", features = ["derive"] }
12
specta = { version = "=2.0.0-rc.22", features = ["uuid", "chrono", "derive"] }
13
-
tokio = { version = "1.45.1", features = ["macros", "rt", "sync", "time"] }
14
uuid = { version = "1.17.0", features = ["serde", "v4"] }
···
10
rand_chacha = "0.9.0"
11
serde = { version = "1.0.219", features = ["derive"] }
12
specta = { version = "=2.0.0-rc.22", features = ["uuid", "chrono", "derive"] }
13
+
tokio = { version = "1.45.1", features = ["macros", "rt", "sync", "time", "test-util"] }
14
+
tokio-util = "0.7.15"
15
uuid = { version = "1.17.0", features = ["serde", "v4"] }
+151
-94
manhunt-logic/src/game.rs
+151
-94
manhunt-logic/src/game.rs
···
1
use anyhow::bail;
2
use chrono::{DateTime, Utc};
3
use std::{sync::Arc, time::Duration};
4
use uuid::Uuid;
5
6
-
use tokio::{sync::RwLock, time::MissedTickBehavior};
7
8
use crate::StartGameInfo;
9
use crate::{prelude::*, transport::TransportMessage};
···
35
location: L,
36
state_update_sender: S,
37
interval: Duration,
38
}
39
40
impl<L: LocationService, T: Transport, S: StateUpdateSender> Game<L, T, S> {
···
57
interval,
58
state: RwLock::new(state),
59
state_update_sender,
60
}
61
}
62
···
71
state.remove_ping(id);
72
// TODO: Maybe reroll for new powerups (specifically seeker ones) instead of just erasing it
73
state.use_powerup();
74
-
75
-
self.send_event(GameEvent::PlayerCaught(state.id)).await;
76
}
77
78
pub async fn clone_settings(&self) -> GameSettings {
···
250
false
251
}
252
253
#[cfg(test)]
254
-
pub async fn force_tick(&self, now: UtcDT) {
255
-
let mut state = self.state.write().await;
256
-
self.tick(&mut state, now).await;
257
}
258
259
-
pub async fn quit_game(&self) {
260
-
self.transport.disconnect().await;
261
}
262
263
/// Main loop of the game, handles ticking and receiving messages from [Transport].
264
pub async fn main_loop(&self) -> Result<Option<GameHistory>> {
265
let mut interval = tokio::time::interval(self.interval);
266
267
-
interval.set_missed_tick_behavior(MissedTickBehavior::Delay);
268
269
let res = 'game: loop {
270
tokio::select! {
271
biased;
272
273
messages = self.transport.receive_messages() => {
274
let mut state = self.state.write().await;
···
286
287
_ = interval.tick() => {
288
let mut state = self.state.write().await;
289
-
let should_break = self.tick(&mut state, Utc::now()).await;
290
291
if should_break {
292
let history = state.as_game_history();
···
313
};
314
315
use super::*;
316
-
use tokio::{task::yield_now, test};
317
318
type TestGame = Game<MockLocation, MockTransport, DummySender>;
319
320
struct MockMatch {
321
uuids: Vec<Uuid>,
322
-
games: HashMap<u32, Arc<TestGame>>,
323
settings: GameSettings,
324
-
mock_now: UtcDT,
325
}
326
327
-
const INTERVAL: Duration = Duration::from_secs(u64::MAX);
328
329
impl MockMatch {
330
pub fn new(settings: GameSettings, players: u32, seekers: u32) -> Self {
331
let (uuids, transports) = MockTransport::create_mesh(players);
332
333
let initial_caught_state = (0..players)
···
336
337
let games = transports
338
.into_iter()
339
-
.enumerate()
340
-
.map(|(id, transport)| {
341
let location = MockLocation;
342
let start_info = StartGameInfo {
343
initial_caught_state: initial_caught_state.clone(),
···
351
DummySender,
352
);
353
354
-
(id as u32, Arc::new(game))
355
})
356
-
.collect::<HashMap<_, _>>();
357
358
Self {
359
settings,
360
games,
361
uuids,
362
-
mock_now: Utc::now(),
363
}
364
}
365
366
-
pub async fn start(&self) {
367
-
for game in self.games.values() {
368
let game = game.clone();
369
tokio::spawn(async move {
370
-
game.main_loop().await.expect("Game Start Fail");
371
});
372
yield_now().await;
373
}
374
}
375
376
-
pub async fn pass_time(&mut self, d: Duration) {
377
-
self.mock_now += d;
378
-
}
379
-
380
-
pub async fn assert_all_states(&self, f: impl Fn(&GameState)) {
381
-
for game in self.games.values() {
382
let state = game.state.read().await;
383
-
f(&state);
384
}
385
}
386
387
-
pub fn game(&self, id: u32) -> &TestGame {
388
-
self.games.get(&id).as_ref().unwrap()
389
}
390
391
pub async fn wait_for_seekers(&mut self) {
392
let hiding_time = Duration::from_secs(self.settings.hiding_time_seconds as u64 + 1);
393
-
self.mock_now += hiding_time;
394
395
self.tick().await;
396
397
-
self.assert_all_states(|s| {
398
-
assert!(s.seekers_released());
399
})
400
.await;
401
}
402
403
-
async fn tick_all(&self, now: UtcDT) {
404
-
for game in self.games.values() {
405
-
game.force_tick(now).await;
406
}
407
}
408
409
pub async fn tick(&self) {
410
-
self.tick_all(self.mock_now).await;
411
yield_now().await;
412
}
413
}
···
436
// 2 players, one is a seeker
437
let mut mat = MockMatch::new(settings, 2, 1);
438
439
-
mat.start().await;
440
441
mat.wait_for_seekers().await;
442
443
-
mat.game(1).mark_caught().await;
444
445
-
mat.tick().await;
446
447
-
mat.assert_all_states(|s| {
448
assert_eq!(
449
s.get_caught(mat.uuids[1]),
450
Some(true),
451
-
"Game {} sees player 1 as not caught",
452
-
s.id
453
);
454
})
455
.await;
456
457
-
// Extra tick for post-game syncing
458
mat.tick().await;
459
460
-
mat.assert_all_states(|s| assert!(s.game_ended(), "Game {} has not ended", s.id))
461
-
.await;
462
}
463
464
#[test]
···
472
473
mat.wait_for_seekers().await;
474
475
-
mat.assert_all_states(|s| {
476
for id in 0..4 {
477
let ping = s.get_ping(mat.uuids[id]);
478
if id == 0 {
479
assert!(
480
ping.is_none(),
481
-
"Game 0 is a seeker and shouldn't be pinged (in {})",
482
-
s.id
483
);
484
} else {
485
assert!(
486
ping.is_some(),
487
-
"Game {} is a hider and should be pinged (in {})",
488
-
id,
489
-
s.id
490
);
491
}
492
}
493
})
494
.await;
495
496
-
mat.game(1).mark_caught().await;
497
498
mat.tick().await;
499
500
-
mat.assert_all_states(|s| {
501
for id in 0..4 {
502
let ping = s.get_ping(mat.uuids[id]);
503
if id <= 1 {
504
assert!(
505
ping.is_none(),
506
-
"Game {} is a seeker and shouldn't be pinged (in {})",
507
-
id,
508
-
s.id
509
);
510
} else {
511
assert!(
512
ping.is_some(),
513
-
"Game {} is a hider and should be pinged (in {})",
514
-
id,
515
-
s.id
516
);
517
}
518
}
···
539
mat.start().await;
540
mat.tick().await;
541
mat.wait_for_seekers().await;
542
-
mat.pass_time(Duration::from_secs(60)).await;
543
mat.tick().await;
544
545
-
let game = mat.game(0);
546
let state = game.state.read().await;
547
let location = state.powerup_location().expect("Powerup didn't spawn");
548
549
drop(state);
550
551
-
mat.assert_all_states(|s| {
552
assert_eq!(
553
s.powerup_location(),
554
Some(location),
555
-
"Game {} has a different location than 0",
556
-
s.id
557
);
558
})
559
.await;
···
562
#[test]
563
async fn test_powerup_ping_seeker_as_you() {
564
let mut settings = mk_settings();
565
-
settings.ping_minutes_interval = 0;
566
let mut mat = MockMatch::new(settings, 2, 1);
567
568
mat.start().await;
569
mat.wait_for_seekers().await;
570
571
-
let game = mat.game(1);
572
let mut state = game.state.write().await;
573
state.force_set_powerup(PowerUpType::PingSeeker);
574
drop(state);
575
576
mat.tick().await;
577
578
-
mat.assert_all_states(|s| {
579
if let Some(ping) = s.get_ping(mat.uuids[1]) {
580
assert_eq!(
581
ping.real_player, mat.uuids[0],
582
-
"Ping for 1 is not truly 0 (in {})",
583
-
s.id
584
);
585
} else {
586
-
panic!("No ping for 1 (in {})", s.id);
587
}
588
})
589
.await;
···
591
592
#[test]
593
async fn test_powerup_ping_random_hider() {
594
-
let settings = mk_settings();
595
596
let mut mat = MockMatch::new(settings, 3, 1);
597
598
mat.start().await;
599
mat.wait_for_seekers().await;
600
601
-
let game = mat.game(1);
602
let mut state = game.state.write().await;
603
state.force_set_powerup(PowerUpType::ForcePingOther);
604
drop(state);
···
606
game.use_powerup().await;
607
mat.tick().await;
608
609
-
mat.assert_all_states(|s| {
610
-
// Player 0 is a seeker, player 1 user the powerup, so 2 is the only one that should
611
-
// could have pinged
612
-
assert!(s.get_ping(mat.uuids[2]).is_some());
613
-
assert!(s.get_ping(mat.uuids[0]).is_none());
614
-
assert!(s.get_ping(mat.uuids[1]).is_none());
615
})
616
.await;
617
}
···
624
625
mat.start().await;
626
627
-
let game = mat.game(3);
628
let mut state = game.state.write().await;
629
state.force_set_powerup(PowerUpType::PingAllSeekers);
630
drop(state);
631
632
game.use_powerup().await;
633
mat.tick().await;
634
635
-
mat.assert_all_states(|s| {
636
for id in 0..3 {
637
assert!(
638
-
s.get_caught(mat.uuids[id]).is_some(),
639
-
"Player {} should be pinged due to the powerup (in {})",
640
-
id,
641
-
s.id
642
);
643
}
644
})
···
650
let settings = mk_settings();
651
let mat = MockMatch::new(settings, 4, 1);
652
653
-
mat.start().await;
654
655
-
let game = mat.game(2);
656
-
game.quit_game().await;
657
let id = game.state.read().await.id;
658
659
mat.tick().await;
660
661
-
mat.assert_all_states(|s| {
662
if s.id != id {
663
assert!(
664
s.get_ping(id).is_none(),
665
-
"Game {} has not removed 2 from pings",
666
-
s.id
667
);
668
assert!(
669
s.get_caught(id).is_none(),
670
-
"Game {} has not removed 2 from caught state",
671
-
s.id
672
);
673
}
674
})
···
1
use anyhow::bail;
2
use chrono::{DateTime, Utc};
3
use std::{sync::Arc, time::Duration};
4
+
use tokio_util::sync::CancellationToken;
5
use uuid::Uuid;
6
7
+
use tokio::sync::RwLock;
8
9
use crate::StartGameInfo;
10
use crate::{prelude::*, transport::TransportMessage};
···
36
location: L,
37
state_update_sender: S,
38
interval: Duration,
39
+
cancel: CancellationToken,
40
}
41
42
impl<L: LocationService, T: Transport, S: StateUpdateSender> Game<L, T, S> {
···
59
interval,
60
state: RwLock::new(state),
61
state_update_sender,
62
+
cancel: CancellationToken::new(),
63
}
64
}
65
···
74
state.remove_ping(id);
75
// TODO: Maybe reroll for new powerups (specifically seeker ones) instead of just erasing it
76
state.use_powerup();
77
+
drop(state);
78
+
self.send_event(GameEvent::PlayerCaught(id)).await;
79
}
80
81
pub async fn clone_settings(&self) -> GameSettings {
···
253
false
254
}
255
256
+
pub async fn quit_game(&self) {
257
+
self.cancel.cancel();
258
+
}
259
+
260
#[cfg(test)]
261
+
fn get_now() -> UtcDT {
262
+
let fake = tokio::time::Instant::now();
263
+
let real = std::time::Instant::now();
264
+
Utc::now() + (fake.into_std().duration_since(real) + Duration::from_secs(1))
265
}
266
267
+
#[cfg(not(test))]
268
+
fn get_now() -> UtcDT {
269
+
Utc::now()
270
}
271
272
/// Main loop of the game, handles ticking and receiving messages from [Transport].
273
pub async fn main_loop(&self) -> Result<Option<GameHistory>> {
274
let mut interval = tokio::time::interval(self.interval);
275
276
+
// interval.set_missed_tick_behavior(MissedTickBehavior::Delay);
277
278
let res = 'game: loop {
279
tokio::select! {
280
biased;
281
+
282
+
_ = self.cancel.cancelled() => {
283
+
break 'game Ok(None);
284
+
}
285
286
messages = self.transport.receive_messages() => {
287
let mut state = self.state.write().await;
···
299
300
_ = interval.tick() => {
301
let mut state = self.state.write().await;
302
+
let should_break = self.tick(&mut state, Self::get_now()).await;
303
304
if should_break {
305
let history = state.as_game_history();
···
326
};
327
328
use super::*;
329
+
use tokio::{sync::oneshot, task::yield_now, test};
330
331
type TestGame = Game<MockLocation, MockTransport, DummySender>;
332
333
+
type EndRecv = oneshot::Receiver<Result<Option<GameHistory>>>;
334
+
335
struct MockMatch {
336
uuids: Vec<Uuid>,
337
+
games: Vec<Arc<TestGame>>,
338
settings: GameSettings,
339
}
340
341
+
const INTERVAL: Duration = Duration::from_secs(600000);
342
343
impl MockMatch {
344
pub fn new(settings: GameSettings, players: u32, seekers: u32) -> Self {
345
+
tokio::time::pause();
346
let (uuids, transports) = MockTransport::create_mesh(players);
347
348
let initial_caught_state = (0..players)
···
351
352
let games = transports
353
.into_iter()
354
+
.map(|transport| {
355
let location = MockLocation;
356
let start_info = StartGameInfo {
357
initial_caught_state: initial_caught_state.clone(),
···
365
DummySender,
366
);
367
368
+
Arc::new(game)
369
})
370
+
.collect();
371
372
Self {
373
settings,
374
games,
375
uuids,
376
}
377
}
378
379
+
pub async fn start(&self) -> Vec<EndRecv> {
380
+
let mut recvs = Vec::with_capacity(self.games.len());
381
+
for game in self.games.iter() {
382
let game = game.clone();
383
+
let (send, recv) = oneshot::channel();
384
+
recvs.push(recv);
385
tokio::spawn(async move {
386
+
let res = game.main_loop().await;
387
+
send.send(res).expect("Failed to send");
388
});
389
yield_now().await;
390
}
391
+
recvs
392
}
393
394
+
pub async fn assert_all_states(&self, f: impl Fn(usize, &GameState)) {
395
+
for (i, game) in self.games.iter().enumerate() {
396
let state = game.state.read().await;
397
+
f(i, &state);
398
}
399
}
400
401
+
pub fn assert_all_transports_disconnected(&self) {
402
+
for game in self.games.iter() {
403
+
assert!(
404
+
game.transport.is_disconnected(),
405
+
"Game {} is still connected",
406
+
game.transport.self_id()
407
+
);
408
+
}
409
}
410
411
pub async fn wait_for_seekers(&mut self) {
412
let hiding_time = Duration::from_secs(self.settings.hiding_time_seconds as u64 + 1);
413
+
414
+
tokio::time::sleep(hiding_time).await;
415
416
self.tick().await;
417
418
+
self.assert_all_states(|i, s| {
419
+
assert!(s.seekers_released(), "Seekers not released on game {i}");
420
})
421
.await;
422
}
423
424
+
pub async fn wait_for_transports(&self) {
425
+
for game in self.games.iter() {
426
+
game.transport.wait_for_queue_empty().await;
427
}
428
}
429
430
pub async fn tick(&self) {
431
+
tokio::time::sleep(INTERVAL + Duration::from_secs(1)).await;
432
+
self.wait_for_transports().await;
433
yield_now().await;
434
}
435
}
···
458
// 2 players, one is a seeker
459
let mut mat = MockMatch::new(settings, 2, 1);
460
461
+
let recvs = mat.start().await;
462
463
mat.wait_for_seekers().await;
464
465
+
mat.games[1].mark_caught().await;
466
467
+
mat.wait_for_transports().await;
468
469
+
mat.assert_all_states(|i, s| {
470
assert_eq!(
471
s.get_caught(mat.uuids[1]),
472
Some(true),
473
+
"Game {i} sees player 1 as not caught",
474
);
475
})
476
.await;
477
478
+
// Tick to process game end
479
+
mat.tick().await;
480
+
481
+
mat.assert_all_states(|i, s| {
482
+
assert!(s.game_ended(), "Game {} has not ended", i);
483
+
})
484
+
.await;
485
+
486
+
// Tick for post-game sync
487
mat.tick().await;
488
489
+
mat.assert_all_transports_disconnected();
490
+
491
+
for (i, recv) in recvs.into_iter().enumerate() {
492
+
let res = recv.await.expect("Failed to recv");
493
+
match res {
494
+
Ok(Some(hist)) => {
495
+
assert!(!hist.locations.is_empty(), "Game {i} has no locations");
496
+
assert!(!hist.events.is_empty(), "Game {i} has no event");
497
+
}
498
+
Ok(None) => {
499
+
panic!("Game {i} exited without a history (did not end via post game sync)");
500
+
}
501
+
Err(why) => {
502
+
panic!("Game {i} encountered error: {why:?}");
503
+
}
504
+
}
505
+
}
506
}
507
508
#[test]
···
516
517
mat.wait_for_seekers().await;
518
519
+
mat.assert_all_states(|i, s| {
520
for id in 0..4 {
521
let ping = s.get_ping(mat.uuids[id]);
522
if id == 0 {
523
assert!(
524
ping.is_none(),
525
+
"Game {i} has a ping for 0, despite them being a seeker",
526
);
527
} else {
528
assert!(
529
ping.is_some(),
530
+
"Game {i} doesn't have a ping for {id}, despite them being a hider",
531
);
532
}
533
}
534
})
535
.await;
536
537
+
mat.games[1].mark_caught().await;
538
539
mat.tick().await;
540
541
+
mat.assert_all_states(|i, s| {
542
for id in 0..4 {
543
let ping = s.get_ping(mat.uuids[id]);
544
if id <= 1 {
545
assert!(
546
ping.is_none(),
547
+
"Game {i} has a ping for {id}, despite them being a seeker",
548
);
549
} else {
550
assert!(
551
ping.is_some(),
552
+
"Game {i} doesn't have a ping for {id}, despite them being a hider",
553
);
554
}
555
}
···
576
mat.start().await;
577
mat.tick().await;
578
mat.wait_for_seekers().await;
579
+
tokio::time::sleep(Duration::from_secs(60)).await;
580
mat.tick().await;
581
582
+
let game = mat.games[0].clone();
583
let state = game.state.read().await;
584
let location = state.powerup_location().expect("Powerup didn't spawn");
585
586
drop(state);
587
588
+
mat.assert_all_states(|i, s| {
589
assert_eq!(
590
s.powerup_location(),
591
Some(location),
592
+
"Game {i} has a different location than 0",
593
);
594
})
595
.await;
···
598
#[test]
599
async fn test_powerup_ping_seeker_as_you() {
600
let mut settings = mk_settings();
601
+
settings.ping_minutes_interval = 1;
602
let mut mat = MockMatch::new(settings, 2, 1);
603
604
mat.start().await;
605
mat.wait_for_seekers().await;
606
607
+
mat.tick().await;
608
+
609
+
tokio::time::sleep(Duration::from_secs(60)).await;
610
+
611
+
let game = mat.games[1].clone();
612
let mut state = game.state.write().await;
613
state.force_set_powerup(PowerUpType::PingSeeker);
614
drop(state);
615
616
mat.tick().await;
617
618
+
mat.assert_all_states(|i, s| {
619
if let Some(ping) = s.get_ping(mat.uuids[1]) {
620
assert_eq!(
621
ping.real_player, mat.uuids[0],
622
+
"Game {i} has a ping for 1, but it wasn't from 0"
623
);
624
} else {
625
+
panic!("Game {i} has no ping for 1");
626
}
627
})
628
.await;
···
630
631
#[test]
632
async fn test_powerup_ping_random_hider() {
633
+
let mut settings = mk_settings();
634
+
settings.ping_minutes_interval = u32::MAX;
635
636
let mut mat = MockMatch::new(settings, 3, 1);
637
638
mat.start().await;
639
mat.wait_for_seekers().await;
640
641
+
let game = mat.games[1].clone();
642
let mut state = game.state.write().await;
643
state.force_set_powerup(PowerUpType::ForcePingOther);
644
drop(state);
···
646
game.use_powerup().await;
647
mat.tick().await;
648
649
+
mat.assert_all_states(|i, s| {
650
+
// Player 0 is a seeker, player 1 used the powerup, so 2 is the only one that should
651
+
// have pinged
652
+
assert!(
653
+
s.get_ping(mat.uuids[2]).is_some(),
654
+
"Ping 2 is not present in game {i}"
655
+
);
656
+
assert!(
657
+
s.get_ping(mat.uuids[0]).is_none(),
658
+
"Ping 0 is present in game {i}"
659
+
);
660
+
assert!(
661
+
s.get_ping(mat.uuids[1]).is_none(),
662
+
"Ping 1 is present in game {i}"
663
+
);
664
})
665
.await;
666
}
···
673
674
mat.start().await;
675
676
+
mat.tick().await;
677
+
678
+
let game = mat.games[3].clone();
679
let mut state = game.state.write().await;
680
state.force_set_powerup(PowerUpType::PingAllSeekers);
681
drop(state);
682
683
game.use_powerup().await;
684
+
// One tick to send out the ForcePing
685
+
mat.tick().await;
686
+
// One tick to for the seekers to reply
687
mat.tick().await;
688
689
+
mat.assert_all_states(|i, s| {
690
for id in 0..3 {
691
assert!(
692
+
&s.get_ping(mat.uuids[id]).is_some(),
693
+
"Game {i} does not have a ping for {id}, despite the powerup being active",
694
);
695
}
696
})
···
702
let settings = mk_settings();
703
let mat = MockMatch::new(settings, 4, 1);
704
705
+
let mut recvs = mat.start().await;
706
707
+
let game = mat.games[2].clone();
708
let id = game.state.read().await.id;
709
710
+
game.quit_game().await;
711
+
let res = recvs.swap_remove(2).await.expect("Failed to recv");
712
+
assert!(res.is_ok_and(|o| o.is_none()), "2 did not exit cleanly");
713
+
assert!(
714
+
game.transport.is_disconnected(),
715
+
"2's transport is not disconnected"
716
+
);
717
+
718
mat.tick().await;
719
720
+
mat.assert_all_states(|i, s| {
721
if s.id != id {
722
assert!(
723
s.get_ping(id).is_none(),
724
+
"Game {i} has not removed 2 from pings",
725
);
726
assert!(
727
s.get_caught(id).is_none(),
728
+
"Game {i} has not removed 2 from caught state",
729
);
730
}
731
})
+3
-3
manhunt-logic/src/game_state.rs
+3
-3
manhunt-logic/src/game_state.rs
···
2
3
use chrono::Utc;
4
use rand::{
5
distr::{Bernoulli, Distribution},
6
seq::{IndexedRandom, IteratorRandom},
7
-
Rng, SeedableRng,
8
};
9
use rand_chacha::ChaCha20Rng;
10
use serde::{Deserialize, Serialize};
···
416
my_id: Uuid,
417
pub game_started: UtcDT,
418
game_ended: UtcDT,
419
-
events: Vec<(UtcDT, GameEvent)>,
420
-
locations: Vec<(Uuid, Vec<(UtcDT, Location)>)>,
421
}
422
423
/// Subset of [GameState] that is meant to be sent to a UI frontend
···
2
3
use chrono::Utc;
4
use rand::{
5
+
Rng, SeedableRng,
6
distr::{Bernoulli, Distribution},
7
seq::{IndexedRandom, IteratorRandom},
8
};
9
use rand_chacha::ChaCha20Rng;
10
use serde::{Deserialize, Serialize};
···
416
my_id: Uuid,
417
pub game_started: UtcDT,
418
game_ended: UtcDT,
419
+
pub events: Vec<(UtcDT, GameEvent)>,
420
+
pub locations: Vec<(Uuid, Vec<(UtcDT, Location)>)>,
421
}
422
423
/// Subset of [GameState] that is meant to be sent to a UI frontend
+368
-18
manhunt-logic/src/lobby.rs
+368
-18
manhunt-logic/src/lobby.rs
···
3
use anyhow::anyhow;
4
use serde::{Deserialize, Serialize};
5
use tokio::sync::Mutex;
6
use uuid::Uuid;
7
8
use crate::{
···
31
PlayerSwitch(Uuid, bool),
32
}
33
34
-
#[derive(Clone, Serialize, Deserialize, specta::Type)]
35
pub struct LobbyState {
36
profiles: HashMap<Uuid, PlayerProfile>,
37
join_code: String,
···
48
state: Mutex<LobbyState>,
49
transport: Arc<T>,
50
state_updates: U,
51
}
52
53
impl<T: Transport, U: StateUpdateSender> Lobby<T, U> {
54
pub async fn new(
55
join_code: &str,
56
-
host: bool,
57
profile: PlayerProfile,
58
settings: GameSettings,
59
state_updates: U,
60
) -> Result<Arc<Self>> {
61
-
let transport = T::initialize(join_code, host)
62
.await
63
.context("Failed to connect to lobby")?;
64
65
let self_id = transport.self_id();
66
-
67
-
let lobby = Arc::new(Self {
68
transport,
69
state_updates,
70
-
is_host: host,
71
join_code: join_code.to_string(),
72
state: Mutex::new(LobbyState {
73
teams: HashMap::from_iter([(self_id, false)]),
74
join_code: join_code.to_string(),
75
profiles: HashMap::from_iter([(self_id, profile)]),
76
self_id,
77
-
is_host: host,
78
settings,
79
}),
80
-
});
81
-
82
-
Ok(lobby)
83
}
84
85
fn emit_state_update(&self) {
···
134
.await
135
.map(|start_game| Ok(Some(start_game))),
136
TransportMessage::PeerConnect(peer) => {
137
-
let mut state = self.state.lock().await;
138
-
state.teams.insert(peer, false);
139
let id = state.self_id;
140
let msg = LobbyMessage::PlayerSync(id, state.profiles[&id].clone());
141
drop(state);
142
self.send_transport_message(Some(peer), msg).await;
143
if self.is_host {
144
let state = self.state.lock().await;
145
let msg = LobbyMessage::HostPush(state.settings.clone());
···
163
let res = 'lobby: loop {
164
self.emit_state_update();
165
166
-
let msgs = self.transport.receive_messages().await;
167
168
-
for (peer, msg) in msgs {
169
-
if let Some(res) = self.handle_message(peer, msg).await {
170
-
break 'lobby res;
171
}
172
}
173
};
174
175
-
if res.is_err() {
176
self.transport.disconnect().await;
177
}
178
···
234
}
235
236
pub async fn quit_lobby(&self) {
237
-
self.transport.disconnect().await;
238
}
239
}
···
3
use anyhow::anyhow;
4
use serde::{Deserialize, Serialize};
5
use tokio::sync::Mutex;
6
+
use tokio_util::sync::CancellationToken;
7
use uuid::Uuid;
8
9
use crate::{
···
32
PlayerSwitch(Uuid, bool),
33
}
34
35
+
#[derive(Debug, Clone, Serialize, Deserialize, specta::Type)]
36
pub struct LobbyState {
37
profiles: HashMap<Uuid, PlayerProfile>,
38
join_code: String,
···
49
state: Mutex<LobbyState>,
50
transport: Arc<T>,
51
state_updates: U,
52
+
cancel: CancellationToken,
53
}
54
55
impl<T: Transport, U: StateUpdateSender> Lobby<T, U> {
56
pub async fn new(
57
join_code: &str,
58
+
is_host: bool,
59
profile: PlayerProfile,
60
settings: GameSettings,
61
state_updates: U,
62
) -> Result<Arc<Self>> {
63
+
let transport = T::initialize(join_code, is_host)
64
.await
65
.context("Failed to connect to lobby")?;
66
67
+
let lobby = Arc::new(Self::new_with_transport(
68
+
join_code,
69
+
is_host,
70
+
profile,
71
+
settings,
72
+
state_updates,
73
+
transport,
74
+
));
75
+
76
+
Ok(lobby)
77
+
}
78
+
79
+
pub fn new_with_transport(
80
+
join_code: &str,
81
+
is_host: bool,
82
+
profile: PlayerProfile,
83
+
settings: GameSettings,
84
+
state_updates: U,
85
+
transport: Arc<T>,
86
+
) -> Self {
87
let self_id = transport.self_id();
88
+
Self {
89
transport,
90
state_updates,
91
+
is_host,
92
+
cancel: CancellationToken::new(),
93
join_code: join_code.to_string(),
94
state: Mutex::new(LobbyState {
95
teams: HashMap::from_iter([(self_id, false)]),
96
join_code: join_code.to_string(),
97
profiles: HashMap::from_iter([(self_id, profile)]),
98
self_id,
99
+
is_host,
100
settings,
101
}),
102
+
}
103
}
104
105
fn emit_state_update(&self) {
···
154
.await
155
.map(|start_game| Ok(Some(start_game))),
156
TransportMessage::PeerConnect(peer) => {
157
+
let state = self.state.lock().await;
158
let id = state.self_id;
159
let msg = LobbyMessage::PlayerSync(id, state.profiles[&id].clone());
160
+
let msg2 = LobbyMessage::PlayerSwitch(id, state.teams[&id]);
161
drop(state);
162
self.send_transport_message(Some(peer), msg).await;
163
+
self.send_transport_message(Some(peer), msg2).await;
164
if self.is_host {
165
let state = self.state.lock().await;
166
let msg = LobbyMessage::HostPush(state.settings.clone());
···
184
let res = 'lobby: loop {
185
self.emit_state_update();
186
187
+
tokio::select! {
188
+
biased;
189
+
190
+
msgs = self.transport.receive_messages() => {
191
+
for (peer, msg) in msgs {
192
+
if let Some(res) = self.handle_message(peer, msg).await {
193
+
break 'lobby res;
194
+
}
195
+
}
196
+
}
197
198
+
_ = self.cancel.cancelled() => {
199
+
break Ok(None);
200
}
201
}
202
};
203
204
+
if let Ok(None) | Err(_) = res {
205
self.transport.disconnect().await;
206
}
207
···
263
}
264
265
pub async fn quit_lobby(&self) {
266
+
self.cancel.cancel();
267
+
}
268
+
}
269
+
270
+
#[cfg(test)]
271
+
mod tests {
272
+
use super::*;
273
+
use std::sync::Arc;
274
+
use tokio::{sync::oneshot, task::yield_now, test};
275
+
276
+
use crate::tests::{DummySender, MockTransport};
277
+
278
+
type MockLobby = Lobby<MockTransport, DummySender>;
279
+
280
+
type CompleteRecv = oneshot::Receiver<Result<Option<StartGameInfo>>>;
281
+
282
+
struct MockLobbyPool {
283
+
uuids: Vec<Uuid>,
284
+
lobbies: Vec<Arc<MockLobby>>,
285
+
}
286
+
287
+
impl MockLobbyPool {
288
+
pub fn new(num_players: u32) -> Self {
289
+
let settings = GameSettings::default();
290
+
let (uuids, transports) = MockTransport::create_mesh(num_players);
291
+
292
+
let lobbies = transports
293
+
.into_iter()
294
+
.enumerate()
295
+
.map(|(i, transport)| {
296
+
let profile = PlayerProfile {
297
+
display_name: format!("Lobby {i} ({})", uuids[i]),
298
+
pfp_base64: None,
299
+
};
300
+
301
+
Arc::new(MockLobby::new_with_transport(
302
+
"aaa",
303
+
i == 0,
304
+
profile,
305
+
settings.clone(),
306
+
DummySender,
307
+
Arc::new(transport),
308
+
))
309
+
})
310
+
.collect();
311
+
312
+
Self { uuids, lobbies }
313
+
}
314
+
315
+
pub async fn wait(&self) {
316
+
for lobby in self.lobbies.iter() {
317
+
lobby.transport.wait_for_queue_empty().await;
318
+
}
319
+
yield_now().await;
320
+
}
321
+
322
+
pub async fn start_all_loops(&self) -> Vec<CompleteRecv> {
323
+
let mut recv_set = Vec::with_capacity(self.lobbies.len());
324
+
for lobby in self.lobbies.iter() {
325
+
let lobby = lobby.clone();
326
+
let (send, recv) = oneshot::channel();
327
+
recv_set.push(recv);
328
+
tokio::spawn(async move {
329
+
let res = lobby.main_loop().await;
330
+
send.send(res).ok();
331
+
});
332
+
}
333
+
recv_set
334
+
}
335
+
336
+
pub async fn player_join(&self, i: usize) {
337
+
self.lobbies[i].transport.fake_join().await;
338
+
}
339
+
340
+
pub async fn assert_state(&self, i: usize, f: impl Fn(&LobbyState)) {
341
+
let state = self.lobbies[i].state.lock().await;
342
+
f(&state);
343
+
}
344
+
345
+
pub async fn assert_all_states(&self, f: impl Fn(usize, &LobbyState)) {
346
+
for (i, lobby) in self.lobbies.iter().enumerate() {
347
+
let state = lobby.state.lock().await;
348
+
f(i, &state);
349
+
}
350
+
}
351
+
}
352
+
353
+
#[test]
354
+
async fn test_joins() {
355
+
let mat = MockLobbyPool::new(3);
356
+
357
+
mat.start_all_loops().await;
358
+
359
+
mat.player_join(0).await;
360
+
mat.player_join(1).await;
361
+
362
+
mat.wait().await;
363
+
364
+
for i in 0..=1 {
365
+
for j in 0..=1 {
366
+
mat.assert_state(i, |s| {
367
+
assert!(
368
+
s.teams.contains_key(&mat.uuids[j]),
369
+
"{i} doesn't have {j}'s uuid in teams"
370
+
);
371
+
assert!(
372
+
s.profiles.contains_key(&mat.uuids[j]),
373
+
"{i} doesn't have {j}'s uuid in profiles"
374
+
);
375
+
})
376
+
.await;
377
+
}
378
+
}
379
+
380
+
mat.lobbies[0].switch_teams(true).await;
381
+
382
+
mat.wait().await;
383
+
384
+
mat.player_join(2).await;
385
+
386
+
mat.wait().await;
387
+
388
+
mat.assert_all_states(|i, s| {
389
+
for j in 0..=2 {
390
+
assert!(
391
+
s.teams.contains_key(&mat.uuids[j]),
392
+
"{i} doesn't have {j}'s uuid in teams"
393
+
);
394
+
assert!(
395
+
s.profiles.contains_key(&mat.uuids[j]),
396
+
"{i} doesn't have {j}'s uuid in profiles"
397
+
);
398
+
assert_eq!(
399
+
s.teams.get(&mat.uuids[0]).copied(),
400
+
Some(true),
401
+
"{i} doesn't see 0 as a seeker"
402
+
)
403
+
}
404
+
})
405
+
.await;
406
+
}
407
+
408
+
#[test]
409
+
async fn test_team_switch() {
410
+
let mat = MockLobbyPool::new(3);
411
+
412
+
mat.start_all_loops().await;
413
+
414
+
mat.lobbies[2].switch_teams(true).await;
415
+
416
+
mat.wait().await;
417
+
418
+
mat.assert_all_states(|i, s| {
419
+
assert_eq!(
420
+
s.teams.get(&mat.uuids[2]).copied(),
421
+
Some(true),
422
+
"{i} ({}) does not see 2 as a seeker",
423
+
mat.uuids[i]
424
+
);
425
+
})
426
+
.await;
427
+
}
428
+
429
+
#[test]
430
+
async fn test_update_settings() {
431
+
let mat = MockLobbyPool::new(2);
432
+
433
+
mat.start_all_loops().await;
434
+
435
+
let mut settings = GameSettings::default();
436
+
const UPDATED_ID: u32 = 284829;
437
+
settings.hiding_time_seconds = UPDATED_ID;
438
+
439
+
mat.lobbies[0].update_settings(settings).await;
440
+
441
+
mat.wait().await;
442
+
443
+
mat.assert_all_states(|i, s| {
444
+
assert_eq!(
445
+
s.settings.hiding_time_seconds, UPDATED_ID,
446
+
"{i} ({}) did not get updated settings",
447
+
mat.uuids[i]
448
+
)
449
+
})
450
+
.await;
451
+
}
452
+
453
+
#[test]
454
+
async fn test_update_settings_not_host() {
455
+
let mat = MockLobbyPool::new(2);
456
+
457
+
mat.start_all_loops().await;
458
+
459
+
let mut settings = GameSettings::default();
460
+
let target = settings.hiding_time_seconds;
461
+
const UPDATED_ID: u32 = 284829;
462
+
settings.hiding_time_seconds = UPDATED_ID;
463
+
464
+
mat.lobbies[1].update_settings(settings).await;
465
+
466
+
mat.wait().await;
467
+
468
+
mat.assert_all_states(|i, s| {
469
+
assert_eq!(
470
+
s.settings.hiding_time_seconds, target,
471
+
"{i} ({}) updated settings despite 1 not being host",
472
+
mat.uuids[i]
473
+
)
474
+
})
475
+
.await;
476
+
}
477
+
478
+
#[test]
479
+
async fn test_game_start() {
480
+
let mat = MockLobbyPool::new(4);
481
+
482
+
let recvs = mat.start_all_loops().await;
483
+
484
+
for i in 0..3 {
485
+
mat.player_join(i).await;
486
+
}
487
+
488
+
mat.lobbies[2].switch_teams(true).await;
489
+
490
+
let settings = GameSettings {
491
+
hiding_time_seconds: 45,
492
+
..Default::default()
493
+
};
494
+
495
+
mat.lobbies[0].update_settings(settings).await;
496
+
497
+
mat.lobbies[3].quit_lobby().await;
498
+
499
+
mat.wait().await;
500
+
501
+
mat.lobbies[0].start_game().await;
502
+
503
+
mat.wait().await;
504
+
505
+
for (i, recv) in recvs.into_iter().enumerate() {
506
+
let res = recv.await.expect("Failed to recv");
507
+
match res {
508
+
Ok(Some(StartGameInfo {
509
+
settings,
510
+
initial_caught_state,
511
+
})) => {
512
+
assert_eq!(
513
+
settings.hiding_time_seconds, 45,
514
+
"Lobby {i} does not match pushed settings"
515
+
);
516
+
assert_eq!(
517
+
initial_caught_state.len(),
518
+
3,
519
+
"Lobby {i} does not have 3 entries in caught state"
520
+
);
521
+
assert_eq!(
522
+
initial_caught_state.get(&mat.uuids[2]).copied(),
523
+
Some(true),
524
+
"Lobby {i} does not see 2 as a seeker"
525
+
);
526
+
assert!(
527
+
initial_caught_state.keys().all(|id| *id != mat.uuids[3]),
528
+
"Lobby {i} still has a disconnected player saved in caught state"
529
+
);
530
+
let profiles = mat.lobbies[i].clone_profiles().await;
531
+
assert_eq!(
532
+
profiles.len(),
533
+
3,
534
+
"Lobby {i} does not have 3 entries in profiles"
535
+
);
536
+
assert!(
537
+
profiles.keys().all(|id| *id != mat.uuids[3]),
538
+
"Lobby {i} still has a disconnected player saved in profiles"
539
+
);
540
+
}
541
+
Ok(None) => {
542
+
if i != 3 {
543
+
panic!("Lobby {i} did not exit with start info");
544
+
}
545
+
}
546
+
Err(why) => {
547
+
panic!("Lobby {i} had an error: {why:?}");
548
+
}
549
+
}
550
+
}
551
+
}
552
+
553
+
#[test]
554
+
async fn test_drop_player() {
555
+
let mat = MockLobbyPool::new(3);
556
+
557
+
let mut recvs = mat.start_all_loops().await;
558
+
559
+
mat.lobbies[1].quit_lobby().await;
560
+
561
+
let res = recvs.swap_remove(1).await.expect("Failed to recv");
562
+
assert!(res.is_ok_and(|o| o.is_none()), "1 did not quit gracefully");
563
+
564
+
mat.wait().await;
565
+
566
+
assert!(
567
+
mat.lobbies[1].transport.is_disconnected(),
568
+
"1 is not disconnected"
569
+
);
570
+
571
+
let id = mat.uuids[1];
572
+
573
+
mat.assert_all_states(|i, s| {
574
+
if mat.uuids[i] != id {
575
+
assert!(
576
+
!s.teams.contains_key(&id),
577
+
"{} has not been removed 1 from teams",
578
+
i
579
+
);
580
+
assert!(
581
+
!s.profiles.contains_key(&id),
582
+
"{} has not been removed 1 from profiles",
583
+
i
584
+
);
585
+
}
586
+
})
587
+
.await;
588
}
589
}
+2
-2
manhunt-logic/src/profile.rs
+2
-2
manhunt-logic/src/profile.rs
+35
-12
manhunt-logic/src/tests.rs
+35
-12
manhunt-logic/src/tests.rs
···
1
use std::{collections::HashMap, sync::Arc};
2
3
-
use tokio::sync::{Mutex, mpsc};
4
use uuid::Uuid;
5
6
use crate::{
···
24
.map(|_| uuid::Uuid::new_v4())
25
.collect::<Vec<_>>();
26
let channels = (0..players)
27
-
.map(|_| tokio::sync::mpsc::channel(10))
28
.collect::<Vec<_>>();
29
let txs = channels
30
.iter()
···
41
(uuids, transports)
42
}
43
44
fn new(id: Uuid, rx: GameEventRx, txs: HashMap<Uuid, GameEventTx>) -> Self {
45
Self {
46
id,
···
63
async fn disconnect(&self) {
64
self.send_message(TransportMessage::PeerDisconnect(self.id))
65
.await;
66
}
67
68
async fn receive_messages(&self) -> impl Iterator<Item = MsgPair> {
···
74
75
async fn send_message(&self, msg: TransportMessage) {
76
for (_id, tx) in self.txs.iter().filter(|(id, _)| **id != self.id) {
77
-
tx.send((Some(self.id), msg.clone()))
78
-
.await
79
-
.expect("Failed to send msg");
80
}
81
}
82
83
async fn send_message_single(&self, peer: Uuid, msg: TransportMessage) {
84
if let Some(tx) = self.txs.get(&peer) {
85
-
tx.send((Some(self.id), msg))
86
-
.await
87
-
.expect("Failed to send msg");
88
}
89
}
90
91
async fn send_self(&self, msg: TransportMessage) {
92
-
self.txs[&self.id]
93
-
.send((Some(self.id), msg))
94
-
.await
95
-
.expect("Failed to send msg");
96
}
97
98
fn self_id(&self) -> Uuid {
···
1
use std::{collections::HashMap, sync::Arc};
2
3
+
use tokio::{
4
+
sync::{Mutex, mpsc},
5
+
task::yield_now,
6
+
};
7
use uuid::Uuid;
8
9
use crate::{
···
27
.map(|_| uuid::Uuid::new_v4())
28
.collect::<Vec<_>>();
29
let channels = (0..players)
30
+
.map(|_| tokio::sync::mpsc::channel(20))
31
.collect::<Vec<_>>();
32
let txs = channels
33
.iter()
···
44
(uuids, transports)
45
}
46
47
+
pub async fn wait_for_queue_empty(&self) {
48
+
// println!("Waiting for {} queue to empty", self.id);
49
+
loop {
50
+
let all_empty = self
51
+
.txs
52
+
.values()
53
+
.all(|tx| tx.is_closed() || tx.capacity() == tx.max_capacity());
54
+
55
+
if all_empty {
56
+
break;
57
+
} else {
58
+
yield_now().await;
59
+
}
60
+
}
61
+
}
62
+
63
+
pub async fn fake_join(&self) {
64
+
self.send_message(TransportMessage::PeerConnect(self.id))
65
+
.await;
66
+
}
67
+
68
+
pub fn is_disconnected(&self) -> bool {
69
+
self.txs[&self.id].is_closed()
70
+
}
71
+
72
fn new(id: Uuid, rx: GameEventRx, txs: HashMap<Uuid, GameEventTx>) -> Self {
73
Self {
74
id,
···
91
async fn disconnect(&self) {
92
self.send_message(TransportMessage::PeerDisconnect(self.id))
93
.await;
94
+
let mut rx = self.rx.lock().await;
95
+
rx.close();
96
}
97
98
async fn receive_messages(&self) -> impl Iterator<Item = MsgPair> {
···
104
105
async fn send_message(&self, msg: TransportMessage) {
106
for (_id, tx) in self.txs.iter().filter(|(id, _)| **id != self.id) {
107
+
tx.send((Some(self.id), msg.clone())).await.ok();
108
}
109
}
110
111
async fn send_message_single(&self, peer: Uuid, msg: TransportMessage) {
112
if let Some(tx) = self.txs.get(&peer) {
113
+
tx.send((Some(self.id), msg)).await.ok();
114
}
115
}
116
117
async fn send_self(&self, msg: TransportMessage) {
118
+
self.txs[&self.id].send((Some(self.id), msg)).await.ok();
119
}
120
121
fn self_id(&self) -> Uuid {
+113
-110
manhunt-transport/src/matchbox.rs
+113
-110
manhunt-transport/src/matchbox.rs
···
1
-
use std::{pin::Pin, sync::Arc, time::Duration};
2
3
use anyhow::{Context, anyhow};
4
-
use futures::FutureExt;
5
-
use log::error;
6
use matchbox_socket::{Error as SocketError, PeerId, PeerState, WebRtcSocket};
7
use tokio::{
8
sync::{Mutex, mpsc},
···
22
pub struct MatchboxTransport {
23
my_id: Uuid,
24
incoming: Queue,
25
-
outgoing: Queue,
26
cancel_token: CancellationToken,
27
}
28
29
type LoopFutRes = Result<(), SocketError>;
30
31
fn map_socket_error(err: SocketError) -> anyhow::Error {
32
match err {
···
38
impl MatchboxTransport {
39
pub async fn new(join_code: &str, is_host: bool) -> Result<Arc<Self>> {
40
let (itx, irx) = mpsc::channel(15);
41
-
let (otx, orx) = mpsc::channel(15);
42
43
let ws_url = server::room_url(join_code, is_host);
44
45
let (mut socket, mut loop_fut) = WebRtcSocket::new_reliable(&ws_url);
46
47
let res = loop {
48
tokio::select! {
49
id = Self::wait_for_id(&mut socket) => {
50
if let Some(id) = id {
51
-
break Ok(id);
52
}
53
},
54
res = &mut loop_fut => {
···
66
let transport = Arc::new(Self {
67
my_id,
68
incoming: (itx, Mutex::new(irx)),
69
-
outgoing: (otx, Mutex::new(orx)),
70
cancel_token: CancellationToken::new(),
71
});
72
73
tokio::spawn({
74
let transport = transport.clone();
75
async move {
76
-
transport.main_loop(socket, loop_fut).await;
77
}
78
});
79
80
Ok(transport)
81
}
82
Err(why) => {
83
drop(socket);
84
-
loop_fut.await.context("While disconnecting")?;
85
Err(why)
86
}
87
}
···
104
.expect("Failed to push to incoming queue");
105
}
106
107
-
async fn push_many_incoming(&self, msgs: Vec<MsgPair>) {
108
-
let senders = self
109
-
.incoming
110
-
.0
111
-
.reserve_many(msgs.len())
112
-
.await
113
-
.expect("Failed to reserve in incoming queue");
114
-
115
-
for (sender, msg) in senders.into_iter().zip(msgs.into_iter()) {
116
-
sender.send(msg);
117
-
}
118
-
}
119
-
120
async fn main_loop(
121
&self,
122
mut socket: WebRtcSocket,
123
loop_fut: Pin<Box<dyn Future<Output = LoopFutRes> + Send + 'static>>,
124
) {
125
-
let loop_fut = async {
126
-
let msg = match loop_fut.await {
127
-
Ok(_) => TransportMessage::Disconnected,
128
-
Err(e) => {
129
-
let msg = map_socket_error(e).to_string();
130
-
TransportMessage::Error(msg)
131
-
}
132
-
};
133
-
self.push_incoming(None, msg).await;
134
-
}
135
-
.fuse();
136
-
137
tokio::pin!(loop_fut);
138
-
139
-
let mut interval = tokio::time::interval(Duration::from_secs(1));
140
-
141
-
let mut outgoing_rx = self.outgoing.1.lock().await;
142
-
const MAX_MSG_SEND: usize = 30;
143
-
let mut message_buffer = Vec::with_capacity(MAX_MSG_SEND);
144
-
145
let mut packet_handler = PacketHandler::default();
146
147
-
loop {
148
-
self.handle_peers(&mut socket).await;
149
150
-
self.handle_recv(&mut socket, &mut packet_handler).await;
151
-
152
tokio::select! {
153
biased;
154
155
-
_ = self.cancel_token.cancelled() => {
156
-
break;
157
}
158
159
-
_ = &mut loop_fut => {
160
-
break;
161
}
162
163
-
_ = outgoing_rx.recv_many(&mut message_buffer, MAX_MSG_SEND) => {
164
-
let peers = socket.connected_peers().collect::<Vec<_>>();
165
-
self.handle_send(&mut socket, &peers, &mut message_buffer).await;
166
}
167
168
-
_ = interval.tick() => {
169
-
continue;
170
}
171
}
172
}
173
}
174
175
-
async fn handle_peers(&self, socket: &mut WebRtcSocket) {
176
-
for (peer, state) in socket.update_peers() {
177
-
let msg = match state {
178
-
PeerState::Connected => TransportMessage::PeerConnect(peer.0),
179
-
PeerState::Disconnected => TransportMessage::PeerDisconnect(peer.0),
180
-
};
181
-
self.push_incoming(Some(peer.0), msg).await;
182
-
}
183
}
184
185
-
async fn handle_send(
186
&self,
187
-
socket: &mut WebRtcSocket,
188
-
all_peers: &[PeerId],
189
-
messages: &mut Vec<MsgPair>,
190
) {
191
-
let encoded_messages = messages.drain(..).filter_map(|(id, msg)| {
192
-
match PacketHandler::message_to_packets(&msg) {
193
-
Ok(packets) => Some((id, packets)),
194
-
Err(why) => {
195
-
error!("Error encoding message to packets: {why:?}");
196
-
None
197
-
}
198
}
199
-
});
200
201
-
let channel = socket.channel_mut(0);
202
203
-
for (peer, packets) in encoded_messages {
204
-
if let Some(peer) = peer {
205
-
for packet in packets {
206
-
channel.send(packet.into_boxed_slice(), PeerId(peer));
207
-
}
208
-
} else {
209
-
for packet in packets {
210
-
let boxed = packet.into_boxed_slice();
211
-
for peer in all_peers {
212
-
channel.send(boxed.clone(), *peer);
213
}
214
}
215
}
216
}
217
-
}
218
-
219
-
async fn handle_recv(&self, socket: &mut WebRtcSocket, handler: &mut PacketHandler) {
220
-
let data = socket.channel_mut(0).receive();
221
-
let messages = data
222
-
.into_iter()
223
-
.filter_map(
224
-
|(peer, bytes)| match handler.consume_packet(peer.0, bytes.into_vec()) {
225
-
Ok(msg) => msg.map(|msg| (Some(peer.0), msg)),
226
-
Err(why) => {
227
-
error!("Error receiving message: {why}");
228
-
None
229
-
}
230
-
},
231
-
)
232
-
.collect();
233
-
self.push_many_incoming(messages).await;
234
-
}
235
-
236
-
pub async fn send_transport_message(&self, peer: Option<Uuid>, msg: TransportMessage) {
237
-
self.outgoing
238
-
.0
239
-
.send((peer, msg))
240
-
.await
241
-
.expect("Failed to add to outgoing queue");
242
}
243
244
pub async fn recv_transport_messages(&self) -> Vec<MsgPair> {
···
1
+
use std::{collections::HashSet, pin::Pin, sync::Arc};
2
3
use anyhow::{Context, anyhow};
4
+
use futures::{
5
+
SinkExt, StreamExt,
6
+
channel::mpsc::{UnboundedReceiver, UnboundedSender},
7
+
};
8
+
use log::{error, info};
9
use matchbox_socket::{Error as SocketError, PeerId, PeerState, WebRtcSocket};
10
use tokio::{
11
sync::{Mutex, mpsc},
···
25
pub struct MatchboxTransport {
26
my_id: Uuid,
27
incoming: Queue,
28
+
all_peers: Mutex<HashSet<Uuid>>,
29
+
msg_sender: UnboundedSender<MatchboxMsgPair>,
30
cancel_token: CancellationToken,
31
}
32
33
type LoopFutRes = Result<(), SocketError>;
34
+
35
+
type MatchboxMsgPair = (PeerId, Box<[u8]>);
36
37
fn map_socket_error(err: SocketError) -> anyhow::Error {
38
match err {
···
44
impl MatchboxTransport {
45
pub async fn new(join_code: &str, is_host: bool) -> Result<Arc<Self>> {
46
let (itx, irx) = mpsc::channel(15);
47
48
let ws_url = server::room_url(join_code, is_host);
49
50
let (mut socket, mut loop_fut) = WebRtcSocket::new_reliable(&ws_url);
51
52
+
let (mtx, mrx) = socket
53
+
.take_channel(0)
54
+
.expect("Failed to get channel")
55
+
.split();
56
+
57
let res = loop {
58
tokio::select! {
59
id = Self::wait_for_id(&mut socket) => {
60
if let Some(id) = id {
61
+
break Ok(id);
62
}
63
},
64
res = &mut loop_fut => {
···
76
let transport = Arc::new(Self {
77
my_id,
78
incoming: (itx, Mutex::new(irx)),
79
+
all_peers: Mutex::new(HashSet::with_capacity(5)),
80
+
msg_sender: mtx.clone(),
81
cancel_token: CancellationToken::new(),
82
});
83
84
tokio::spawn({
85
let transport = transport.clone();
86
async move {
87
+
transport.main_loop(socket, loop_fut, mrx).await;
88
}
89
});
90
91
Ok(transport)
92
}
93
Err(why) => {
94
+
drop(mrx);
95
+
mtx.close_channel();
96
drop(socket);
97
Err(why)
98
}
99
}
···
116
.expect("Failed to push to incoming queue");
117
}
118
119
async fn main_loop(
120
&self,
121
mut socket: WebRtcSocket,
122
loop_fut: Pin<Box<dyn Future<Output = LoopFutRes> + Send + 'static>>,
123
+
mut mrx: UnboundedReceiver<MatchboxMsgPair>,
124
) {
125
tokio::pin!(loop_fut);
126
let mut packet_handler = PacketHandler::default();
127
128
+
info!("Starting transport loop");
129
130
+
let (should_await, msg) = loop {
131
tokio::select! {
132
biased;
133
134
+
res = &mut loop_fut => {
135
+
info!("Transport-initiated disconnect");
136
+
break (false, match res {
137
+
Ok(_) => TransportMessage::Disconnected,
138
+
Err(e) => {
139
+
let msg = map_socket_error(e).to_string();
140
+
TransportMessage::Error(msg)
141
+
}
142
+
});
143
}
144
145
+
_ = self.cancel_token.cancelled() => {
146
+
info!("Logic-initiated disconnect");
147
+
break (true, TransportMessage::Disconnected);
148
}
149
150
+
Some((peer, state)) = socket.next() => {
151
+
info!("Handling peer {peer}: {state:?}");
152
+
self.handle_peer(peer, state).await;
153
}
154
155
+
Some(data) = mrx.next() => {
156
+
info!("Handling new packet from {}", data.0);
157
+
self.handle_recv(data, &mut packet_handler).await;
158
}
159
+
160
+
161
+
}
162
+
};
163
+
164
+
self.push_incoming(Some(self.my_id), msg).await;
165
+
166
+
self.msg_sender.close_channel();
167
+
drop(mrx);
168
+
socket.try_update_peers().ok();
169
+
drop(socket);
170
+
if should_await {
171
+
if let Err(why) = loop_fut.await {
172
+
error!("Failed to await after disconnect: {why:?}");
173
}
174
}
175
+
info!("Transport disconnected");
176
}
177
178
+
async fn handle_peer(&self, peer: PeerId, state: PeerState) {
179
+
let mut all_peers = self.all_peers.lock().await;
180
+
let msg = match state {
181
+
PeerState::Connected => {
182
+
all_peers.insert(peer.0);
183
+
TransportMessage::PeerConnect(peer.0)
184
+
}
185
+
PeerState::Disconnected => {
186
+
all_peers.remove(&peer.0);
187
+
TransportMessage::PeerDisconnect(peer.0)
188
+
}
189
+
};
190
+
drop(all_peers);
191
+
self.push_incoming(Some(peer.0), msg).await;
192
}
193
194
+
async fn handle_recv(
195
&self,
196
+
(PeerId(peer), packet): MatchboxMsgPair,
197
+
handler: &mut PacketHandler,
198
) {
199
+
match handler.consume_packet(peer, packet.into_vec()) {
200
+
Ok(Some(msg)) => {
201
+
self.push_incoming(Some(peer), msg).await;
202
}
203
+
Ok(None) => {
204
+
// Non complete message
205
+
}
206
+
Err(why) => {
207
+
error!("Error receiving message: {why}");
208
+
}
209
+
}
210
+
}
211
212
+
pub async fn send_transport_message(&self, peer: Option<Uuid>, msg: TransportMessage) {
213
+
let mut tx = self.msg_sender.clone();
214
215
+
match PacketHandler::message_to_packets(&msg) {
216
+
Ok(packets) => {
217
+
if let Some(peer) = peer {
218
+
let mut stream = futures::stream::iter(
219
+
packets
220
+
.into_iter()
221
+
.map(|p| Ok((PeerId(peer), p.into_boxed_slice()))),
222
+
);
223
+
if let Err(why) = tx.send_all(&mut stream).await {
224
+
error!("Error sending packet: {why}");
225
+
}
226
+
} else {
227
+
let all_peers = self.all_peers.lock().await;
228
+
for peer in all_peers.iter().copied() {
229
+
let packets = packets.clone();
230
+
let mut stream = futures::stream::iter(
231
+
packets
232
+
.into_iter()
233
+
.map(|p| Ok((PeerId(peer), p.into_boxed_slice()))),
234
+
);
235
+
if let Err(why) = tx.send_all(&mut stream).await {
236
+
error!("Error sending packet: {why}");
237
+
}
238
}
239
}
240
}
241
+
Err(why) => {
242
+
error!("Error encoding message: {why}");
243
+
}
244
}
245
}
246
247
pub async fn recv_transport_messages(&self) -> Vec<MsgPair> {
+1
-3
manhunt-transport/src/packets.rs
+1
-3
manhunt-transport/src/packets.rs
···
1
use std::collections::HashMap;
2
3
use anyhow::{anyhow, bail};
4
-
use manhunt_logic::{prelude::*, TransportMessage};
5
use serde::{Deserialize, Serialize};
6
use uuid::Uuid;
7
···
174
assert_eq!(data.len(), 1);
175
176
let data = data.into_iter().next().unwrap();
177
-
178
-
println!("dat: {data:?}");
179
180
let decoded = handler
181
.consume_packet(Uuid::default(), data)
···
1
use std::collections::HashMap;
2
3
use anyhow::{anyhow, bail};
4
+
use manhunt_logic::{TransportMessage, prelude::*};
5
use serde::{Deserialize, Serialize};
6
use uuid::Uuid;
7
···
174
assert_eq!(data.len(), 1);
175
176
let data = data.into_iter().next().unwrap();
177
178
let decoded = handler
179
.consume_packet(Uuid::default(), data)