[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M6KRC670RV8RWVPBN9TWGXK4":3,"skill-same:01M6KRC670RV8RWVPBN9TWGXK4":74},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":18,"publishedAt":28,"linkOnly":29,"markdownContent":30,"markdownBody":31,"frontMatter":32,"refName":33,"commitSha":34,"skillDirectory":35,"forksCount":36,"repositoryHtmlUrl":37,"repositoryHomepageUrl":6,"ownerHtmlUrl":38,"ownerBlogUrl":39,"ownerDescription":40,"updatedAt":41,"install":42,"resources":55},"01M6KRC670RV8RWVPBN9TWGXK4","multiplayer-sync",null,"Use when synchronizing multiplayer state — MultiplayerSynchronizer, interpolation, prediction, and lag compensation","jame581\u002FGodotPrompter","jame581","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F21112138?v=4","01M6KR3KEQ9Z30WVJRR2E2ZVXE","Jan Mesarč","01M6KR3KJVRMPDSMASQPBCBVK3",964,"MIT","https:\u002F\u002Fgithub.com\u002Fjame581\u002FGodotPrompter\u002Fblob\u002Fmaster\u002Fskills\u002Fmultiplayer-sync\u002FSKILL.md",[],[19,20,21,22,23,24,25,26,27],"sync","multiplayer","multiplayer sync","state","use","interpolation","when","compensation","prediction","2026-11-10 10:12:30",false,"---\nname: multiplayer-sync\ndescription: Use when synchronizing multiplayer state — MultiplayerSynchronizer, interpolation, prediction, and lag compensation\n---\n\n# Multiplayer Synchronization in Godot 4.3+\n\nAll examples target Godot 4.3+ with no deprecated APIs. GDScript is shown first, then C#.\n\n> **Related skills:** **multiplayer-basics** for ENet setup, RPCs, and authority model, **dedicated-server** for headless export and deployment, **physics-system** for physics interpolation and RigidBody synchronization.\n\n---\n\n## 1. MultiplayerSynchronizer\n\n`MultiplayerSynchronizer` is Godot's built-in node for replicating properties across the network. Add it as a child of the node whose state you want to share.\n\n### What It Does\n\n- Sends property values from the **authority** peer to all others at a configured interval\n- Supports both **delta sync** (\"On Change\" properties, sent reliably when changed) and **full sync** (\"Always\" properties, sent unreliably every interval)\n- Allows **visibility filters** to control which peers receive updates\n\n### Replication Config in the Editor\n\n1. Select the `MultiplayerSynchronizer` node in the scene tree.\n2. In the Inspector, open **Replication** and click **Add Property**.\n3. Pick the parent node path and property name (e.g. `position`, `velocity`).\n4. Set **Sync** (send every interval) or **Spawn** (send only on spawn) per property.\n5. Set the **Replication Interval** (seconds). `0` means every network process frame (the multiplayer API polls once per process frame, not per physics tick).\n\n### Key Properties\n\n| Property | Description |\n|---|---|\n| `replication_interval` | Seconds between full sync updates. `0` (default) = every network process frame |\n| `delta_interval` | Seconds between delta sync updates. `0` (default) = every network process frame |\n| `public_visibility` | When `true`, updates go to all peers (default) |\n| `add_visibility_filter(callable)` | Method, not a property: adds a `Callable` that takes a peer ID and returns `true` if that peer should receive updates |\n\n### Delta vs Full Sync\n\n| Mode | How It Works | Best For |\n|---|---|---|\n| **Full sync** | Sends every \"Always\" property every `replication_interval`, unreliably | Continuously changing values (position, velocity) |\n| **Delta sync** | Sends the \"On Change\" properties that changed, every `delta_interval`, reliably | Values that change rarely but must arrive (health, state) |\n\nEach property uses one mode, so the two intervals govern different property sets — `replication_interval` is not a full-state refresh of the \"On Change\" properties.\n\n### Visibility Filters (GDScript)\n\n```gdscript\n# Only send updates to peers within 500 units of this object.\nfunc _ready() -> void:\n    $MultiplayerSynchronizer.add_visibility_filter(_is_peer_in_range)\n\nfunc _is_peer_in_range(peer_id: int) -> bool:\n    var peer_player := _get_player_node(peer_id)\n    if peer_player == null:\n        return false\n    return global_position.distance_to(peer_player.global_position) \u003C= 500.0\n```\n\n### Visibility Filters (C#)\n\n```csharp\n\u002F\u002F Only send updates to peers within 500 units of this object.\npublic override void _Ready()\n{\n    var sync = GetNode\u003CMultiplayerSynchronizer>(\"MultiplayerSynchronizer\");\n    sync.AddVisibilityFilter(Callable.From\u003Cint, bool>(IsPeerInRange));\n}\n\nprivate bool IsPeerInRange(int peerId)\n{\n    var peerPlayer = GetPlayerNode(peerId);\n    if (peerPlayer is null)\n        return false;\n    return GlobalPosition.DistanceTo(peerPlayer.GlobalPosition) \u003C= 500.0f;\n}\n```\n\n---\n\n## 2. Property Synchronization\n\n### What to Sync\n\nSync the minimal state needed to reconstruct the visual on remote peers. Typical properties:\n\n| Property | Type | Notes |\n|---|---|---|\n| `position` | `Vector2` \u002F `Vector3` | Core transform — sync every frame or use interpolation |\n| `velocity` | `Vector2` \u002F `Vector3` | Helps remote prediction stay ahead of position snaps |\n| `health` | `int` \u002F `float` | Sync reliably on change; delta sync is ideal |\n| `animation_state` | `String` \u002F `int` | Sync on change; use an enum int to save bandwidth |\n| `is_crouching` | `bool` | Low-change boolean; delta sync or RPC on change |\n\n### Synced Player (GDScript)\n\n```gdscript\n# synced_player.gd\nextends CharacterBody2D\n\n## Sync interval in seconds — exposed so designers can tune per object type.\n@export var sync_interval: float = 0.05  # 20 Hz\n\n@export var speed: float = 200.0\n\n# These properties are listed in the MultiplayerSynchronizer replication config.\nvar synced_position: Vector2 = Vector2.ZERO\nvar synced_velocity: Vector2 = Vector2.ZERO\nvar synced_health: int = 100\nvar synced_anim: int = 0  # 0 = idle, 1 = run, 2 = jump\n\n@onready var _sync: MultiplayerSynchronizer = $MultiplayerSynchronizer\n\n\nfunc _ready() -> void:\n    _sync.replication_interval = sync_interval\n    # Only the authority (owner) drives movement.\n    set_physics_process(is_multiplayer_authority())\n\n\nfunc _physics_process(_delta: float) -> void:\n    # Authority: write canonical state so MultiplayerSynchronizer can replicate it.\n    synced_position = global_position\n    synced_velocity = velocity\n    synced_anim     = _compute_anim_state()\n```\n\n### Synced Player (C#)\n\n```csharp\n\u002F\u002F SyncedPlayer.cs\nusing Godot;\n\npublic partial class SyncedPlayer : CharacterBody2D\n{\n    \u002F\u002F\u002F \u003Csummary>Sync interval in seconds. Exposed so designers can tune per object type.\u003C\u002Fsummary>\n    [Export] public float SyncInterval { get; set; } = 0.05f; \u002F\u002F 20 Hz\n\n    [Export] public float Speed { get; set; } = 200.0f;\n\n    \u002F\u002F These properties are listed in the MultiplayerSynchronizer replication config.\n    public Vector2 SyncedPosition { get; set; } = Vector2.Zero;\n    public Vector2 SyncedVelocity { get; set; } = Vector2.Zero;\n    public int SyncedHealth { get; set; } = 100;\n    public int SyncedAnim   { get; set; } = 0; \u002F\u002F 0=idle, 1=run, 2=jump\n\n    private MultiplayerSynchronizer _sync = null!;\n\n    public override void _Ready()\n    {\n        _sync = GetNode\u003CMultiplayerSynchronizer>(\"MultiplayerSynchronizer\");\n        _sync.ReplicationInterval = SyncInterval;\n        SetPhysicsProcess(IsMultiplayerAuthority());\n    }\n\n    public override void _PhysicsProcess(double delta)\n    {\n        \u002F\u002F Authority: write canonical state for replication.\n        SyncedPosition = GlobalPosition;\n        SyncedVelocity = Velocity;\n        SyncedAnim     = ComputeAnimState();\n    }\n\n    private int ComputeAnimState()\n    {\n        if (!IsOnFloor()) return 2;\n        return Velocity.Length() > 1f ? 1 : 0;\n    }\n}\n```\n\n---\n\n## 3. Interpolation\n\n`MultiplayerSynchronizer` updates target properties at sync intervals (e.g., 30 Hz), but rendering runs at frame rate (60+ Hz). Without interpolation, remote players appear to teleport between snapshots. The fix: on each `synchronized` signal keep the previous and the new position, and lerp between them in `_process` by the time elapsed since the update divided by the sync interval; a timestamped snapshot buffer (render ~100 ms behind) is the more robust version.\n\n> See [references\u002Finterpolation.md](references\u002Finterpolation.md) for the full GDScript and C# previous\u002Fcurrent-snapshot interpolation (`synchronized` signal, elapsed-time lerp in `_process`).\n\n---\n\n## 4. Client-Side Prediction\n\nFor local-player responsiveness: predict movement immediately on client, send input to server, reconcile when server snapshot arrives. If server diverges from client prediction beyond a threshold, snap; otherwise smoothly lerp the correction over 100-200 ms.\n\n> See [references\u002Fclient-prediction.md](references\u002Fclient-prediction.md) for the full predict-and-reconcile pattern (input ring buffer, server reconciliation, replay) in GDScript + C#.\n\n---\n\n## 5. Lag Compensation\n\nFor hit-scan weapons in fast-paced games: when the server validates a hit, it rewinds the world state to the client's view-time (`now - client_rtt\u002F2 - interp_delay`) and tests the hit against that historical state.\n\n> See [references\u002Flag-compensation.md](references\u002Flag-compensation.md) for the snapshot-history pattern, view-time calculation, and a hit-scan validator in GDScript + C#.\n\n---\n\n## 6. State vs Input Synchronization\n\nChoose the synchronization model that fits your game's needs:\n\n| Factor | Sync State | Sync Inputs |\n|---|---|---|\n| **What is sent** | Current property values (position, health, etc.) | Player input actions each frame |\n| **Who simulates** | Authority only; others receive results | All peers run the same simulation |\n| **Determinism required** | No | Yes — every peer must produce identical output from the same inputs |\n| **Bandwidth** | Higher — full state sent each interval | Lower — small input structs per frame |\n| **Responsiveness** | Lower — non-authority peers wait for next sync tick | Higher — local prediction is trivial when deterministic |\n| **Complexity** | Lower — no reconciliation loop | Higher — requires deterministic physics, fixed-point math, or lockstep |\n| **Best for** | Action games, shooters, most real-time games | Fighting games, RTS, turn-based, simulation games |\n| **Lag compensation needed** | Yes, for hit detection | Usually not — all peers are in sync |\n\n**Hybrid approach** (most real-time games): sync inputs for the local player's character (enabling prediction), sync state for all other objects and game events.\n\n---\n\n## 7. Bandwidth Optimization\n\nFour levers: **sync only changed properties** (replication-config flag per property), **quantize floats** (components as 16-bit centimetres instead of floats — RPC arguments and synced properties compress ints to 1\u002F2\u002F4\u002F8 bytes plus a type byte, so a 16-bit int costs 3 bytes against 8 for a float), **distance-based sync rate** (far-away objects sync at 5 Hz, close at 30 Hz), and **channel selection** (reliable for state changes that must arrive, unreliable for position streams that get superseded).\n\n> See [references\u002Fbandwidth-optimization.md](references\u002Fbandwidth-optimization.md) for full GDScript + C# recipes for each lever, plus the reliable-vs-unreliable channel decision tree.\n\n---\n\n## 8. Implementation Checklist\n\n- [ ] `MultiplayerSynchronizer` is a direct child of the node it replicates\n- [ ] Only the **authority** peer writes to synced properties; others are read-only\n- [ ] `set_multiplayer_authority()` is called at spawn time with the correct peer ID\n- [ ] `replication_interval` and `delta_interval` are tuned for the object's update rate\n- [ ] Remote player visuals use interpolation in `_process`, not `_physics_process`\n- [ ] Interpolation stores previous and current state and blends by the time since the last update (not `Engine.get_physics_interpolation_fraction()`, which tracks physics ticks, not network updates)\n- [ ] Client-side prediction is applied only to the local player's own character\n- [ ] Pending input buffer is bounded (max ~128 ticks) to prevent memory growth\n- [ ] Reconciliation threshold prevents jitter from micro-corrections\n- [ ] Position and velocity use `unreliable` RPC; state changes use `reliable`\n- [ ] Float quantization is applied before sending position data over the network\n- [ ] Lag compensation snapshot history is pruned each tick to a bounded window\n- [ ] Server validates all hit detection; clients never self-report kills\n- [ ] Distance-based sync rate reduces bandwidth for far-away objects\n","# Multiplayer Synchronization in Godot 4.3+\n\nAll examples target Godot 4.3+ with no deprecated APIs. GDScript is shown first, then C#.\n\n> **Related skills:** **multiplayer-basics** for ENet setup, RPCs, and authority model, **dedicated-server** for headless export and deployment, **physics-system** for physics interpolation and RigidBody synchronization.\n\n---\n\n## 1. MultiplayerSynchronizer\n\n`MultiplayerSynchronizer` is Godot's built-in node for replicating properties across the network. Add it as a child of the node whose state you want to share.\n\n### What It Does\n\n- Sends property values from the **authority** peer to all others at a configured interval\n- Supports both **delta sync** (\"On Change\" properties, sent reliably when changed) and **full sync** (\"Always\" properties, sent unreliably every interval)\n- Allows **visibility filters** to control which peers receive updates\n\n### Replication Config in the Editor\n\n1. Select the `MultiplayerSynchronizer` node in the scene tree.\n2. In the Inspector, open **Replication** and click **Add Property**.\n3. Pick the parent node path and property name (e.g. `position`, `velocity`).\n4. Set **Sync** (send every interval) or **Spawn** (send only on spawn) per property.\n5. Set the **Replication Interval** (seconds). `0` means every network process frame (the multiplayer API polls once per process frame, not per physics tick).\n\n### Key Properties\n\n| Property | Description |\n|---|---|\n| `replication_interval` | Seconds between full sync updates. `0` (default) = every network process frame |\n| `delta_interval` | Seconds between delta sync updates. `0` (default) = every network process frame |\n| `public_visibility` | When `true`, updates go to all peers (default) |\n| `add_visibility_filter(callable)` | Method, not a property: adds a `Callable` that takes a peer ID and returns `true` if that peer should receive updates |\n\n### Delta vs Full Sync\n\n| Mode | How It Works | Best For |\n|---|---|---|\n| **Full sync** | Sends every \"Always\" property every `replication_interval`, unreliably | Continuously changing values (position, velocity) |\n| **Delta sync** | Sends the \"On Change\" properties that changed, every `delta_interval`, reliably | Values that change rarely but must arrive (health, state) |\n\nEach property uses one mode, so the two intervals govern different property sets — `replication_interval` is not a full-state refresh of the \"On Change\" properties.\n\n### Visibility Filters (GDScript)\n\n```gdscript\n# Only send updates to peers within 500 units of this object.\nfunc _ready() -> void:\n    $MultiplayerSynchronizer.add_visibility_filter(_is_peer_in_range)\n\nfunc _is_peer_in_range(peer_id: int) -> bool:\n    var peer_player := _get_player_node(peer_id)\n    if peer_player == null:\n        return false\n    return global_position.distance_to(peer_player.global_position) \u003C= 500.0\n```\n\n### Visibility Filters (C#)\n\n```csharp\n\u002F\u002F Only send updates to peers within 500 units of this object.\npublic override void _Ready()\n{\n    var sync = GetNode\u003CMultiplayerSynchronizer>(\"MultiplayerSynchronizer\");\n    sync.AddVisibilityFilter(Callable.From\u003Cint, bool>(IsPeerInRange));\n}\n\nprivate bool IsPeerInRange(int peerId)\n{\n    var peerPlayer = GetPlayerNode(peerId);\n    if (peerPlayer is null)\n        return false;\n    return GlobalPosition.DistanceTo(peerPlayer.GlobalPosition) \u003C= 500.0f;\n}\n```\n\n---\n\n## 2. Property Synchronization\n\n### What to Sync\n\nSync the minimal state needed to reconstruct the visual on remote peers. Typical properties:\n\n| Property | Type | Notes |\n|---|---|---|\n| `position` | `Vector2` \u002F `Vector3` | Core transform — sync every frame or use interpolation |\n| `velocity` | `Vector2` \u002F `Vector3` | Helps remote prediction stay ahead of position snaps |\n| `health` | `int` \u002F `float` | Sync reliably on change; delta sync is ideal |\n| `animation_state` | `String` \u002F `int` | Sync on change; use an enum int to save bandwidth |\n| `is_crouching` | `bool` | Low-change boolean; delta sync or RPC on change |\n\n### Synced Player (GDScript)\n\n```gdscript\n# synced_player.gd\nextends CharacterBody2D\n\n## Sync interval in seconds — exposed so designers can tune per object type.\n@export var sync_interval: float = 0.05  # 20 Hz\n\n@export var speed: float = 200.0\n\n# These properties are listed in the MultiplayerSynchronizer replication config.\nvar synced_position: Vector2 = Vector2.ZERO\nvar synced_velocity: Vector2 = Vector2.ZERO\nvar synced_health: int = 100\nvar synced_anim: int = 0  # 0 = idle, 1 = run, 2 = jump\n\n@onready var _sync: MultiplayerSynchronizer = $MultiplayerSynchronizer\n\n\nfunc _ready() -> void:\n    _sync.replication_interval = sync_interval\n    # Only the authority (owner) drives movement.\n    set_physics_process(is_multiplayer_authority())\n\n\nfunc _physics_process(_delta: float) -> void:\n    # Authority: write canonical state so MultiplayerSynchronizer can replicate it.\n    synced_position = global_position\n    synced_velocity = velocity\n    synced_anim     = _compute_anim_state()\n```\n\n### Synced Player (C#)\n\n```csharp\n\u002F\u002F SyncedPlayer.cs\nusing Godot;\n\npublic partial class SyncedPlayer : CharacterBody2D\n{\n    \u002F\u002F\u002F \u003Csummary>Sync interval in seconds. Exposed so designers can tune per object type.\u003C\u002Fsummary>\n    [Export] public float SyncInterval { get; set; } = 0.05f; \u002F\u002F 20 Hz\n\n    [Export] public float Speed { get; set; } = 200.0f;\n\n    \u002F\u002F These properties are listed in the MultiplayerSynchronizer replication config.\n    public Vector2 SyncedPosition { get; set; } = Vector2.Zero;\n    public Vector2 SyncedVelocity { get; set; } = Vector2.Zero;\n    public int SyncedHealth { get; set; } = 100;\n    public int SyncedAnim   { get; set; } = 0; \u002F\u002F 0=idle, 1=run, 2=jump\n\n    private MultiplayerSynchronizer _sync = null!;\n\n    public override void _Ready()\n    {\n        _sync = GetNode\u003CMultiplayerSynchronizer>(\"MultiplayerSynchronizer\");\n        _sync.ReplicationInterval = SyncInterval;\n        SetPhysicsProcess(IsMultiplayerAuthority());\n    }\n\n    public override void _PhysicsProcess(double delta)\n    {\n        \u002F\u002F Authority: write canonical state for replication.\n        SyncedPosition = GlobalPosition;\n        SyncedVelocity = Velocity;\n        SyncedAnim     = ComputeAnimState();\n    }\n\n    private int ComputeAnimState()\n    {\n        if (!IsOnFloor()) return 2;\n        return Velocity.Length() > 1f ? 1 : 0;\n    }\n}\n```\n\n---\n\n## 3. Interpolation\n\n`MultiplayerSynchronizer` updates target properties at sync intervals (e.g., 30 Hz), but rendering runs at frame rate (60+ Hz). Without interpolation, remote players appear to teleport between snapshots. The fix: on each `synchronized` signal keep the previous and the new position, and lerp between them in `_process` by the time elapsed since the update divided by the sync interval; a timestamped snapshot buffer (render ~100 ms behind) is the more robust version.\n\n> See [references\u002Finterpolation.md](references\u002Finterpolation.md) for the full GDScript and C# previous\u002Fcurrent-snapshot interpolation (`synchronized` signal, elapsed-time lerp in `_process`).\n\n---\n\n## 4. Client-Side Prediction\n\nFor local-player responsiveness: predict movement immediately on client, send input to server, reconcile when server snapshot arrives. If server diverges from client prediction beyond a threshold, snap; otherwise smoothly lerp the correction over 100-200 ms.\n\n> See [references\u002Fclient-prediction.md](references\u002Fclient-prediction.md) for the full predict-and-reconcile pattern (input ring buffer, server reconciliation, replay) in GDScript + C#.\n\n---\n\n## 5. Lag Compensation\n\nFor hit-scan weapons in fast-paced games: when the server validates a hit, it rewinds the world state to the client's view-time (`now - client_rtt\u002F2 - interp_delay`) and tests the hit against that historical state.\n\n> See [references\u002Flag-compensation.md](references\u002Flag-compensation.md) for the snapshot-history pattern, view-time calculation, and a hit-scan validator in GDScript + C#.\n\n---\n\n## 6. State vs Input Synchronization\n\nChoose the synchronization model that fits your game's needs:\n\n| Factor | Sync State | Sync Inputs |\n|---|---|---|\n| **What is sent** | Current property values (position, health, etc.) | Player input actions each frame |\n| **Who simulates** | Authority only; others receive results | All peers run the same simulation |\n| **Determinism required** | No | Yes — every peer must produce identical output from the same inputs |\n| **Bandwidth** | Higher — full state sent each interval | Lower — small input structs per frame |\n| **Responsiveness** | Lower — non-authority peers wait for next sync tick | Higher — local prediction is trivial when deterministic |\n| **Complexity** | Lower — no reconciliation loop | Higher — requires deterministic physics, fixed-point math, or lockstep |\n| **Best for** | Action games, shooters, most real-time games | Fighting games, RTS, turn-based, simulation games |\n| **Lag compensation needed** | Yes, for hit detection | Usually not — all peers are in sync |\n\n**Hybrid approach** (most real-time games): sync inputs for the local player's character (enabling prediction), sync state for all other objects and game events.\n\n---\n\n## 7. Bandwidth Optimization\n\nFour levers: **sync only changed properties** (replication-config flag per property), **quantize floats** (components as 16-bit centimetres instead of floats — RPC arguments and synced properties compress ints to 1\u002F2\u002F4\u002F8 bytes plus a type byte, so a 16-bit int costs 3 bytes against 8 for a float), **distance-based sync rate** (far-away objects sync at 5 Hz, close at 30 Hz), and **channel selection** (reliable for state changes that must arrive, unreliable for position streams that get superseded).\n\n> See [references\u002Fbandwidth-optimization.md](references\u002Fbandwidth-optimization.md) for full GDScript + C# recipes for each lever, plus the reliable-vs-unreliable channel decision tree.\n\n---\n\n## 8. Implementation Checklist\n\n- [ ] `MultiplayerSynchronizer` is a direct child of the node it replicates\n- [ ] Only the **authority** peer writes to synced properties; others are read-only\n- [ ] `set_multiplayer_authority()` is called at spawn time with the correct peer ID\n- [ ] `replication_interval` and `delta_interval` are tuned for the object's update rate\n- [ ] Remote player visuals use interpolation in `_process`, not `_physics_process`\n- [ ] Interpolation stores previous and current state and blends by the time since the last update (not `Engine.get_physics_interpolation_fraction()`, which tracks physics ticks, not network updates)\n- [ ] Client-side prediction is applied only to the local player's own character\n- [ ] Pending input buffer is bounded (max ~128 ticks) to prevent memory growth\n- [ ] Reconciliation threshold prevents jitter from micro-corrections\n- [ ] Position and velocity use `unreliable` RPC; state changes use `reliable`\n- [ ] Float quantization is applied before sending position data over the network\n- [ ] Lag compensation snapshot history is pruned each tick to a bounded window\n- [ ] Server validates all hit detection; clients never self-report kills\n- [ ] Distance-based sync rate reduces bandwidth for far-away objects\n",{"name":5,"description":7},"master","d7b26cdb5fae14d4ef7b713c5bf259395e75c3c6","skills\u002Fmultiplayer-sync",63,"https:\u002F\u002Fgithub.com\u002Fjame581\u002FGodotPrompter","https:\u002F\u002Fgithub.com\u002Fjame581","https:\u002F\u002Fjanmesarc.online\u002F","Software engineer. My biggest passion is game development.","2026-11-14 20:45:49",{"source":8,"skillName":5,"commands":43,"prompt":53,"zipAvailable":54},[44,47,50],{"tool":45,"command":46},"npx","npx skills add jame581\u002FGodotPrompter --skill multiplayer-sync",{"tool":48,"command":49},"bunx","bunx skills add jame581\u002FGodotPrompter --skill multiplayer-sync",{"tool":51,"command":52},"pnpm","pnpm dlx skills add jame581\u002FGodotPrompter --skill multiplayer-sync","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fjame581\u002FGodotPrompter\u002Fblob\u002Fmaster\u002Fskills\u002Fmultiplayer-sync\u002FSKILL.md",true,[56,62,66,70],{"path":57,"resourceType":58,"resourceTypeDesc":59,"sizeBytes":60,"sourceHtmlUrl":61},"references\u002Fbandwidth-optimization.md","REFERENCE","参考文档",5056,"https:\u002F\u002Fgithub.com\u002Fjame581\u002FGodotPrompter\u002Fblob\u002Fmaster\u002Fskills\u002Fmultiplayer-sync\u002Freferences\u002Fbandwidth-optimization.md",{"path":63,"resourceType":58,"resourceTypeDesc":59,"sizeBytes":64,"sourceHtmlUrl":65},"references\u002Fclient-prediction.md",5614,"https:\u002F\u002Fgithub.com\u002Fjame581\u002FGodotPrompter\u002Fblob\u002Fmaster\u002Fskills\u002Fmultiplayer-sync\u002Freferences\u002Fclient-prediction.md",{"path":67,"resourceType":58,"resourceTypeDesc":59,"sizeBytes":68,"sourceHtmlUrl":69},"references\u002Finterpolation.md",4169,"https:\u002F\u002Fgithub.com\u002Fjame581\u002FGodotPrompter\u002Fblob\u002Fmaster\u002Fskills\u002Fmultiplayer-sync\u002Freferences\u002Finterpolation.md",{"path":71,"resourceType":58,"resourceTypeDesc":59,"sizeBytes":72,"sourceHtmlUrl":73},"references\u002Flag-compensation.md",5517,"https:\u002F\u002Fgithub.com\u002Fjame581\u002FGodotPrompter\u002Fblob\u002Fmaster\u002Fskills\u002Fmultiplayer-sync\u002Freferences\u002Flag-compensation.md",[75,95,116,146,170,188],{"skillNo":76,"name":77,"nameZh":6,"description":78,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":79,"categories":80,"keywords":81,"publishedAt":28},"01M6KRFE5BR2PSD08ZKDAS66R7","xr-development","Use when building VR\u002FAR\u002FXR applications — OpenXR setup, XROrigin3D, hand tracking, controllers, passthrough, and Meta Quest deployment in Godot 4.3+","https:\u002F\u002Fgithub.com\u002Fjame581\u002FGodotPrompter\u002Fblob\u002Fmaster\u002Fskills\u002Fxr-development\u002FSKILL.md",[],[82,83,25,84,85,86,87,88,89,90,91,23,92,93,94],"xr development","development","deployment","godot","vr","setup","tracking","godot 4","ar","hand","Meta","applications","quest",{"skillNo":96,"name":97,"nameZh":6,"description":98,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":99,"categories":100,"keywords":101,"publishedAt":28},"01M6KRF8GZTG1TAS506MFBSGFC","web-services","Use when a Godot game calls a web server — HTTPRequest, downloads, REST\u002FJSON APIs, auth headers, WebSocketPeer clients, TLS, retries, and keeping secrets out of the build. Not for game networking\u002FRPCs (multiplayer-basics) or browser export (web-export)","https:\u002F\u002Fgithub.com\u002Fjame581\u002FGodotPrompter\u002Fblob\u002Fmaster\u002Fskills\u002Fweb-services\u002FSKILL.md",[],[102,103,104,105,106,107,108,109,23,25,85,110,111,112,113,114,115],"web services","web","services","tls","retries","calling","auth","downloads","clients","headers","secrets","json","build","REST",{"skillNo":117,"name":118,"nameZh":6,"description":119,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":120,"categories":121,"keywords":127,"publishedAt":28},"01M6KRF38Q4WSKAYFS56PG87T0","web-export","Use when shipping a Godot game to the browser — Web export preset options, threads vs no-threads and COOP\u002FCOEP headers, hosting on itch.io or your own server, PWA, JavaScriptBridge, user:\u002F\u002F persistence, audio and input limits, and load size","https:\u002F\u002Fgithub.com\u002Fjame581\u002FGodotPrompter\u002Fblob\u002Fmaster\u002Fskills\u002Fweb-export\u002FSKILL.md",[122],{"categoryNo":123,"categoryName":124,"taxonomyType":125,"taxonomyTypeDesc":126},"01JBSEEDCAT000000000000016","图像与多媒体","SCENARIO","使用场景",[103,128,129,130,131,132,133,134,111,135,136,25,137,138,139,140,141,142,23,143,144,145],"export","web export","threads","limits","shipping","size","options","hosting","input","Coop","preset","browser","game","io","load","pwa","Audio","server",{"skillNo":147,"name":148,"nameZh":6,"description":149,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":150,"categories":151,"keywords":160,"publishedAt":28},"01M6KREYFETEBH62ZTN6EZH2X3","using-godot-prompter","Bootstrap skill — establishes how to find and use GodotPrompter skills, with platform-specific tool mapping","https:\u002F\u002Fgithub.com\u002Fjame581\u002FGodotPrompter\u002Fblob\u002Fmaster\u002Fskills\u002Fusing-godot-prompter\u002FSKILL.md",[152,155],{"categoryNo":153,"categoryName":154,"taxonomyType":125,"taxonomyTypeDesc":126},"01JBSEEDCAT000000000000023","Skill与智能体开发",{"categoryNo":156,"categoryName":157,"taxonomyType":158,"taxonomyTypeDesc":159},"01JBSEEDCAT000000000000032","设计师","PROFESSION","适用职业",[85,161,162,163,164,23,165,166,167,168,169],"using godot prompter","find","with","bootstrap","tool","platform","mapping","how","how to",{"skillNo":171,"name":172,"nameZh":6,"description":173,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":174,"categories":175,"keywords":176,"publishedAt":28},"01M6KRER5G7EQWKGAFN8QJKQ69","tween-animation","Use when implementing tweens — property animation, method tweening, chaining, parallel sequences, easing, and common UI\u002Fgameplay motion recipes","https:\u002F\u002Fgithub.com\u002Fjame581\u002FGodotPrompter\u002Fblob\u002Fmaster\u002Fskills\u002Ftween-animation\u002FSKILL.md",[],[177,178,23,179,180,181,182,183,184,185,186,25,187],"tween animation","Animation","motion","parallel","gameplay","chaining","ui","recipes","common","implementing","sequences",{"skillNo":189,"name":190,"nameZh":6,"description":191,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":192,"categories":193,"keywords":194,"publishedAt":28},"01M6KREKGCQMVDV8WX7HWX8BZG","state-machine","Use when building a state machine or refactoring logic into one — enum, node, and resource-based FSM patterns with trade-offs. Not for adding states to an existing one","https:\u002F\u002Fgithub.com\u002Fjame581\u002FGodotPrompter\u002Fblob\u002Fmaster\u002Fskills\u002Fstate-machine\u002FSKILL.md",[],[22,195,196,85,25,197,198,199,200,201,163,23,186,202],"state machine","machine","patterns","node","fsm","state machines","trade","trade-offs"]