lightyear 0.29.0

Server-client networking library for the Bevy game engine with modular architecture
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

# Lightyear

[![crates.io](https://img.shields.io/crates/v/lightyear)](https://crates.io/crates/lightyear)
[![docs.rs](https://docs.rs/lightyear/badge.svg)](https://docs.rs/lightyear)
[![codecov](https://codecov.io/gh/cBournhonesque/lightyear/branch/main/graph/badge.svg?token=N1G28NQB1L)](https://codecov.io/gh/cBournhonesque/lightyear)

A library for writing server-authoritative multiplayer games with [Bevy](https://bevyengine.org/). Compatible with wasm
via WebTransport.

## Getting started

For Bevy 0.19, add Lightyear to your project with:

```toml
[dependencies]
lightyear = "0.29"
```

You can first check out the [examples](https://github.com/cBournhonesque/lightyear/tree/main/examples).

To quickly get started, you can follow
this [tutorial](https://cbournhonesque.github.io/lightyear/book/tutorial/title.html), which re-creates
the [simple_box](https://github.com/cBournhonesque/lightyear/tree/main/examples/simple_box) example.

You can also find more information in this WIP [book](https://cbournhonesque.github.io/lightyear/book/).

## Repository layout

Workspace crate sources live under `crates/`, grouped by role. Directory names drop the `lightyear_` prefix, but Cargo package names keep it.

- `crates/io`: low-level IO links and backends such as `aeronet`, `link`, `udp`, `crossbeam`, `websocket`, and `webtransport`
- `crates/connection`: connection abstractions and adapters such as `connection`, `raw_connection`, `netcode`, and `steam`
- `crates/core`: the top-level `lightyear` crate plus shared core, sync, utils, and frame interpolation crates
- `crates/inputs`: input crates such as `inputs`, `inputs_native`, `input_bei`, and `inputs_leafwing`
- `crates/replication`: replication, prediction, and interpolation crates
- `crates/transport`: serialization, transport, and message crates
- `crates/integration`: Bevy ecosystem integrations such as Avian
- `crates/platform`, `crates/deterministic`, `crates/tools`, and `crates/tests`: platform support, deterministic replication, tooling, and test support

## Related projects

- [lightyear-template](https://github.com/Piefayth/lightyear-template/tree/main): opiniated template for a bevy + lightyear starter project

### Games

- [Lumina](https://github.com/nixon-voxell/lumina)
- [cycles.io](https://github.com/cBournhonesque/jam5) for bevy jam 5: https://cbournhonesque.itch.io/cyclesio


## Features


- Transport-agnostic: *Lightyear* is compatible with a number of IO backends, including:
    - UDP sockets
    - Uses [`aeronet`](https://github.com/aecsocket/aeronet) for WebSocket, Steam and WebTransport support
- Serialization
    - *Lightyear* uses `postcard` as a default serializer, but you can provide your own serialization function
- Message passing
    - *Lightyear* supports sending packets with different guarantees of ordering and reliability through the use of
      channels.
    - Packet fragmentation (for messages larger than ~1200 bytes) is supported
- Input handling
    - *Lightyear* has special handling for player inputs (mouse presses, keyboards).
      They are buffered every tick on the `Client`, and *lightyear* makes sure that the client input for tick `N` will
      be processed on tick `N` on the server.
      Inputs are protected against packet-loss: each packet will contain the client inputs for the last few frames.
    - With the `leafwing` feature, there is a special integration with
      the [`leafwing-input-manager`](https://github.com/Leafwing-Studios/leafwing-input-manager) crate, where
      your `leafwing` inputs are networked for you!
    - Also supports the [`bevy-enhanced-input`](https://github.com/projectharmonia/bevy_enhanced_input) crate!
- Deterministic replication
    - *Lightyear* supports deterministic replication when only inputs are replicated. The simulation needs to be deterministic.
      The deterministic replication is compatible with both lockstep and prediction/rollback.
- World Replication
    - `lightyear` uses [`bevy_replicon`](https://github.com/simgine/bevy_replicon) to enable world replication features
      (replication, interest management, pre-spawning, etc.)
- Advanced replication
    - **Client-side prediction**: with just a one-line change, you can enable client-prediction with rollback on the
      client, so that your inputs can feel responsive
    - **Snapshot interpolation**: with just a one-line change, you can enable Snapshot interpolation so that entities
      are smoothly interpolated even if replicated infrequently.
    - **Input Delay**: you can add a custom amount of input-delay as a trade-off between having a more responsive game
      or more miss-predictions
    - **Bandwidth Management**: you can set a cap to the bandwidth for the connection. Then messages will be sent in
      decreasing order of priority (that you can set yourself), with a priority-accumulation scheme
    - **Lag Compensation** is available so that predicted entities can interact with interpolated entities (used most often for fps games)
- Various topologies supported
    - You can run your app in client-server mode or in P2P mode. You can also have a client act as the server (host-client mode).
- Examples
    - *Lightyear* has plenty of examples demonstrating all these features, as well as the integration with other bevy
      crates such as `avian`


## Supported bevy version

| Lightyear | Bevy |
|-----------|------|
| 0.28-0.29 | 0.19 |
| 0.26-0.27 | 0.18 |
| 0.25      | 0.17 |
| 0.20-0.24 | 0.16 |
| 0.18-0.19 | 0.15 |
| 0.16-0.17 | 0.14 |
| 0.10-0.15 | 0.13 |
| 0.1-0.9   | 0.12 |