Table of Contents
Rust implementation of StarCraft II API
The library aims to be simple and easy to use, being very fast and functional at the same time. However, it provides both high and low level abstractions. This lib is inspired by python-sc2 lib, so people might find it easy to switch to rust-sc2. It was originally created because other rust libs were old, not functional and low level.
Feel free to ask questions in #rust channel of Starcraft 2 AI Discord server
Install latest stable Rust (Older versions may also work, but compatibility is not guaranteed)
Create your project
cargo new <project_name>
Add to dependencies in Cargo.toml:
[dependencies]
rust-sc2 = "1"Or if you want developer version directly from github:
[dependencies]
rust-sc2 = { git = "https://github.com/UltraMachine/rust-sc2" }Or if you want to use a local version:
[dependencies]
rust-sc2 = { path = "/path/to/rust-sc2" }NOTE: Version of this library on crates.io is outdated and lacks many features. Unfortunately, I can't update it yet, so it's highly recommended to use github version for now.
Install SC2 through Battle.net.
- Install Lutris from your package manager
- Install Battle.net dependencies. (Wine and Vulkan drivers)
- Install SC2 through Lutris
- Download most recent Linux Package (Maps will come with the zip)
- Unzip to ~/StarCraftII (you'll need the End User License Agreement Password above the Linux Packages link)
- Move your
.SC2Mapfiles up out of theirLadderXXXXSeasonXdirectory toMapsdirectory. (Since there are multiple versions of the same map, there is no way of knowing which one you want.)
The simplest competetive bot in less than 30 lines. Copy this into your /path/to/project/main.rs
use rust_sc2::prelude::*;
#[bot]
#[derive(Default)]
struct WorkerRush;
impl Player for WorkerRush {
fn get_player_settings(&self) -> PlayerSettings {
PlayerSettings::new(Race::Protoss)
}
fn on_start(&mut self) -> SC2Result<()> {
for worker in &self.units.my.workers {
worker.attack(Target::Pos(self.enemy_start), false);
}
Ok(())
}
}
fn main() -> SC2Result<()> {
let mut bot = WorkerRush::default();
run_vs_computer(
&mut bot,
Computer::new(Race::Random, Difficulty::Medium, None),
"EternalEmpireLE",
Default::default(),
)
}Note: The Linux client doesn't have the map EternalEmpireLE so you'll need to download it, or reference another map from the LadderXXXXSeasonX directories.
export SC2PATH="/home/<user>/Games/starcraft-ii/drive_c/Program Files (x86)/StarCraft II"- Make sure you have this snippet in your project's Cargo.toml:
[features]
wine_sc2 = ["rust-sc2/wine_sc2"]
cargo run --features wine_sc2
export SC2PATH=/abs/path/to/StarCraftIIcargo run
There are more advanced examples in the examples folder. To run one of these examples on your own machine, say the Reaper Rush one, clone this repository, navigate to the root folder and run the command
cargo run --example reaper-rush -- local
In addition to local (or human if you want to play against your own bot), these examples take several arguments. For a full list in either case, run the commands
cargo run --example reaper-rush -- local --help
cargo run --example reaper-rush -- human --help
"rayon"- enables parallelism and makes all types threadsafe"serde"- adds implementation ofSerialize,Deserializeto ids, Race, GameResult, ..."wine_sc2"- allows you to run headful SC2 through Lutris and Wine
First of all, import rust-sc2 lib:
use rust_sc2::prelude::*;Create your bot's struct (Can be Unit or C-like):
#[bot]
struct MyBot;#[bot]
struct MyBot {
/* fields here */
}Then implement Player trait for your bot:
// You mustn't call any of these methods by hands, they're for API only
impl Player for MyBot {
// Must be implemented
fn get_player_settings(&self) -> PlayerSettings {
// Race can be Terran, Zerg, Protoss or Random
PlayerSettings::new(Race::Random)
}
// Methods below aren't necessary to implement (Empty by default)
// Called once on first step
fn on_start(&mut self) -> SC2Result<()> {
/* your awesome code here */
}
// Called on every game step
fn on_step(&mut self, iteration: usize) -> SC2Result<()> {
/* your awesome code here */
}
// Called once on last step
// "result" says if your bot won or lost game
fn on_end(&self, result: GameResult) -> SC2Result<()> {
/* your awesome code here */
}
// Called on different events, see more in `examples/events.rs`
fn on_event(&mut self, event: Event) -> SC2Result<()> {
/* your awesome code here */
}
}Also you might want to add method to construct it:
impl MyBot {
// It's necessary to have #[bot_new] here
#[bot_new]
fn new() -> Self {
Self {
/* initializing fields */
}
}
}If your bot implements Default you can simply call MyBot::default(), but if you want more control over initializer:
impl MyBot {
// You don't need #[bot_new] here, because of "..Default::default()"
fn new() -> Self {
Self {
/* initializing fields */
..Default::default()
}
}
}The rest is to run it:
fn main() -> SC2Result<()> {
let mut bot = MyBot::new();
run_vs_computer(
&mut bot,
Computer::new(
Race::Random,
Difficulty::VeryEasy,
None, // AI Build (random here)
),
"EternalEmpireLE", // Map name
LaunchOptions::default(),
)
}
![dependabot-preview[bot] avatar](https://avatars.githubusercontent.com/in/2141?v=4 "dependabot-preview[bot]")
![dependabot[bot] avatar](https://avatars.githubusercontent.com/in/29110?v=4 "dependabot[bot]")
React
Typescript
Django
Laravel
Facebook
Microsoft
Google
Alibaba
D3
Tencent