build: Add Docker support

Author: balintkissdev

Dockerfile

@@ -0,0 +1,11 @@
+ARG APP_NAME=multiplayer-game-demo-rust
+
+FROM rust:1.81-bullseye as builder
+WORKDIR /usr/src/${APP_NAME}
+COPY . .
+RUN cargo install --path .
+
+FROM debian:bullseye-slim
+COPY --from=builder /usr/local/cargo/bin/${APP_NAME} /usr/local/bin/${APP_NAME}
+ENTRYPOINT ["multiplayer-game-demo-rust", "--server-only", "--trace"]
+

README.md

@@ -29,30 +29,37 @@ efficient application using real-time multiplayer game techniques. The project
 showcases confident understanding of networking and concurrency concepts as
 well as the use of Tokio async runtime.
 
+This application was tested under `tc-netem` network emulator simulating
+harsh network environment and packet loss, as well as live being deployed on a
+remote [Amazon EC2](https://aws.amazon.com/ec2/) virtual machine instance.
+
 Using conventional threads for concurrency and parallelism can be expensive due
 to the cost of requesting threads from the operating system and additional heap
 allocations (although thread pools mitigate this). Rust has language support
 for asynchronous programming, but does not ship with built-in implementation of
 an async runtime due to increase in compiled binary size. Instead it is opt-in
 with the inclusion of crates like [async-std](https://async.rs/),
-[Tokio](https://tokio.rs/) and [smol](https://github.com/smol-rs/smol). Tokio
-utilizes the concept of *green-threading* (concept similar to goroutines in the
-Go programming language) and the asynchronous I/O capabilities of the operating
-system (`epoll` on Linux, `IOCP` on Windows and `kqueue` on macOS).
+[Tokio](https://tokio.rs/), [mio](https://github.com/tokio-rs/mio) and
+[smol](https://github.com/smol-rs/smol). Tokio utilizes the concept of
+*green-threading* (concept similar to goroutines in the Go programming
+language) and the asynchronous I/O capabilities of the operating system
+(`epoll` on Linux, `IOCP` on Windows and `kqueue` on macOS).
 
 Game programming provides a challenging environment to put these concepts into
 practice due to them being classified as *soft real-time systems*, requiring
 response within a time of generating a frame in 16.666 milliseconds (60
 frames/second). Although TCP network protocol is used in conventional software
-systems, the `SYN/ACK` handshake procedure introduces additional latency. Real-time
-multiplayer game developers utilize UDP protocol for faster responses and make
-their own custom-tailored reliability protocol on top of it.
+systems, the `SYN/ACK` handshake procedure introduces additional latency.
+Real-time multiplayer game developers utilize the UDP protocol for faster
+responses at the cost of guaranteed packet delivery, and they create their own
+custom-tailored reliability protocols on top of it.
 
 ## Features
 
 - Client-server architecture for multiplayer networking. UDP socket
   communication for low-latency networking.
   - Health-check mechanism to detect lost network connections.
+  - Reliability patterns to mitigate harsh network environments like UDP packet losses.
 - Real-time multiplayer gameplay with smooth synchronization.
 - Graphical client application with GUI menu
 - Hardware-accelerated OpenGL rendering for 2D top-down perspective graphics.
@@ -74,19 +81,36 @@ Dependencies are automatically downloaded by `cargo`.
 1. Make sure you have the latest stable version of Rust and `cargo` installed, following the instructions on
 https://www.rust-lang.org/tools/install
 
-2. Clone the repository
+2. Clone the repository:
 
   ```sh
   git clone https://github.com/balintkissdev/multiplayer-game-demo-rust.git
   cd multiplayer-game-demo-rust
   ```
 
-3. Compile and execute the release build
+3. Compile and execute the release build:
 
   ```sh
   cargo run --release
   ```
 
+### Docker
+
+The application can also be deployed as a Docker container, which will run in server-only mode.
+
+1. Build the Docker image:
+
+```sh
+docker build -t multiplayer-game-demo-rust .
+```
+
+2. Launch the Docker container. This starts with `--server-only` and `--trace` options by
+default. See [Command line options](#command-line-options) for more info.
+
+```sh
+docker run -d -p 8080:8080 multiplayer-game-demo-rust
+```
+
 ## Usage
 
 You can test out the application on your local machine by executing multiple