bevy-adapt-mobile-to-desktop
Bevy ECS skill for adapting a Bevy mobile game to desktop. Keywords: Bevy, desktop, mouse, keyboard, adapt, window.
thedivergentai · 已有静态检查记录
安装与使用
运行命令前先阅读来源与依赖说明。复制命令不会自动安装或执行。
npx skills add thedivergentai/Game-Dev-Agentic-Skills --skill bevy-adapt-mobile-to-desktop技能说明
name: bevy-adapt-mobile-to-desktop description: "Bevy ECS skill for adapting a Bevy mobile game to desktop. Keywords: Bevy, desktop, mouse, keyboard, adapt, window."
Bevy adapt mobile to desktop
When to use
Load this when a touch-first game gains a window, mouse, and keyboard. Window setup is bevy-platform-desktop.
ECS shape
- Window:
Window,WindowMode, andPrimaryWindow. - Input: keyboard, mouse, and gamepad features are named on the crate page and already used by bevy-input-handling.
- Pointer:
CursorOptionson the primary window.CursorGrabMode::None,Confined, orLocked.
Desktop choices
| Need | Bevy idiom |
|---|---|
| On-screen buttons | Keyboard and mouse via bevy-input-handling, writing the same intent component. |
| Wider layout | A wider WindowResolution on the primary Window. |
| Pointer lock | CursorOptions.grab_mode = CursorGrabMode::Locked and visible = false. |
Scope
- Keyboard and mouse write a
MoveIntentcomponent. Touch buttons can keep writing that same component. - Window mode, resolution, present mode, and cursor grab live on the primary window entity.
Examples
[package]
name = "desktop_port"
version = "0.1.0"
edition = "2021"
[dependencies]
bevy = "0.20"
Open a windowed 1920x1080 view and lock the pointer while aiming.
use bevy::window::{
CursorGrabMode, CursorOptions, MonitorSelection, PresentMode, PrimaryWindow, WindowMode,
WindowResolution,
};
fn desktop_window(mut windows: Query<&mut Window, With<PrimaryWindow>>) {
for mut window in &mut windows {
window.mode = WindowMode::Windowed;
window.resolution = WindowResolution::new(1920, 1080);
window.title = "Desktop".to_string();
window.present_mode = PresentMode::AutoVsync;
}
}
fn unlock_framerate(mut windows: Query<&mut Window, With<PrimaryWindow>>) {
for mut window in &mut windows {
window.present_mode = PresentMode::AutoNoVsync;
}
}
fn borderless(mut windows: Query<&mut Window, With<PrimaryWindow>>) {
for mut window in &mut windows {
window.mode = WindowMode::BorderlessFullscreen(MonitorSelection::Current);
}
}
#[derive(Component)]
struct Aiming;
fn grab_cursor(
mut cursors: Query<&mut CursorOptions, With<PrimaryWindow>>,
aiming: Query<(), With<Aiming>>,
) {
let locked = !aiming.is_empty();
for mut cursor in &mut cursors {
cursor.visible = !locked;
cursor.grab_mode = if locked {
CursorGrabMode::Locked
} else {
CursorGrabMode::None
};
}
}
WASD replaces on-screen sticks. The gameplay system reads MoveIntent, not the key codes.
use bevy::window::{MonitorSelection, PrimaryWindow, VideoModeSelection, WindowMode};
#[derive(Component, Default)]
struct MoveIntent(Vec2);
fn read_wasd(keys: Res<ButtonInput<KeyCode>>, mut intents: Query<&mut MoveIntent>) {
let mut dir = Vec2::ZERO;
if keys.pressed(KeyCode::KeyA) {
dir.x -= 1.0;
}
if keys.pressed(KeyCode::KeyD) {
dir.x += 1.0;
}
if keys.pressed(KeyCode::KeyW) {
dir.y += 1.0;
}
if keys.pressed(KeyCode::KeyS) {
dir.y -= 1.0;
}
for mut intent in &mut intents {
intent.0 = dir;
}
}
fn toggle_fullscreen(
keys: Res<ButtonInput<KeyCode>>,
mut windows: Query<&mut Window, With<PrimaryWindow>>,
) {
if !keys.just_pressed(KeyCode::F11) {
return;
}
for mut window in &mut windows {
window.mode = match window.mode {
WindowMode::Windowed => {
WindowMode::Fullscreen(MonitorSelection::Primary, VideoModeSelection::Current)
}
_ => WindowMode::Windowed,
};
}
}
Captured look uses the frame's summed motion.
use bevy::input::mouse::AccumulatedMouseMotion;
#[derive(Component)]
struct LookRig;
fn apply_look(
motion: Res<AccumulatedMouseMotion>,
mut rigs: Query<&mut Transform, With<LookRig>>,
) {
for mut transform in &mut rigs {
transform.rotate_y(-motion.delta.x * 0.002);
}
}
pub struct LookPlugin;
impl Plugin for LookPlugin {
fn build(&self, app: &mut App) {
app.add_systems(Update, apply_look);
}
}
Expert Knowledge Delta
Target: Bevy 0.20+.
Core ECS types: Component, Resource, Query, Commands, Startup, Update, Fixed / FixedMain (bevy::time), .chain(), Plugin, DefaultPlugins, MinimalPlugins. Messages and observers are an ownership slot. See bevy-events-messaging for their APIs. Systems run in parallel unless .chain() orders the ones that conflict.
Who owns state
| Piece | Owner | Who may mutate | Schedule |
|---|---|---|---|
| Data on one entity | Component | One system via Query | Update or FixedMain |
| One value for the whole app | Resource | One system | Startup to insert, then the schedule that reads it |
| Spawn | Commands | The spawning system | Startup for the initial world; later schedules for runtime spawn |
| Order that must not race | .chain() | The chained systems only | Same schedule |
| Plugin boundary | Plugin | build registers systems and resources | Before the app runs |
Borrow rule: two systems that both mutably query the same component must be ordered (.chain()) or split so only one writes. Unrelated systems stay parallel. That is the ECS page rule, not a guess at a system-set API.
Decision
| If you need | Do this | Do not |
|---|---|---|
| Per-entity data | Component + Query | A value stored off the entity |
| App-wide config or clock | Resource | Copy the value onto every entity |
| Stable simulation step | FixedMain and the Fixed clock | Tie simulation to raw frame Update |
| Startup spawn | Commands in Startup | Spawn from a render system |
| Cross-system notice that is not shared state | Message or observer slot in bevy-events-messaging | A new event type |