# `QuakeServer.Outbox`
[🔗](https://github.com/jaman/quake_server/blob/v0.1.0/lib/quake_server/outbox.ex#L1)

What the server holds for each player until the player's next packet, as FTE keeps it
for a client: the reliable messages (`MSG_ONE`, reliable multicasts, prints), the
datagram (unreliable multicasts), and the last centerprint, which goes out with the
next packet after the reliable messages queued before it.

    server = QuakeServer.Outbox.print(server, 1, 2, "You got the shotgun\n")
    {%{reliable: [_], datagram: []}, server} = QuakeServer.Outbox.take(server, 1)

Each message is a binary of whole server messages, opening with its `svc` byte. The
players are the entities 1 to the server's `slots` once a player has connected.

# `packet`

```elixir
@type packet() :: %{reliable: [binary()], datagram: [binary()]}
```

A player's messages, oldest first.

# `centerprint`

```elixir
@spec centerprint(QuakeServer.Server.t(), pos_integer(), String.t()) ::
  QuakeServer.Server.t()
```

Make `text` the centerprint `player` gets with the next packet, replacing one waiting.

# `players`

```elixir
@spec players(QuakeServer.Server.t()) :: [pos_integer()]
```

The connected players.

# `print`

```elixir
@spec print(QuakeServer.Server.t(), pos_integer(), integer(), String.t()) ::
  QuakeServer.Server.t()
```

Queue `text` reliably for `player` as a print of `level` (`svc_print`).

# `reliable`

```elixir
@spec reliable(QuakeServer.Server.t(), pos_integer(), binary()) ::
  QuakeServer.Server.t()
```

Queue `bytes` reliably for `player`.

# `take`

```elixir
@spec take(QuakeServer.Server.t(), pos_integer()) ::
  {packet(), QuakeServer.Server.t()}
```

Take `player`'s packet: the reliable messages, then the waiting centerprint, and the datagram.

# `unreliable`

```elixir
@spec unreliable(QuakeServer.Server.t(), pos_integer(), binary()) ::
  QuakeServer.Server.t()
```

Add `bytes` to `player`'s datagram.

---

*Consult [api-reference.md](api-reference.md) for complete listing*