feat: CS 枪火对决 —— Rust 权威服务端 + 手写 WebGL 前端的第一人称 1v1 对枪
- 服务端 60Hz 固定步长模拟:重力/摩擦/轴分离碰撞/上台阶,客户端预测回滚 - 命中裁决:射线打墙打人(身体 + 头部盒),射速/弹匣/换弹/伤害/比分全在服务端 - 回合制:3 秒准备、先到 8 分、100 秒平局;观战自由视角 - 机器人陪练:视线检测 + 反应延迟 + 点射偏差,能单人开练 - 前端零依赖:手写 WebGL(程序化贴图、地图合批、粒子、曳光弹、假投影、黄昏天空) - 2D Canvas 枪模 + WebAudio 合成音效,无任何图片/音频/CDN 资源 - 地图 level.json 前后端同源,tools/gen_level.py 四分镜像生成,绝对对称 - 测试:14 组规则单测 + 6 组联机 e2e
This commit is contained in:
commit
00d63ba736
32 files changed
+8599
No files matched your search
+1167
File diff suppressed because it is too large.
Load diff
+153
@@ -0,0 +1,153 @@
|
||||
//! 地图:一堆轴对齐方块(AABB)。碰撞、视线、子弹射线都基于它。
|
||||
//!
|
||||
//! 地图数据是 `public/level.json`,前后端共用同一份,编译期就嵌进二进制。
|
||||
//! 生成脚本见 `tools/gen_level.py`(只写四分之一,镜像出整张图,保证绝对对称)。
|
||||
|
||||
use std::sync::OnceLock;
|
||||
|
||||
use serde::Deserialize;
|
||||
|
||||
use crate::math::{de_arr, V3};
|
||||
|
||||
#[derive(Clone, Copy, Debug, Deserialize)]
|
||||
pub struct Block {
|
||||
#[serde(deserialize_with = "de_arr")]
|
||||
pub min: V3,
|
||||
#[serde(deserialize_with = "de_arr")]
|
||||
pub max: V3,
|
||||
pub mat: u8,
|
||||
}
|
||||
|
||||
impl Block {
|
||||
/// 射线与方块求交(slab 法)。返回命中距离(沿单位方向)
|
||||
pub fn ray(&self, o: V3, d: V3, max_t: f32) -> Option<f32> {
|
||||
ray_box(o, d, self.min, self.max, max_t)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn overlaps(&self, min: V3, max: V3) -> bool {
|
||||
self.min.x < max.x
|
||||
&& self.max.x > min.x
|
||||
&& self.min.y < max.y
|
||||
&& self.max.y > min.y
|
||||
&& self.min.z < max.z
|
||||
&& self.max.z > min.z
|
||||
}
|
||||
}
|
||||
|
||||
/// 射线与任意 AABB 求交(slab 法),返回最近命中距离(d 需为单位向量)
|
||||
pub fn ray_box(o: V3, d: V3, min: V3, max: V3, max_t: f32) -> Option<f32> {
|
||||
let mut t0 = 0.0f32;
|
||||
let mut t1 = max_t;
|
||||
for i in 0..3 {
|
||||
let oi = o.axis(i);
|
||||
let di = d.axis(i);
|
||||
let mn = min.axis(i);
|
||||
let mx = max.axis(i);
|
||||
if di.abs() < 1e-8 {
|
||||
if oi < mn || oi > mx {
|
||||
return None;
|
||||
}
|
||||
} else {
|
||||
let inv = 1.0 / di;
|
||||
let mut ta = (mn - oi) * inv;
|
||||
let mut tb = (mx - oi) * inv;
|
||||
if ta > tb {
|
||||
std::mem::swap(&mut ta, &mut tb);
|
||||
}
|
||||
t0 = t0.max(ta);
|
||||
t1 = t1.min(tb);
|
||||
if t0 > t1 {
|
||||
return None;
|
||||
}
|
||||
}
|
||||
}
|
||||
if t0 <= max_t {
|
||||
Some(t0)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Deserialize)]
|
||||
pub struct Spawn { #[serde(deserialize_with = "de_arr")]
|
||||
pub pos: V3,
|
||||
pub yaw: f32,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize)]
|
||||
struct RawLevel {
|
||||
name: String,
|
||||
#[serde(default = "default_size")]
|
||||
size: f32,
|
||||
spawns: Vec<Spawn>,
|
||||
boxes: Vec<Block>,
|
||||
}
|
||||
|
||||
fn default_size() -> f32 {
|
||||
48.0
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct Level {
|
||||
pub name: String,
|
||||
pub size: f32,
|
||||
pub blocks: Vec<Block>,
|
||||
pub spawns: Vec<Spawn>,
|
||||
}
|
||||
|
||||
impl Level {
|
||||
pub fn parse(json: &str) -> Level {
|
||||
let raw: RawLevel = serde_json::from_str(json).expect("level.json 格式错误");
|
||||
assert!(raw.spawns.len() >= 2, "level.json 至少要有两个出生点");
|
||||
assert!(!raw.boxes.is_empty(), "level.json 没有方块");
|
||||
Level {
|
||||
name: raw.name,
|
||||
size: raw.size,
|
||||
blocks: raw.boxes,
|
||||
// level.json 里写的是角度,运行时统一用弧度
|
||||
spawns: raw
|
||||
.spawns
|
||||
.into_iter()
|
||||
.map(|s| Spawn {
|
||||
pos: s.pos,
|
||||
yaw: s.yaw.to_radians(),
|
||||
})
|
||||
.collect(),
|
||||
}
|
||||
}
|
||||
|
||||
/// 内嵌地图(只解析一次)
|
||||
pub fn embedded() -> &'static Level {
|
||||
static LEVEL: OnceLock<Level> = OnceLock::new();
|
||||
LEVEL.get_or_init(|| Level::parse(include_str!("../public/level.json")))
|
||||
}
|
||||
|
||||
/// 视线 / 子弹射线:返回最近的墙面命中距离
|
||||
pub fn ray(&self, o: V3, d: V3, max_t: f32) -> Option<f32> {
|
||||
let mut best = max_t;
|
||||
let mut hit = false;
|
||||
for b in &self.blocks {
|
||||
if let Some(t) = b.ray(o, d, best) {
|
||||
if t < best {
|
||||
best = t;
|
||||
hit = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
if hit {
|
||||
Some(best)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
/// 一个 AABB 是否卡进地图
|
||||
pub fn overlaps(&self, min: V3, max: V3) -> bool {
|
||||
self.blocks.iter().any(|b| b.overlaps(min, max))
|
||||
}
|
||||
|
||||
pub fn spawn(&self, slot: usize) -> Spawn {
|
||||
self.spawns[slot % self.spawns.len()]
|
||||
}
|
||||
}
|
||||
+17
@@ -0,0 +1,17 @@
|
||||
//! CS · 枪火对决:Rust 权威服务端 + 纯静态 WebGL 前端
|
||||
//!
|
||||
//! - [`math`] 三维向量与角度
|
||||
//! - [`level`] 地图(AABB 方块)与射线
|
||||
//! - [`physics`] 移动物理(前端 movement.js 是镜像)
|
||||
//! - [`weapons`] 武器表(前端 weapons.js 是镜像)
|
||||
//! - [`game`] 房间状态机、命中裁决、机器人
|
||||
//! - [`protocol`] WebSocket 消息契约
|
||||
//! - [`server`] 房间管理、60Hz 模拟、静态资源
|
||||
|
||||
pub mod game;
|
||||
pub mod level;
|
||||
pub mod math;
|
||||
pub mod physics;
|
||||
pub mod protocol;
|
||||
pub mod server;
|
||||
pub mod weapons;
|
||||
+47
@@ -0,0 +1,47 @@
|
||||
use std::net::SocketAddr;
|
||||
|
||||
use tokio::net::TcpListener;
|
||||
|
||||
use cs::server::{self, App};
|
||||
|
||||
#[tokio::main]
|
||||
async fn main() {
|
||||
let port: u16 = std::env::var("PORT")
|
||||
.ok()
|
||||
.and_then(|v| v.parse().ok())
|
||||
.unwrap_or(3000);
|
||||
let host = std::env::var("HOST").unwrap_or_else(|_| "0.0.0.0".to_string());
|
||||
let addr: SocketAddr = match format!("{host}:{port}").parse() {
|
||||
Ok(a) => a,
|
||||
Err(_) => {
|
||||
eprintln!("地址不合法:{host}:{port}");
|
||||
std::process::exit(1);
|
||||
}
|
||||
};
|
||||
|
||||
let app = App::new();
|
||||
let listener = match TcpListener::bind(addr).await {
|
||||
Ok(l) => l,
|
||||
Err(e) => {
|
||||
eprintln!("端口 {port} 起不来:{e}");
|
||||
std::process::exit(1);
|
||||
}
|
||||
};
|
||||
|
||||
let level = cs::level::Level::embedded();
|
||||
println!();
|
||||
println!(" CS · 枪火对决 已启动");
|
||||
println!(" 运行方式 Rust 权威服务端(前端资源已内嵌,单文件二进制)");
|
||||
println!(" 地图 {}({} 个方块)", level.name, level.blocks.len());
|
||||
println!(" 模拟 60Hz 物理 / 30Hz 快照");
|
||||
println!(" 本机访问 http://localhost:{port}");
|
||||
for ip in server::lan_addrs() {
|
||||
println!(" 同一局域网 http://{ip}:{port}");
|
||||
}
|
||||
println!();
|
||||
|
||||
if let Err(e) = server::serve(listener, app).await {
|
||||
eprintln!("服务异常退出:{e}");
|
||||
std::process::exit(1);
|
||||
}
|
||||
}
|
||||
+125
@@ -0,0 +1,125 @@
|
||||
//! 三维向量与角度工具(不用第三方数学库,保持依赖精简)
|
||||
|
||||
use serde::Deserialize;
|
||||
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq)]
|
||||
pub struct V3 {
|
||||
pub x: f32,
|
||||
pub y: f32,
|
||||
pub z: f32,
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub const fn v3(x: f32, y: f32, z: f32) -> V3 {
|
||||
V3 { x, y, z }
|
||||
}
|
||||
|
||||
impl V3 {
|
||||
pub const ZERO: V3 = v3(0.0, 0.0, 0.0);
|
||||
|
||||
#[inline]
|
||||
pub fn add(self, o: V3) -> V3 {
|
||||
v3(self.x + o.x, self.y + o.y, self.z + o.z)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn sub(self, o: V3) -> V3 {
|
||||
v3(self.x - o.x, self.y - o.y, self.z - o.z)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn scale(self, k: f32) -> V3 {
|
||||
v3(self.x * k, self.y * k, self.z * k)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn dot(self, o: V3) -> f32 {
|
||||
self.x * o.x + self.y * o.y + self.z * o.z
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn len(self) -> f32 {
|
||||
self.dot(self).sqrt()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn flat_len(self) -> f32 {
|
||||
(self.x * self.x + self.z * self.z).sqrt()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn norm(self) -> V3 {
|
||||
let l = self.len();
|
||||
if l < 1e-8 {
|
||||
V3::ZERO
|
||||
} else {
|
||||
self.scale(1.0 / l)
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn arr(self) -> [f32; 3] {
|
||||
[self.x, self.y, self.z]
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn axis(self, i: usize) -> f32 {
|
||||
match i {
|
||||
0 => self.x,
|
||||
1 => self.y,
|
||||
_ => self.z,
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn set_axis(&mut self, i: usize, v: f32) {
|
||||
match i {
|
||||
0 => self.x = v,
|
||||
1 => self.y = v,
|
||||
_ => self.z = v,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<[f32; 3]> for V3 {
|
||||
fn from(a: [f32; 3]) -> V3 {
|
||||
v3(a[0], a[1], a[2])
|
||||
}
|
||||
}
|
||||
|
||||
/// 视线方向:yaw=0 看向 -z,yaw 增大向右转(+x),pitch 上正下负
|
||||
pub fn forward(yaw: f32, pitch: f32) -> V3 {
|
||||
let cp = pitch.cos();
|
||||
v3(cp * yaw.sin(), pitch.sin(), -cp * yaw.cos())
|
||||
}
|
||||
|
||||
/// 水平前方(移动用)
|
||||
pub fn flat_forward(yaw: f32) -> V3 {
|
||||
v3(yaw.sin(), 0.0, -yaw.cos())
|
||||
}
|
||||
|
||||
/// 水平右方
|
||||
pub fn right(yaw: f32) -> V3 {
|
||||
v3(yaw.cos(), 0.0, yaw.sin())
|
||||
}
|
||||
|
||||
/// 把角度收进 [-PI, PI]
|
||||
pub fn wrap_angle(mut a: f32) -> f32 {
|
||||
use std::f32::consts::PI;
|
||||
while a > PI {
|
||||
a -= 2.0 * PI;
|
||||
}
|
||||
while a < -PI {
|
||||
a += 2.0 * PI;
|
||||
}
|
||||
a
|
||||
}
|
||||
|
||||
/// 反序列化辅助:JSON 里的 [x,y,z]
|
||||
pub fn de_arr<'de, D>(d: D) -> Result<V3, D::Error>
|
||||
where
|
||||
D: serde::Deserializer<'de>,
|
||||
{
|
||||
let a = <[f32; 3]>::deserialize(d)?;
|
||||
Ok(V3::from(a))
|
||||
}
|
||||
+190
@@ -0,0 +1,190 @@
|
||||
//! 角色移动物理。**前端 `public/js/client/movement.js` 是这份代码的 JS 镜像**,
|
||||
//! 客户端预测用同一套常数和同样的积分顺序,服务端才是权威。
|
||||
//!
|
||||
//! 碰撞体是一个轴对齐盒子:x/z 半径 0.36,高 1.75,视点 1.62。
|
||||
//! 移动按轴分离解算(先 x、再 z、最后 y),撞到不高于 0.55 的台面会自动抬腿上去。
|
||||
|
||||
use crate::level::Level;
|
||||
use crate::math::{flat_forward, right, v3, V3};
|
||||
|
||||
pub const GRAVITY: f32 = 18.0;
|
||||
pub const JUMP_VEL: f32 = 6.2;
|
||||
pub const RUN_SPEED: f32 = 5.6;
|
||||
pub const WALK_SPEED: f32 = 2.7;
|
||||
pub const ACCEL_GROUND: f32 = 11.0;
|
||||
pub const ACCEL_AIR: f32 = 2.2;
|
||||
pub const FRICTION: f32 = 8.0;
|
||||
pub const RADIUS: f32 = 0.36;
|
||||
pub const HEIGHT: f32 = 1.75;
|
||||
pub const EYE: f32 = 1.62;
|
||||
pub const STEP_UP: f32 = 0.55;
|
||||
pub const MAX_FALL: f32 = 55.0;
|
||||
|
||||
pub const K_FWD: u8 = 1;
|
||||
pub const K_BACK: u8 = 2;
|
||||
pub const K_LEFT: u8 = 4;
|
||||
pub const K_RIGHT: u8 = 8;
|
||||
pub const K_JUMP: u8 = 16;
|
||||
pub const K_WALK: u8 = 32;
|
||||
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub struct Body {
|
||||
pub pos: V3,
|
||||
pub vel: V3,
|
||||
pub on_ground: bool,
|
||||
}
|
||||
|
||||
impl Body {
|
||||
pub fn new(pos: V3) -> Body {
|
||||
Body {
|
||||
pos,
|
||||
vel: V3::ZERO,
|
||||
on_ground: false,
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn eye(&self) -> V3 {
|
||||
self.pos.add(v3(0.0, EYE, 0.0))
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn bounds(&self) -> (V3, V3) {
|
||||
(
|
||||
v3(self.pos.x - RADIUS, self.pos.y, self.pos.z - RADIUS),
|
||||
v3(self.pos.x + RADIUS, self.pos.y + HEIGHT, self.pos.z + RADIUS),
|
||||
)
|
||||
}
|
||||
|
||||
fn blocker(&self, level: &Level) -> Option<crate::level::Block> {
|
||||
let (mn, mx) = self.bounds();
|
||||
level.blocks.iter().copied().find(|b| b.overlaps(mn, mx))
|
||||
}
|
||||
|
||||
/// 推进一帧。dt 固定 1/60,keys 见上面的 K_* 位
|
||||
pub fn step(&mut self, keys: u8, yaw: f32, level: &Level, dt: f32) {
|
||||
let mut wish = V3::ZERO;
|
||||
if keys & K_FWD != 0 {
|
||||
wish = wish.add(flat_forward(yaw));
|
||||
}
|
||||
if keys & K_BACK != 0 {
|
||||
wish = wish.sub(flat_forward(yaw));
|
||||
}
|
||||
if keys & K_RIGHT != 0 {
|
||||
wish = wish.add(right(yaw));
|
||||
}
|
||||
if keys & K_LEFT != 0 {
|
||||
wish = wish.sub(right(yaw));
|
||||
}
|
||||
|
||||
let max_speed = if keys & K_WALK != 0 {
|
||||
WALK_SPEED
|
||||
} else {
|
||||
RUN_SPEED
|
||||
};
|
||||
|
||||
if wish.flat_len() > 1e-4 {
|
||||
let wd = wish.norm();
|
||||
let accel = if self.on_ground {
|
||||
ACCEL_GROUND
|
||||
} else {
|
||||
ACCEL_AIR
|
||||
};
|
||||
let current = self.vel.x * wd.x + self.vel.z * wd.z;
|
||||
let add = (accel * max_speed * dt).min(max_speed - current).max(0.0);
|
||||
self.vel.x += wd.x * add;
|
||||
self.vel.z += wd.z * add;
|
||||
// 只靠加速分量收敛,不允许瞬间转向;速度上限由 add 的钳制保证
|
||||
} else if self.on_ground {
|
||||
let speed = self.vel.flat_len();
|
||||
if speed > 0.02 {
|
||||
let k = ((speed - FRICTION * dt) / speed).max(0.0);
|
||||
self.vel.x *= k;
|
||||
self.vel.z *= k;
|
||||
} else {
|
||||
self.vel.x = 0.0;
|
||||
self.vel.z = 0.0;
|
||||
}
|
||||
}
|
||||
|
||||
if keys & K_JUMP != 0 && self.on_ground {
|
||||
self.vel.y = JUMP_VEL;
|
||||
self.on_ground = false;
|
||||
}
|
||||
|
||||
self.vel.y = (self.vel.y - GRAVITY * dt).max(-MAX_FALL);
|
||||
|
||||
self.move_axis(0, self.vel.x * dt, level);
|
||||
self.move_axis(2, self.vel.z * dt, level);
|
||||
|
||||
self.on_ground = false;
|
||||
self.move_axis(1, self.vel.y * dt, level);
|
||||
|
||||
// 兜底:真卡进去了就往上顶到安全位置,别把玩家永久卡死在墙里
|
||||
let mut guard = 0;
|
||||
while self.blocker(level).is_some() && guard < 40 {
|
||||
self.pos.y += 0.1;
|
||||
guard += 1;
|
||||
}
|
||||
}
|
||||
|
||||
fn move_axis(&mut self, axis: usize, delta: f32, level: &Level) {
|
||||
if delta.abs() < 1e-6 {
|
||||
return;
|
||||
}
|
||||
let steps = ((delta.abs() / 0.2).ceil() as i32).max(1);
|
||||
let d = delta / steps as f32;
|
||||
for _ in 0..steps {
|
||||
self.pos.set_axis(axis, self.pos.axis(axis) + d);
|
||||
let Some(b) = self.blocker(level) else {
|
||||
continue;
|
||||
};
|
||||
|
||||
// 水平移动撞到矮台子:抬腿上去(台阶 / 矮箱子)
|
||||
if axis != 1 && b.max.y > self.pos.y && b.max.y - self.pos.y <= STEP_UP {
|
||||
let saved = self.pos;
|
||||
self.pos.y = b.max.y + 1e-3;
|
||||
if self.blocker(level).is_none() {
|
||||
continue;
|
||||
}
|
||||
self.pos = saved;
|
||||
}
|
||||
|
||||
match axis {
|
||||
0 => {
|
||||
self.pos.x = if d > 0.0 {
|
||||
b.min.x - RADIUS - 1e-3
|
||||
} else {
|
||||
b.max.x + RADIUS + 1e-3
|
||||
};
|
||||
self.vel.x = 0.0;
|
||||
}
|
||||
2 => {
|
||||
self.pos.z = if d > 0.0 {
|
||||
b.min.z - RADIUS - 1e-3
|
||||
} else {
|
||||
b.max.z + RADIUS + 1e-3
|
||||
};
|
||||
self.vel.z = 0.0;
|
||||
}
|
||||
_ => {
|
||||
if d <= 0.0 {
|
||||
self.pos.y = b.max.y;
|
||||
self.on_ground = true;
|
||||
} else {
|
||||
self.pos.y = b.min.y - HEIGHT - 1e-3;
|
||||
}
|
||||
self.vel.y = 0.0;
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// 视线是否通畅(bot 用)
|
||||
pub fn los(level: &Level, from: V3, to: V3) -> bool {
|
||||
let d = to.sub(from);
|
||||
let len = d.len();
|
||||
len > 1e-4 && level.ray(from, d.scale(1.0 / len), len - 0.2).is_none()
|
||||
}
|
||||
+224
@@ -0,0 +1,224 @@
|
||||
//! WebSocket 消息(前后端共用的 JSON 契约,前端见 public/js/client/net.js)
|
||||
//!
|
||||
//! 客户端 60Hz 发 input(按键位 + 视角),服务端 60Hz 模拟、30Hz 回快照。
|
||||
//! 命中、伤害、回合全部由服务端裁决,前端只做预测和表现。
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use crate::level::Level;
|
||||
|
||||
#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum Phase {
|
||||
Freeze,
|
||||
Live,
|
||||
Over,
|
||||
MatchOver,
|
||||
}
|
||||
|
||||
impl Phase {
|
||||
pub fn as_str(self) -> &'static str {
|
||||
match self {
|
||||
Phase::Freeze => "freeze",
|
||||
Phase::Live => "live",
|
||||
Phase::Over => "over",
|
||||
Phase::MatchOver => "matchOver",
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* ------------------------------- 客户端 -> 服务端 ------------------------------- */
|
||||
|
||||
#[derive(Debug, Deserialize)]
|
||||
#[serde(tag = "t")]
|
||||
pub enum ClientMsg {
|
||||
#[serde(rename = "create")]
|
||||
Create,
|
||||
#[serde(rename = "join")]
|
||||
Join {
|
||||
code: String,
|
||||
spectate: Option<bool>,
|
||||
},
|
||||
#[serde(rename = "input")]
|
||||
Input {
|
||||
seq: u32,
|
||||
keys: u8,
|
||||
yaw: f32,
|
||||
pitch: f32,
|
||||
#[serde(default)]
|
||||
fire: bool,
|
||||
#[serde(default)]
|
||||
reload: bool,
|
||||
#[serde(default)]
|
||||
weapon: Option<u8>,
|
||||
},
|
||||
#[serde(rename = "addBot")]
|
||||
AddBot,
|
||||
#[serde(rename = "rematch")]
|
||||
Rematch,
|
||||
#[serde(rename = "leave")]
|
||||
Leave,
|
||||
#[serde(rename = "ping")]
|
||||
Ping { id: u32 },
|
||||
}
|
||||
|
||||
/* ------------------------------- 服务端 -> 客户端 ------------------------------- */
|
||||
|
||||
fn is_false(b: &bool) -> bool {
|
||||
!*b
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct PlayerState {
|
||||
pub slot: u8,
|
||||
pub bot: bool,
|
||||
pub name: String,
|
||||
pub pos: [f32; 3],
|
||||
pub vel: [f32; 3],
|
||||
pub yaw: f32,
|
||||
pub pitch: f32,
|
||||
pub hp: i32,
|
||||
pub alive: bool,
|
||||
pub ground: bool,
|
||||
pub weapon: u8,
|
||||
pub mag: u32,
|
||||
pub reserve: u32,
|
||||
pub reloading: bool,
|
||||
/// 换弹剩余毫秒(0 = 没在换弹)
|
||||
pub reload_left: u32,
|
||||
#[serde(skip_serializing_if = "is_false")]
|
||||
pub firing: bool,
|
||||
pub kills: u32,
|
||||
pub deaths: u32,
|
||||
/// 已处理到第几号输入(客户端预测回滚用)
|
||||
pub ack: u32,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct Snap {
|
||||
pub tick: u32,
|
||||
pub phase: Phase,
|
||||
pub left_ms: u32,
|
||||
pub round_no: u32,
|
||||
pub score: [u32; 2],
|
||||
pub target: u32,
|
||||
pub players: Vec<PlayerState>,
|
||||
pub spectators: usize,
|
||||
pub paused: bool,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct HitInfo {
|
||||
pub slot: u8,
|
||||
pub head: bool,
|
||||
pub dmg: i32,
|
||||
pub hp: i32,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct ShotMsg {
|
||||
pub by: u8,
|
||||
pub from: [f32; 3],
|
||||
pub to: [f32; 3],
|
||||
pub weapon: u8,
|
||||
#[serde(skip_serializing_if = "Option::is_none")]
|
||||
pub hit: Option<HitInfo>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct KillMsg {
|
||||
pub by: Option<u8>,
|
||||
pub victim: u8,
|
||||
pub weapon: String,
|
||||
pub head: bool,
|
||||
pub score: [u32; 2],
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct RoundMsg {
|
||||
pub phase: Phase,
|
||||
pub round_no: u32,
|
||||
pub score: [u32; 2],
|
||||
pub left_ms: u32,
|
||||
#[serde(skip_serializing_if = "Option::is_none")]
|
||||
pub winner: Option<u8>,
|
||||
#[serde(skip_serializing_if = "Option::is_none")]
|
||||
pub reason: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct MatchMsg {
|
||||
pub winner: u8,
|
||||
pub score: [u32; 2],
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize)]
|
||||
#[serde(tag = "t")]
|
||||
pub enum ServerMsg {
|
||||
#[serde(rename = "welcome")]
|
||||
Welcome {
|
||||
code: String,
|
||||
#[serde(rename = "you")]
|
||||
you: Option<u8>,
|
||||
#[serde(rename = "spectating")]
|
||||
spectating: bool,
|
||||
#[serde(rename = "level")]
|
||||
level: LevelInfo,
|
||||
},
|
||||
#[serde(rename = "snap")]
|
||||
Snap(Box<Snap>),
|
||||
#[serde(rename = "shot")]
|
||||
Shot(ShotMsg),
|
||||
#[serde(rename = "kill")]
|
||||
Kill(KillMsg),
|
||||
#[serde(rename = "round")]
|
||||
Round(RoundMsg),
|
||||
#[serde(rename = "match")]
|
||||
Match(MatchMsg),
|
||||
#[serde(rename = "pong")]
|
||||
Pong { id: u32, now: u64 },
|
||||
#[serde(rename = "err")]
|
||||
Err { msg: String },
|
||||
#[serde(rename = "left")]
|
||||
Left,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct LevelInfo {
|
||||
pub name: String,
|
||||
pub size: f32,
|
||||
pub spawns: Vec<[f32; 4]>,
|
||||
}
|
||||
|
||||
impl LevelInfo {
|
||||
pub fn from_level(l: &Level) -> LevelInfo {
|
||||
LevelInfo {
|
||||
name: l.name.clone(),
|
||||
size: l.size,
|
||||
spawns: l
|
||||
.spawns
|
||||
.iter()
|
||||
.map(|s| [s.pos.x, s.pos.y, s.pos.z, s.yaw])
|
||||
.collect(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl ServerMsg {
|
||||
pub fn err(msg: impl Into<String>) -> ServerMsg {
|
||||
ServerMsg::Err { msg: msg.into() }
|
||||
}
|
||||
|
||||
pub fn to_json(&self) -> String {
|
||||
serde_json::to_string(self).unwrap_or_else(|_| "{}".to_string())
|
||||
}
|
||||
}
|
||||
|
||||
+549
@@ -0,0 +1,549 @@
|
||||
//! 房间管理 + 60Hz 权威模拟 + 30Hz 快照 + 静态文件服务
|
||||
|
||||
use std::collections::HashMap;
|
||||
use std::path::PathBuf;
|
||||
use std::sync::atomic::{AtomicBool, Ordering};
|
||||
use std::sync::{Arc, Mutex};
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
use axum::extract::ws::{Message, WebSocket, WebSocketUpgrade};
|
||||
use axum::extract::State;
|
||||
use axum::http::{header, StatusCode, Uri};
|
||||
use axum::response::{IntoResponse, Response};
|
||||
use axum::routing::get;
|
||||
use axum::Router;
|
||||
use futures_util::{SinkExt, StreamExt};
|
||||
use tokio::net::TcpListener;
|
||||
use tokio::sync::mpsc::UnboundedSender;
|
||||
|
||||
use crate::game::{InputFrame, Room, Rng, TICK};
|
||||
use crate::level::Level;
|
||||
use crate::protocol::*;
|
||||
|
||||
// 编译期把 public/ 打进来的资源表(build.rs 生成)
|
||||
include!(concat!(env!("OUT_DIR"), "/assets_gen.rs"));
|
||||
|
||||
const CODE_CHARS: &[u8] = b"ACDEFGHJKLMNPQRTUVWXY34679"; // 去掉容易看错的字符
|
||||
const EMPTY_ROOM_TTL: Duration = Duration::from_secs(10 * 60);
|
||||
const IDLE_ROOM_TTL: Duration = Duration::from_secs(60 * 60);
|
||||
const SNAP_EVERY: u64 = 2; // 60Hz 模拟 / 30Hz 快照
|
||||
|
||||
/* --------------------------------- 连接与房间 --------------------------------- */
|
||||
|
||||
struct Conn {
|
||||
tx: UnboundedSender<Message>,
|
||||
alive: Arc<AtomicBool>,
|
||||
room: Option<String>,
|
||||
slot: Option<u8>,
|
||||
}
|
||||
|
||||
pub struct Inner {
|
||||
rooms: HashMap<String, Room>,
|
||||
conns: HashMap<u64, Conn>,
|
||||
next_conn: u64,
|
||||
}
|
||||
|
||||
pub struct App {
|
||||
pub inner: Mutex<Inner>,
|
||||
}
|
||||
|
||||
impl App {
|
||||
pub fn new() -> Arc<App> {
|
||||
Arc::new(App {
|
||||
inner: Mutex::new(Inner {
|
||||
rooms: HashMap::new(),
|
||||
conns: HashMap::new(),
|
||||
next_conn: 1,
|
||||
}),
|
||||
})
|
||||
}
|
||||
|
||||
fn register(&self, tx: UnboundedSender<Message>, alive: Arc<AtomicBool>) -> u64 {
|
||||
let mut inner = self.inner.lock().unwrap();
|
||||
let id = inner.next_conn;
|
||||
inner.next_conn += 1;
|
||||
inner.conns.insert(
|
||||
id,
|
||||
Conn {
|
||||
tx,
|
||||
alive,
|
||||
room: None,
|
||||
slot: None,
|
||||
},
|
||||
);
|
||||
id
|
||||
}
|
||||
|
||||
fn detach(&self, id: u64) {
|
||||
let mut inner = self.inner.lock().unwrap();
|
||||
let Inner { rooms, conns, .. } = &mut *inner;
|
||||
let room_code = conns.get(&id).and_then(|c| c.room.clone());
|
||||
if let Some(code) = room_code {
|
||||
if let Some(room) = rooms.get_mut(&code) {
|
||||
room.leave(id);
|
||||
if room.humans() == 0 {
|
||||
room.touched_at = Instant::now();
|
||||
}
|
||||
}
|
||||
}
|
||||
conns.remove(&id);
|
||||
eprintln!("[ws] 连接 {id} 断开");
|
||||
}
|
||||
|
||||
pub fn room_count(&self) -> usize {
|
||||
self.inner.lock().unwrap().rooms.len()
|
||||
}
|
||||
|
||||
pub fn conn_count(&self) -> usize {
|
||||
self.inner.lock().unwrap().conns.len()
|
||||
}
|
||||
}
|
||||
|
||||
fn gen_code(inner: &Inner) -> String {
|
||||
let mut rng = Rng::new(
|
||||
std::time::SystemTime::now()
|
||||
.duration_since(std::time::UNIX_EPOCH)
|
||||
.map(|d| d.subsec_nanos() ^ d.as_secs() as u32)
|
||||
.unwrap_or(0x9e37),
|
||||
);
|
||||
for _ in 0..200 {
|
||||
let mut code = String::new();
|
||||
for _ in 0..4 {
|
||||
let i = (rng.next_u32() as usize) % CODE_CHARS.len();
|
||||
code.push(CODE_CHARS[i] as char);
|
||||
}
|
||||
if !inner.rooms.contains_key(&code) {
|
||||
return code;
|
||||
}
|
||||
}
|
||||
// 极端情况:撞库撞麻了,就用时间戳兜底
|
||||
format!("{:04X}", (std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map(|d| d.subsec_millis()).unwrap_or(0)))
|
||||
}
|
||||
|
||||
fn send(inner: &Inner, id: u64, msg: &ServerMsg) {
|
||||
if let Some(c) = inner.conns.get(&id) {
|
||||
let _ = c.tx.send(Message::Text(msg.to_json().into()));
|
||||
}
|
||||
}
|
||||
|
||||
fn welcome(code: &str, slot: Option<u8>) -> ServerMsg {
|
||||
ServerMsg::Welcome {
|
||||
code: code.to_string(),
|
||||
you: slot,
|
||||
spectating: slot.is_none(),
|
||||
level: LevelInfo::from_level(Level::embedded()),
|
||||
}
|
||||
}
|
||||
|
||||
fn handle(app: &Arc<App>, id: u64, msg: ClientMsg) {
|
||||
let mut inner = app.inner.lock().unwrap();
|
||||
|
||||
match msg {
|
||||
ClientMsg::Create => {
|
||||
// 先离开原来的房间
|
||||
if let Some(code) = inner.conns.get(&id).and_then(|c| c.room.clone()) {
|
||||
if let Some(room) = inner.rooms.get_mut(&code) {
|
||||
room.leave(id);
|
||||
}
|
||||
}
|
||||
let code = gen_code(&inner);
|
||||
let seed = std::time::SystemTime::now()
|
||||
.duration_since(std::time::UNIX_EPOCH)
|
||||
.map(|d| d.as_nanos() as u32)
|
||||
.unwrap_or(7);
|
||||
let mut room = Room::new(&code, seed);
|
||||
let slot = room.join(id, false);
|
||||
room.touched_at = Instant::now();
|
||||
inner.rooms.insert(code.clone(), room);
|
||||
if let Some(c) = inner.conns.get_mut(&id) {
|
||||
c.room = Some(code.clone());
|
||||
c.slot = slot;
|
||||
}
|
||||
send(&inner, id, &welcome(&code, slot));
|
||||
send_snap(&inner, id, &code);
|
||||
}
|
||||
|
||||
ClientMsg::Join { code, spectate } => {
|
||||
let code = code.trim().to_ascii_uppercase();
|
||||
if !inner.rooms.contains_key(&code) {
|
||||
send(&inner, id, &ServerMsg::err("房间不存在,检查一下房号"));
|
||||
return;
|
||||
}
|
||||
if let Some(old) = inner.conns.get(&id).and_then(|c| c.room.clone()) {
|
||||
if old != code {
|
||||
if let Some(r) = inner.rooms.get_mut(&old) {
|
||||
r.leave(id);
|
||||
}
|
||||
}
|
||||
}
|
||||
let spectate = spectate.unwrap_or(false);
|
||||
let slot = inner
|
||||
.rooms
|
||||
.get_mut(&code)
|
||||
.and_then(|r| r.join(id, spectate));
|
||||
if let Some(c) = inner.conns.get_mut(&id) {
|
||||
c.room = Some(code.clone());
|
||||
c.slot = slot;
|
||||
}
|
||||
send(&inner, id, &welcome(&code, slot));
|
||||
send_snap(&inner, id, &code);
|
||||
}
|
||||
|
||||
ClientMsg::Input {
|
||||
seq,
|
||||
keys,
|
||||
yaw,
|
||||
pitch,
|
||||
fire,
|
||||
reload,
|
||||
weapon,
|
||||
} => {
|
||||
let (Some(code), Some(_)) = (
|
||||
inner.conns.get(&id).and_then(|c| c.room.clone()),
|
||||
inner.conns.get(&id).and_then(|c| c.slot),
|
||||
) else {
|
||||
return;
|
||||
};
|
||||
if let Some(room) = inner.rooms.get_mut(&code) {
|
||||
let slot = room.seat_of(id);
|
||||
if let Some(slot) = slot {
|
||||
room.input(
|
||||
slot,
|
||||
InputFrame {
|
||||
seq,
|
||||
keys,
|
||||
yaw,
|
||||
pitch: pitch.clamp(-1.5533, 1.5533),
|
||||
fire,
|
||||
reload,
|
||||
weapon,
|
||||
},
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
ClientMsg::AddBot => {
|
||||
let Some(code) = inner.conns.get(&id).and_then(|c| c.room.clone()) else {
|
||||
send(&inner, id, &ServerMsg::err("先建房再加入机器人"));
|
||||
return;
|
||||
};
|
||||
let ok = inner
|
||||
.rooms
|
||||
.get_mut(&code)
|
||||
.map(|r| r.add_bot())
|
||||
.unwrap_or(false);
|
||||
if !ok {
|
||||
send(&inner, id, &ServerMsg::err("这个房间已经有对手了"));
|
||||
} else {
|
||||
send_snap(&inner, id, &code);
|
||||
}
|
||||
}
|
||||
|
||||
ClientMsg::Rematch => {
|
||||
let Some(code) = inner.conns.get(&id).and_then(|c| c.room.clone()) else {
|
||||
return;
|
||||
};
|
||||
if let Some(room) = inner.rooms.get_mut(&code) {
|
||||
if let Some(slot) = room.seat_of(id) {
|
||||
room.rematch(slot);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
ClientMsg::Leave => {
|
||||
let Some(code) = inner.conns.get(&id).and_then(|c| c.room.clone()) else {
|
||||
return;
|
||||
};
|
||||
if let Some(room) = inner.rooms.get_mut(&code) {
|
||||
room.leave(id);
|
||||
}
|
||||
if let Some(c) = inner.conns.get_mut(&id) {
|
||||
c.room = None;
|
||||
c.slot = None;
|
||||
}
|
||||
send(&inner, id, &ServerMsg::Left);
|
||||
}
|
||||
|
||||
ClientMsg::Ping { id: pid } => {
|
||||
let now = now_ms();
|
||||
if let Some(c) = inner.conns.get(&id) {
|
||||
let _ = c.tx.send(Message::Text(
|
||||
ServerMsg::Pong { id: pid, now }.to_json().into(),
|
||||
));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn send_snap(inner: &Inner, id: u64, code: &str) {
|
||||
if let Some(room) = inner.rooms.get(code) {
|
||||
send(inner, id, &ServerMsg::Snap(Box::new(room.snap())));
|
||||
}
|
||||
}
|
||||
|
||||
fn now_ms() -> u64 {
|
||||
std::time::SystemTime::now()
|
||||
.duration_since(std::time::UNIX_EPOCH)
|
||||
.map(|d| d.as_millis() as u64)
|
||||
.unwrap_or(0)
|
||||
}
|
||||
|
||||
/* --------------------------------- 主循环 --------------------------------- */
|
||||
|
||||
/// 60Hz 权威模拟:推进所有房间,把事件和快照推给房间里的人
|
||||
async fn game_loop(app: Arc<App>) {
|
||||
let mut tick = tokio::time::interval(Duration::from_secs_f64(TICK as f64));
|
||||
tick.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Delay);
|
||||
let mut n: u64 = 0;
|
||||
let mut last_gc = Instant::now();
|
||||
|
||||
loop {
|
||||
tick.tick().await;
|
||||
n += 1;
|
||||
let mut inner = app.inner.lock().unwrap();
|
||||
let Inner { rooms, conns, .. } = &mut *inner;
|
||||
let mut out: Vec<(Vec<u64>, String)> = Vec::new();
|
||||
|
||||
for room in rooms.values_mut() {
|
||||
room.tick(TICK);
|
||||
let audience = room.audience();
|
||||
for ev in room.drain_events() {
|
||||
out.push((audience.clone(), ev.to_json()));
|
||||
}
|
||||
if n % SNAP_EVERY == 0 {
|
||||
out.push((
|
||||
audience,
|
||||
ServerMsg::Snap(Box::new(room.snap())).to_json(),
|
||||
));
|
||||
}
|
||||
}
|
||||
|
||||
for (ids, json) in out {
|
||||
for id in ids {
|
||||
if let Some(c) = conns.get(&id) {
|
||||
let _ = c.tx.send(Message::Text(json.clone().into()));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if last_gc.elapsed() > Duration::from_secs(30) {
|
||||
last_gc = Instant::now();
|
||||
let now = Instant::now();
|
||||
let dead: Vec<String> = rooms
|
||||
.iter()
|
||||
.filter(|(_, r)| {
|
||||
(r.humans() == 0 && now.duration_since(r.touched_at) > EMPTY_ROOM_TTL)
|
||||
|| now.duration_since(r.touched_at) > IDLE_ROOM_TTL
|
||||
})
|
||||
.map(|(c, _)| c.clone())
|
||||
.collect();
|
||||
for code in dead {
|
||||
rooms.remove(&code);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* -------------------------------- HTTP / WS -------------------------------- */
|
||||
|
||||
fn mime_of(name: &str) -> &'static str {
|
||||
let ext = name.rsplit('.').next().unwrap_or("").to_ascii_lowercase();
|
||||
match ext.as_str() {
|
||||
"html" | "htm" => "text/html; charset=utf-8",
|
||||
"js" | "mjs" => "text/javascript; charset=utf-8",
|
||||
"css" => "text/css; charset=utf-8",
|
||||
"json" | "webmanifest" => "application/json; charset=utf-8",
|
||||
"png" => "image/png",
|
||||
"jpg" | "jpeg" => "image/jpeg",
|
||||
"svg" => "image/svg+xml",
|
||||
"ico" => "image/x-icon",
|
||||
"woff2" => "font/woff2",
|
||||
"mp3" => "audio/mpeg",
|
||||
"webp" => "image/webp",
|
||||
_ => "application/octet-stream",
|
||||
}
|
||||
}
|
||||
|
||||
/// 开发时优先用磁盘上的 public/(改了文件立刻生效)
|
||||
fn public_dir() -> Option<PathBuf> {
|
||||
if let Ok(p) = std::env::var("PUBLIC_DIR") {
|
||||
let p = PathBuf::from(p);
|
||||
if p.is_dir() {
|
||||
return Some(p);
|
||||
}
|
||||
}
|
||||
let cwd = PathBuf::from("public");
|
||||
if cwd.is_dir() {
|
||||
return Some(cwd);
|
||||
}
|
||||
let exe = std::env::current_exe().ok()?;
|
||||
let near = exe.parent()?.join("public");
|
||||
if near.is_dir() {
|
||||
Some(near)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
fn disk_asset(key: &str) -> Option<(String, Vec<u8>)> {
|
||||
if key.contains("..") {
|
||||
return None;
|
||||
}
|
||||
let dir = public_dir()?;
|
||||
let path = dir.join(key.trim_start_matches('/'));
|
||||
let body = std::fs::read(&path).ok()?;
|
||||
Some((mime_of(&path.to_string_lossy()).to_string(), body))
|
||||
}
|
||||
|
||||
fn embedded_asset(key: &str) -> Option<(&'static str, &'static [u8])> {
|
||||
ASSETS
|
||||
.iter()
|
||||
.find(|(k, _, _)| *k == key)
|
||||
.map(|(_, mime, body)| (*mime, *body))
|
||||
}
|
||||
|
||||
async fn static_handler(State(app): State<Arc<App>>, uri: Uri) -> Response {
|
||||
let path = uri.path();
|
||||
if path == "/health" || path == "/healthz" {
|
||||
let (rooms, conns) = (app.room_count(), app.conn_count());
|
||||
let level = Level::embedded();
|
||||
let body = format!(
|
||||
r#"{{"ok":true,"rooms":{rooms},"conns":{conns},"engine":"rust","mode":"{}","map":"{}","tick":60,"snapshot":30}}"#,
|
||||
if public_dir().is_some() { "disk" } else { "embedded" },
|
||||
level.name
|
||||
);
|
||||
return (
|
||||
[(header::CONTENT_TYPE, "application/json; charset=utf-8")],
|
||||
body,
|
||||
)
|
||||
.into_response();
|
||||
}
|
||||
|
||||
let key = if path == "/" { "/index.html" } else { path };
|
||||
for key in [key, "/index.html"] {
|
||||
if let Some((mime, body)) = disk_asset(key) {
|
||||
return (
|
||||
[
|
||||
(header::CONTENT_TYPE, mime),
|
||||
(header::CACHE_CONTROL, "no-cache".to_string()),
|
||||
],
|
||||
body,
|
||||
)
|
||||
.into_response();
|
||||
}
|
||||
if let Some((mime, body)) = embedded_asset(key) {
|
||||
return (
|
||||
[
|
||||
(header::CONTENT_TYPE, mime.to_string()),
|
||||
(header::CACHE_CONTROL, "no-cache".to_string()),
|
||||
],
|
||||
body,
|
||||
)
|
||||
.into_response();
|
||||
}
|
||||
}
|
||||
(StatusCode::NOT_FOUND, "not found").into_response()
|
||||
}
|
||||
|
||||
async fn ws_handler(ws: WebSocketUpgrade, State(app): State<Arc<App>>) -> Response {
|
||||
ws.max_message_size(64 * 1024)
|
||||
.max_frame_size(64 * 1024)
|
||||
.on_upgrade(move |socket| handle_socket(app, socket))
|
||||
}
|
||||
|
||||
async fn handle_socket(app: Arc<App>, socket: WebSocket) {
|
||||
let (mut sender, mut receiver) = socket.split();
|
||||
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel::<Message>();
|
||||
let alive = Arc::new(AtomicBool::new(true));
|
||||
let id = app.register(tx, alive.clone());
|
||||
|
||||
let writer = tokio::spawn(async move {
|
||||
while let Some(msg) = rx.recv().await {
|
||||
if sender.send(msg).await.is_err() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
let _ = sender.close().await;
|
||||
});
|
||||
|
||||
while let Some(next) = receiver.next().await {
|
||||
let Ok(msg) = next else { break };
|
||||
alive.store(true, Ordering::Relaxed);
|
||||
let text = match msg {
|
||||
Message::Text(t) => t.as_str().to_string(),
|
||||
Message::Close(_) => break,
|
||||
_ => continue,
|
||||
};
|
||||
let Ok(cmsg) = serde_json::from_str::<ClientMsg>(&text) else {
|
||||
continue;
|
||||
};
|
||||
handle(&app, id, cmsg);
|
||||
}
|
||||
|
||||
app.detach(id);
|
||||
let _ = writer.await;
|
||||
}
|
||||
|
||||
/// 心跳:发 ping 探活,睡死过去的连接直接清掉
|
||||
async fn heartbeat(app: Arc<App>) {
|
||||
let mut tick = tokio::time::interval(Duration::from_secs(30));
|
||||
tick.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Delay);
|
||||
loop {
|
||||
tick.tick().await;
|
||||
let dead: Vec<u64> = {
|
||||
let mut inner = app.inner.lock().unwrap();
|
||||
let Inner { rooms, conns, .. } = &mut *inner;
|
||||
let mut dead = Vec::new();
|
||||
for (id, conn) in conns.iter_mut() {
|
||||
if !conn.alive.swap(false, Ordering::Relaxed) {
|
||||
dead.push(*id);
|
||||
} else {
|
||||
let _ = conn.tx.send(Message::Ping(Vec::new().into()));
|
||||
}
|
||||
}
|
||||
for id in &dead {
|
||||
let code = conns.get(id).and_then(|c| c.room.clone());
|
||||
if let Some(code) = code {
|
||||
if let Some(room) = rooms.get_mut(&code) {
|
||||
room.leave(*id);
|
||||
}
|
||||
}
|
||||
conns.remove(id);
|
||||
}
|
||||
dead
|
||||
};
|
||||
if !dead.is_empty() {
|
||||
println!("[heartbeat] 清理 {} 条失活连接", dead.len());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn router(app: Arc<App>) -> Router {
|
||||
Router::new()
|
||||
.route("/ws", get(ws_handler))
|
||||
.fallback(get(static_handler))
|
||||
.with_state(app)
|
||||
}
|
||||
|
||||
/// 启动服务(模拟循环 / 心跳跟着一起起来)
|
||||
pub async fn serve(listener: TcpListener, app: Arc<App>) -> std::io::Result<()> {
|
||||
tokio::spawn(game_loop(app.clone()));
|
||||
tokio::spawn(heartbeat(app.clone()));
|
||||
axum::serve(listener, router(app))
|
||||
.await
|
||||
.map_err(std::io::Error::other)
|
||||
}
|
||||
|
||||
/// 本机 IPv4 地址(打印局域网访问地址用)
|
||||
pub fn lan_addrs() -> Vec<String> {
|
||||
let mut out = Vec::new();
|
||||
if let Ok(sock) = std::net::UdpSocket::bind("0.0.0.0:0") {
|
||||
if sock.connect("8.8.8.8:80").is_ok() {
|
||||
if let Ok(addr) = sock.local_addr() {
|
||||
out.push(addr.ip().to_string());
|
||||
}
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
@@ -0,0 +1,61 @@
|
||||
//! 武器表。**前端 `public/js/client/weapons.js` 是这份表的镜像**(只用于显示,
|
||||
//! 真正的伤害、射速、弹匣全在服务端算)。
|
||||
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub struct Weapon {
|
||||
pub id: u8,
|
||||
pub name: &'static str,
|
||||
/// 连发 / 单发
|
||||
pub auto: bool,
|
||||
pub damage: f32,
|
||||
pub head_mul: f32,
|
||||
/// 两发之间的最小间隔(秒)
|
||||
pub interval: f32,
|
||||
pub mag: u32,
|
||||
pub reserve: u32,
|
||||
pub reload: f32,
|
||||
/// 基础散布(弧度),移动 / 腾空还会再加
|
||||
pub spread: f32,
|
||||
pub range: f32,
|
||||
/// 后坐力(弧度,主要抬枪口)
|
||||
pub kick: f32,
|
||||
}
|
||||
|
||||
pub const RIFLE: u8 = 0;
|
||||
pub const PISTOL: u8 = 1;
|
||||
|
||||
pub const WEAPONS: [Weapon; 2] = [
|
||||
Weapon {
|
||||
id: RIFLE,
|
||||
name: "AK-47",
|
||||
auto: true,
|
||||
damage: 27.0,
|
||||
head_mul: 4.0,
|
||||
interval: 0.1,
|
||||
mag: 30,
|
||||
reserve: 90,
|
||||
reload: 2.4,
|
||||
spread: 0.0075,
|
||||
range: 120.0,
|
||||
kick: 0.014,
|
||||
},
|
||||
Weapon {
|
||||
id: PISTOL,
|
||||
name: "沙漠之鹰",
|
||||
auto: false,
|
||||
damage: 52.0,
|
||||
head_mul: 3.2,
|
||||
interval: 0.32,
|
||||
mag: 7,
|
||||
reserve: 35,
|
||||
reload: 2.1,
|
||||
spread: 0.0045,
|
||||
range: 90.0,
|
||||
kick: 0.028,
|
||||
},
|
||||
];
|
||||
|
||||
#[inline]
|
||||
pub fn get(id: u8) -> &'static Weapon {
|
||||
&WEAPONS[(id as usize).min(WEAPONS.len() - 1)]
|
||||
}
|
||||
Reference in new issue
Block a user