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:
rong committed 2026-10-22 21:53:45 +08:00
commit 00d63ba736
32 files changed
+8599

No files matched your search

+1167
View File
File diff suppressed because it is too large. Load diff
+153
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
}
+61
View File
@@ -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)]
}