[![crates.io](https://img.shields.io/crates/v/social_tournament.svg)](https://crates.io/crates/social_tournament)
[![Documentation](https://docs.rs/social_tournament/badge.svg)](https://docs.rs/social_tournament)
[![Workflow](https://github.com/flocksserver/social_tournament/workflows/Rust/badge.svg)](https://github.com/flocksserver/social_tournament/workflows/Rust/badge.svg)
[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)


# Social Tournament

This is a library for creating tournament schedules for the sport I love.

🏓  table tennis 🏓

The focus is on meeting as many opponents and teammates as possible during the tournament. One can draw a single or double tournament.

## Example

### Single
Get rounds for a single tournament (round robin)
```rust
use social_tournament::{Round, SocialTournament, TournamentConfig, TableConfig};

let mut tournament = SocialTournament::new(TournamentConfig::Single {
    number_of_players: 12,
    number_of_rounds: 2,
    table_config: TableConfig { available_tables: 10, distribution_option: None }
});

tournament.draw().unwrap();
let rounds: Vec<Round> = tournament.rounds.unwrap();
/*
Creates:
Round number: 0
SingleMatch { a: 0, b: 9 }
SingleMatch { a: 1, b: 8 }
SingleMatch { a: 2, b: 7 }
SingleMatch { a: 3, b: 6 }
SingleMatch { a: 4, b: 5 }
--------------
Round number: 1
SingleMatch { a: 1, b: 9 }
SingleMatch { a: 2, b: 0 }
SingleMatch { a: 3, b: 8 }
SingleMatch { a: 4, b: 7 }
SingleMatch { a: 5, b: 6 }
--------------
...
*/
```

### Double
If you want to get rounds for a double tournament you have to do the following:
```rust
use social_tournament::{Round, SocialTournament, TournamentConfig, TableConfig};

let mut tournament = SocialTournament::new(TournamentConfig::Double {
    number_of_players: 24,
    number_of_rounds: 2,
    draw_option: None,
    table_config: TableConfig { available_tables: 10, distribution_option: None }
});

tournament.draw().unwrap();
let rounds: Vec<Round> = tournament.rounds.unwrap();
/*
Creates:
Round number: 0
DoubleMatch { double_a: (2, 37), double_b: (1, 38) }
DoubleMatch { double_a: (3, 36), double_b: (4, 35) }
DoubleMatch { double_a: (5, 34), double_b: (6, 33) }
DoubleMatch { double_a: (7, 32), double_b: (8, 31) }
DoubleMatch { double_a: (9, 30), double_b: (10, 29) }
DoubleMatch { double_a: (11, 28), double_b: (12, 27) }
DoubleMatch { double_a: (13, 26), double_b: (14, 25) }
DoubleMatch { double_a: (15, 24), double_b: (16, 23) }
DoubleMatch { double_a: (17, 22), double_b: (18, 21) }
--------------
Round number: 1
DoubleMatch { double_a: (20, 21), double_b: (2, 0) }
DoubleMatch { double_a: (3, 38), double_b: (7, 34) }
DoubleMatch { double_a: (4, 37), double_b: (6, 35) }
DoubleMatch { double_a: (5, 36), double_b: (9, 32) }
DoubleMatch { double_a: (8, 33), double_b: (10, 31) }
DoubleMatch { double_a: (11, 30), double_b: (15, 26) }
DoubleMatch { double_a: (12, 29), double_b: (14, 27) }
DoubleMatch { double_a: (13, 28), double_b: (17, 24) }
DoubleMatch { double_a: (16, 25), double_b: (18, 23) }
--------------
...
*/
```

#### Double Options
For number of players that are not completely divisible by 4 you can choose between three `DrawOption`.
Depending on the selected option you can have doubles with only 3 players, single matches or player with byes. You have to make sure that the player ids >= `number_of_players` in the schedule post processed correctly. So that you can mark them as byes for example.

### Table distribution
Tournament matches take place on tables in a room or gym. If the tournament is drawn, you can distribute the
matches in each round to available tables. Specify how many tables you can provide for the tournament in your room or gym. 
The algorithm ensures that enough sub-rounds are formed. You can specify the forming method by providing the DistributionOption. 
Depending on the option you choose, can have as many matches as possible in a sub-round or mainly even matches in each sub-round.
```rust
use social_tournament::{Round, SocialTournament, TournamentConfig, TableConfig};
use social_tournament::table::Table;

let mut tournament = SocialTournament::new(TournamentConfig::Double {
    number_of_players: 24,
    number_of_rounds: 2,
    draw_option: None,
    table_config: TableConfig { available_tables: 10, distribution_option: None }
});

tournament.draw().unwrap();
tournament.distribute().unwrap();

let tables: Vec<Vec<Table>> = tournament.tables.unwrap();
/*
Creates:
Table { table_number: 0, occupied_number: 0 }
Table { table_number: 1, occupied_number: 0 }
Table { table_number: 2, occupied_number: 0 }
Table { table_number: 3, occupied_number: 0 }
Table { table_number: 0, occupied_number: 1 }
Table { table_number: 1, occupied_number: 1 }
--------------
Table { table_number: 0, occupied_number: 0 }
Table { table_number: 1, occupied_number: 0 }
Table { table_number: 2, occupied_number: 0 }
Table { table_number: 3, occupied_number: 0 }
Table { table_number: 0, occupied_number: 1 }
Table { table_number: 1, occupied_number: 1 }
--------------
*/
```
### PDF creation
Currently, there is only the possibility for double tournaments to generate route cards as pdf. In the future will follow singles and referee sheet generation.
Available languages are English and German.
```rust
use social_tournament::{Round, SocialTournament, TournamentConfig, TableConfig};
use social_tournament::table::Table;
use social_tournament::pdf::language::Language;

let mut tournament = SocialTournament::new(TournamentConfig::Double {
    number_of_players: 24,
    number_of_rounds: 2,
    draw_option: None,
    table_config: TableConfig { available_tables: 10, distribution_option: None }
});

tournament.draw().unwrap();
tournament.distribute().unwrap();
tournament.create_route_cards_pdf(Language::EN).unwrap();

let pdf: Vec<u8> = tournament.pdf.unwrap();
```
A sample pdf looks like [this](sample.pdf).
## License

Licensed under either of

* Apache License, Version 2.0, ([LICENSE-APACHE](https://github.com/Flocksserver/social_tournament/blob/master/LICENSE_APACHE) or https://www.apache.org/licenses/LICENSE-2.0)
* MIT license ([LICENSE-MIT](https://github.com/Flocksserver/social_tournament/blob/master/LICENSE_MIT) or https://opensource.org/licenses/MIT)

at your option.

### Contribution

Unless you explicitly state otherwise, any contribution intentionally
submitted for inclusion in the work by you, as defined in the Apache-2.0
license, shall be dual licensed as above, without any additional terms or
conditions.