How do you write a multiplayer server in Rust using steamworks?
Writing a multiplayer server in Rust using Steamworks is a substantial task, but here's a general idea of how you can get started. 

For the purpose of this guide, I'll assume that you're familiar with Rust programming, networking concepts, and have a basic understanding of the Steamworks API.

1. **Setup**

   - Install the Rust compiler and Cargo, Rust's package manager. 
   
   - Create a new Rust project by running `cargo new my_game_server` in your terminal.
   
   - Add `steamworks` to your dependencies in your `Cargo.toml` file:

     ```toml
     [dependencies]
     steamworks = 0.7.0
     ```
   
     The version may change based on the time you are doing this. Always use the latest version that is compatible with your project.

2. **Initialize Steamworks**

   You'll need to initialize Steamworks before you can use it. You can do this in your main function:

   ```rust
   use steamworks::Client;

   fn main() {
       let (client, _single) = Client::init().unwrap();
   }
   ```

3. **Create a server**

   Using the `matchmaking` servers from Steamworks, you can create a server:

   ```rust
   let server = client.matchmaking_servers();
   ```

4. **Set up server**

   Configure the server with details like its game data, location, port, max player count, and so on. For example:

   ```rust
   server.create_dedicated_server(12345, 27015, game_data, US West, 32);
   ```

5. **Start server**

   Then start the server:

   ```rust
   server.start();
   ```

6. **Handle incoming connections**

   The main server loop will need to handle incoming connections, and game-specific messages from connected clients.

The above example is a very simplified version of what you might need to do, and it depends greatly on the specifics of your project. Steamworks API can be quite complex, especially when it comes to multiplayer networking, and you might also need to incorporate some game-specific networking logic.

Also, make sure you adhere to Steam's guidelines and terms of service when you're developing your server.

Lastly, keep in mind that you may want to look into using a networking library or framework to help manage connections, as well as handle tasks like serialization/deserialization of game data, managing player state, and so on. Examples of such libraries for Rust include `tokio`, `async-std`, and `smol`.

Please remember that you need to be a part of the Steam Partner Program and have your own Application ID to create servers for your game on Steam.

For the complete details, you should consult the Steamworks API documentation and Rust's `steamworks` library documentation.
What games can I use this multiplayer server for?
You can use this kind of multiplayer server setup for any game you develop that you wish to have multiplayer features. As long as your game is compatible with Steamworks, and you adhere to the Steam Partner Program guidelines, you can utilize this type of server.

This approach is typically used for creating dedicated game servers. It can be useful for a variety of game genres such as first-person shooters, strategy games, MMORPGs, and many more, provided that these games need or benefit from a dedicated server infrastructure.

This server setup is meant for your own games, games that you or your team develop. It's not intended for creating servers for already published games on the Steam platform, as that would likely violate the terms of service of those games and/or Steam itself.

In other words, if you're developing a game in Rust and plan to integrate it with Steam, you can use the approach outlined above to create a multiplayer server for your game.