Add support for linear bots

This commit is contained in:
Pierre HUBERT 2022-09-17 12:02:13 +02:00
parent 6efaa81ecb
commit d1e8efc764
18 changed files with 344 additions and 72 deletions

View File

@ -0,0 +1,87 @@
use actix::Addr;
use uuid::Uuid;
use crate::data::{BoatsLayout, Coordinates, CurrentGameStatus, EndGameMap, FireResult, GameRules};
use crate::game::{Fire, Game, Player, RespondRequestRematch, SetBoatsLayout};
#[derive(Clone)]
pub struct LinearBot {
game: Addr<Game>,
uuid: Uuid,
}
impl LinearBot {
pub fn new(game: Addr<Game>) -> Self {
Self {
game,
uuid: Uuid::new_v4(),
}
}
}
impl Player for LinearBot {
fn get_name(&self) -> &str {
"Linear Bot"
}
fn get_uid(&self) -> Uuid {
self.uuid
}
fn is_bot(&self) -> bool {
true
}
fn set_other_player_name(&self, _name: &str) {}
fn query_boats_layout(&self, rules: &GameRules) {
match BoatsLayout::gen_random_for_rules(rules) {
Ok(layout) => self.game.do_send(SetBoatsLayout(self.uuid, layout)),
Err(e) => log::error!(
"Failed to use game rules to construct boats layout: {:?}",
e
),
}
}
fn rejected_boats_layout(&self, _errors: Vec<&'static str>) {
unreachable!()
}
fn notify_other_player_ready(&self) {}
fn notify_game_starting(&self) {}
fn request_fire(&self, status: CurrentGameStatus) {
self.game
.do_send(Fire(self.uuid, status.find_first_valid_fire_location()));
}
fn opponent_must_fire(&self, _status: CurrentGameStatus) {}
fn strike_result(&self, _c: Coordinates, _res: FireResult) {}
fn other_player_strike_result(&self, _c: Coordinates, _res: FireResult) {}
fn lost_game(&self, _your_map: EndGameMap, _opponent_map: EndGameMap) {}
fn won_game(&self, _your_map: EndGameMap, _opponent_map: EndGameMap) {}
fn opponent_requested_rematch(&self) {
self.game.do_send(RespondRequestRematch(self.uuid, true));
}
fn opponent_rejected_rematch(&self) {}
fn opponent_accepted_rematch(&self) {}
fn opponent_left_game(&self) {
// Human are not reliable lol
}
fn opponent_replaced_by_bot(&self) {
// Not such a good idea. will panic, just in case
panic!("Bot shall not play against each other (it is completely useless)");
}
}

View File

@ -0,0 +1,2 @@
pub mod linear_bot;
pub mod random_bot;

View File

@ -284,7 +284,7 @@ impl BoatsLayout {
mod test { mod test {
use crate::data::boats_layout::{BoatDirection, BoatPosition, BoatsLayout, Coordinates}; use crate::data::boats_layout::{BoatDirection, BoatPosition, BoatsLayout, Coordinates};
use crate::data::game_map::GameMap; use crate::data::game_map::GameMap;
use crate::data::{BotType, GameRules, PlayConfiguration}; use crate::data::{BotType, GameRules, PlayConfiguration, PrintableMap};
#[test] #[test]
fn get_boat_coordinates() { fn get_boat_coordinates() {

View File

@ -1,8 +1,10 @@
use rand::RngCore; use rand::RngCore;
use crate::data::{BoatPosition, BoatsLayout, Coordinates, GameRules}; use crate::data::{
BoatPosition, BoatsLayout, Coordinates, GameRules, MapCellContent, PrintableMap,
};
#[derive(Debug, serde::Serialize, serde::Deserialize)] #[derive(Debug, serde::Serialize, serde::Deserialize, Clone)]
pub struct CurrentGameMapStatus { pub struct CurrentGameMapStatus {
pub boats: BoatsLayout, pub boats: BoatsLayout,
pub successful_strikes: Vec<Coordinates>, pub successful_strikes: Vec<Coordinates>,
@ -10,7 +12,46 @@ pub struct CurrentGameMapStatus {
pub sunk_boats: Vec<BoatPosition>, pub sunk_boats: Vec<BoatPosition>,
} }
#[derive(Debug, serde::Serialize, serde::Deserialize)] impl CurrentGameMapStatus {
pub fn did_fire_at_location(&self, c: Coordinates) -> bool {
self.successful_strikes.contains(&c) || self.failed_strikes.contains(&c)
}
}
struct PrintableCurrentGameMapStatus(GameRules, CurrentGameMapStatus);
impl PrintableMap for PrintableCurrentGameMapStatus {
fn map_cell_content(&self, c: Coordinates) -> MapCellContent {
if !c.is_valid(&self.0) {
return MapCellContent::Invalid;
}
if self.1.failed_strikes.contains(&c) {
return MapCellContent::FailedStrike;
}
if self
.1
.sunk_boats
.iter()
.any(|b| b.all_coordinates().contains(&c))
{
return MapCellContent::SunkBoat;
}
if self.1.successful_strikes.contains(&c) {
return MapCellContent::TouchedBoat;
}
if self.1.boats.find_boat_at_position(c).is_some() {
return MapCellContent::Boat;
}
MapCellContent::Nothing
}
}
#[derive(Debug, serde::Serialize, serde::Deserialize, Clone)]
pub struct CurrentGameStatus { pub struct CurrentGameStatus {
pub rules: GameRules, pub rules: GameRules,
pub your_map: CurrentGameMapStatus, pub your_map: CurrentGameMapStatus,
@ -37,4 +78,26 @@ impl CurrentGameStatus {
} }
} }
} }
/// Find valid linear fire location. Loop until one is found
pub fn find_first_valid_fire_location(&self) -> Coordinates {
for y in 0..self.rules.map_height {
for x in 0..self.rules.map_width {
let coordinates = Coordinates::new(x as i32, y as i32);
if self.can_fire_at_location(coordinates) {
return coordinates;
}
}
}
panic!("Could not find fire location!")
}
pub fn print_your_map(&self) {
PrintableCurrentGameMapStatus(self.rules.clone(), self.your_map.clone()).print_map()
}
pub fn print_opponent_map(&self) {
PrintableCurrentGameMapStatus(self.rules.clone(), self.opponent_map.clone()).print_map()
}
} }

View File

@ -1,5 +1,7 @@
use crate::data::boats_layout::{BoatsLayout, Coordinates}; use crate::data::boats_layout::{BoatsLayout, Coordinates};
use crate::data::{BoatPosition, CurrentGameMapStatus, EndGameMap, GameRules}; use crate::data::{
BoatPosition, CurrentGameMapStatus, EndGameMap, GameRules, MapCellContent, PrintableMap,
};
#[derive(Debug, Copy, Clone, Eq, PartialEq, serde::Serialize, serde::Deserialize)] #[derive(Debug, Copy, Clone, Eq, PartialEq, serde::Serialize, serde::Deserialize)]
pub enum FireResult { pub enum FireResult {
@ -10,29 +12,6 @@ pub enum FireResult {
AlreadyTargetedPosition, AlreadyTargetedPosition,
} }
#[derive(Debug, Copy, Clone, Eq, PartialEq, serde::Serialize, serde::Deserialize)]
pub enum MapCellContent {
Invalid,
Nothing,
TouchedBoat,
SunkBoat,
Boat,
FailedStrike,
}
impl MapCellContent {
pub fn letter(&self) -> &'static str {
match self {
MapCellContent::Invalid => "!",
MapCellContent::Nothing => ".",
MapCellContent::TouchedBoat => "T",
MapCellContent::SunkBoat => "S",
MapCellContent::Boat => "B",
MapCellContent::FailedStrike => "x",
}
}
}
pub struct GameMap { pub struct GameMap {
rules: GameRules, rules: GameRules,
boats_config: BoatsLayout, boats_config: BoatsLayout,
@ -120,19 +99,6 @@ impl GameMap {
self.sunk_boats.len() == self.boats_config.number_of_boats() self.sunk_boats.len() == self.boats_config.number_of_boats()
} }
pub fn print_map(&self) {
for y in 0..self.rules.map_height {
for x in 0..self.rules.map_width {
print!(
"{} ",
self.get_cell_content(Coordinates::new(x as i32, y as i32))
.letter()
);
}
println!();
}
}
pub fn current_map_status(&self, for_opponent: bool) -> CurrentGameMapStatus { pub fn current_map_status(&self, for_opponent: bool) -> CurrentGameMapStatus {
CurrentGameMapStatus { CurrentGameMapStatus {
boats: match for_opponent { boats: match for_opponent {
@ -158,3 +124,9 @@ impl GameMap {
} }
} }
} }
impl PrintableMap for GameMap {
fn map_cell_content(&self, c: Coordinates) -> MapCellContent {
self.get_cell_content(c)
}
}

View File

@ -27,6 +27,11 @@ impl GameRules {
} }
} }
pub fn with_bot_type(mut self, t: BotType) -> Self {
self.bot_type = t;
self
}
/// Set the list of boats for this configuration /// Set the list of boats for this configuration
pub fn set_boats_list(&mut self, boats: &[usize]) { pub fn set_boats_list(&mut self, boats: &[usize]) {
self.boats_str = boats self.boats_str = boats

View File

@ -4,6 +4,7 @@ pub use end_game_map::*;
pub use game_map::*; pub use game_map::*;
pub use game_rules::*; pub use game_rules::*;
pub use play_config::*; pub use play_config::*;
pub use printable_map::*;
mod boats_layout; mod boats_layout;
mod current_game_status; mod current_game_status;
@ -11,3 +12,4 @@ mod end_game_map;
mod game_map; mod game_map;
mod game_rules; mod game_rules;
mod play_config; mod play_config;
mod printable_map;

View File

@ -4,7 +4,7 @@ use crate::consts::*;
#[derive(serde::Serialize, serde::Deserialize, Debug, Copy, Clone, Eq, PartialEq)] #[derive(serde::Serialize, serde::Deserialize, Debug, Copy, Clone, Eq, PartialEq)]
pub enum BotType { pub enum BotType {
Random, Random,
// TODO : LinearShooting Linear,
// TODO : GridBot // TODO : GridBot
// TODO : SmartBot // TODO : SmartBot
} }
@ -40,10 +40,16 @@ impl Default for PlayConfiguration {
max_map_height: MAX_MAP_HEIGHT, max_map_height: MAX_MAP_HEIGHT,
min_boats_number: MIN_BOATS_NUMBER, min_boats_number: MIN_BOATS_NUMBER,
max_boats_number: MAX_BOATS_NUMBER, max_boats_number: MAX_BOATS_NUMBER,
bot_types: vec![BotDescription { bot_types: vec![
r#type: BotType::Random, BotDescription {
description: "Random strike. All the time.".to_string(), r#type: BotType::Linear,
}], description: "Linear strike. Shoot A1, A2, A3, ..., B1, B2, ...".to_string(),
},
BotDescription {
r#type: BotType::Random,
description: "Random strike. All the time.".to_string(),
},
],
ordinate_alphabet: ALPHABET, ordinate_alphabet: ALPHABET,
} }
} }

View File

@ -0,0 +1,55 @@
use crate::data::Coordinates;
#[derive(Debug, Copy, Clone, Eq, PartialEq, serde::Serialize, serde::Deserialize)]
pub enum MapCellContent {
Invalid,
Nothing,
TouchedBoat,
SunkBoat,
Boat,
FailedStrike,
}
impl MapCellContent {
pub fn letter(&self) -> &'static str {
match self {
MapCellContent::Invalid => "!",
MapCellContent::Nothing => ".",
MapCellContent::TouchedBoat => "T",
MapCellContent::SunkBoat => "S",
MapCellContent::Boat => "B",
MapCellContent::FailedStrike => "x",
}
}
}
pub trait PrintableMap {
fn map_cell_content(&self, c: Coordinates) -> MapCellContent;
fn print_map(&self) {
let mut y = 0;
let mut x;
loop {
x = 0;
loop {
let content = self.map_cell_content(Coordinates::new(x, y));
if content == MapCellContent::Invalid {
break;
}
print!("{} ", content.letter());
x += 1;
}
println!();
// x == 0 <=> we reached the end of the map
if x == 0 {
break;
}
y += 1;
}
}
}

View File

@ -4,8 +4,8 @@ use actix::prelude::*;
use actix::{Actor, Context, Handler}; use actix::{Actor, Context, Handler};
use uuid::Uuid; use uuid::Uuid;
use crate::bots::random_bot::RandomBot;
use crate::data::*; use crate::data::*;
use crate::random_bot::RandomBot;
pub trait Player { pub trait Player {
fn get_name(&self) -> &str; fn get_name(&self) -> &str;

View File

@ -1,18 +1,19 @@
use std::sync::Arc; use std::sync::Arc;
use std::time::{Duration, Instant}; use std::time::{Duration, Instant};
use crate::bots::linear_bot::LinearBot;
use actix::prelude::*; use actix::prelude::*;
use actix::{Actor, Handler, StreamHandler}; use actix::{Actor, Handler, StreamHandler};
use actix_web_actors::ws; use actix_web_actors::ws;
use actix_web_actors::ws::{CloseCode, CloseReason, Message, ProtocolError, WebsocketContext}; use actix_web_actors::ws::{CloseCode, CloseReason, Message, ProtocolError, WebsocketContext};
use uuid::Uuid; use uuid::Uuid;
use crate::bots::random_bot::RandomBot;
use crate::data::{ use crate::data::{
BoatsLayout, BotType, Coordinates, CurrentGameStatus, EndGameMap, FireResult, GameRules, BoatsLayout, BotType, Coordinates, CurrentGameStatus, EndGameMap, FireResult, GameRules,
}; };
use crate::game::{AddPlayer, Game}; use crate::game::{AddPlayer, Game};
use crate::human_player::HumanPlayer; use crate::human_player::HumanPlayer;
use crate::random_bot::RandomBot;
/// How often heartbeat pings are sent /// How often heartbeat pings are sent
const HEARTBEAT_INTERVAL: Duration = Duration::from_secs(10); const HEARTBEAT_INTERVAL: Duration = Duration::from_secs(10);
@ -41,7 +42,7 @@ pub enum ClientMessage {
#[derive(Message)] #[derive(Message)]
#[rtype(result = "()")] #[rtype(result = "()")]
#[derive(serde::Serialize, serde::Deserialize, Debug)] #[derive(serde::Serialize, serde::Deserialize, Debug, Clone)]
#[serde(tag = "type")] #[serde(tag = "type")]
pub enum ServerMessage { pub enum ServerMessage {
WaitingForAnotherPlayer, WaitingForAnotherPlayer,
@ -147,6 +148,9 @@ impl Actor for HumanPlayerWS {
BotType::Random => { BotType::Random => {
game.do_send(AddPlayer(Arc::new(RandomBot::new(game.clone())))); game.do_send(AddPlayer(Arc::new(RandomBot::new(game.clone()))));
} }
BotType::Linear => {
game.do_send(AddPlayer(Arc::new(LinearBot::new(game.clone()))));
}
}; };
let player = Arc::new(HumanPlayer { let player = Arc::new(HumanPlayer {

View File

@ -1,12 +1,12 @@
extern crate core; extern crate core;
pub mod args; pub mod args;
pub mod bots;
pub mod consts; pub mod consts;
pub mod data; pub mod data;
pub mod game; pub mod game;
pub mod human_player; pub mod human_player;
pub mod human_player_ws; pub mod human_player_ws;
pub mod random_bot;
pub mod server; pub mod server;
#[cfg(test)] #[cfg(test)]
mod test; mod test;

View File

@ -1,10 +1,11 @@
use crate::args::Args;
use crate::data::{GameRules, PlayConfiguration};
use crate::human_player_ws::{HumanPlayerWS, StartMode};
use actix_cors::Cors; use actix_cors::Cors;
use actix_web::{web, App, HttpRequest, HttpResponse, HttpServer, Responder}; use actix_web::{web, App, HttpRequest, HttpResponse, HttpServer, Responder};
use actix_web_actors::ws; use actix_web_actors::ws;
use crate::args::Args;
use crate::data::{GameRules, PlayConfiguration};
use crate::human_player_ws::{HumanPlayerWS, StartMode};
/// The default '/' route /// The default '/' route
async fn index() -> impl Responder { async fn index() -> impl Responder {
HttpResponse::Ok().json("Sea battle backend") HttpResponse::Ok().json("Sea battle backend")
@ -54,6 +55,8 @@ pub async fn start_server(args: Args) -> std::io::Result<()> {
.wrap(cors) .wrap(cors)
.route("/config", web::get().to(game_configuration)) .route("/config", web::get().to(game_configuration))
.route("/play/bot", web::get().to(start_bot_play)) .route("/play/bot", web::get().to(start_bot_play))
// TODO : create & accept invite
// TODO : join random
.route("/", web::get().to(index)) .route("/", web::get().to(index))
.route("{tail:.*}", web::get().to(not_found)) .route("{tail:.*}", web::get().to(not_found))
}) })

View File

@ -20,6 +20,7 @@ pub struct BotClient {
requested_rules: GameRules, requested_rules: GameRules,
layout: Option<BoatsLayout>, layout: Option<BoatsLayout>,
number_plays: usize, number_plays: usize,
server_msg_callback: Option<Box<dyn Fn(&ServerMessage)>>,
} }
impl BotClient { impl BotClient {
@ -32,6 +33,7 @@ impl BotClient {
requested_rules: GameRules::random_players_rules(), requested_rules: GameRules::random_players_rules(),
layout: None, layout: None,
number_plays: 1, number_plays: 1,
server_msg_callback: None,
} }
} }
@ -50,6 +52,14 @@ impl BotClient {
self self
} }
pub fn with_server_msg_callback<F>(mut self, cb: F) -> Self
where
F: Fn(&ServerMessage) + 'static,
{
self.server_msg_callback = Some(Box::new(cb));
self
}
pub async fn run_client(&self) -> Result<ClientEndResult, Box<dyn Error>> { pub async fn run_client(&self) -> Result<ClientEndResult, Box<dyn Error>> {
let mut remaining_games = self.number_plays; let mut remaining_games = self.number_plays;
@ -97,6 +107,10 @@ impl BotClient {
} }
}; };
if let Some(cb) = &self.server_msg_callback {
(cb)(&message)
}
match message { match message {
ServerMessage::WaitingForAnotherPlayer => { ServerMessage::WaitingForAnotherPlayer => {
log::debug!("Waiting for other player...") log::debug!("Waiting for other player...")

View File

@ -0,0 +1,51 @@
use tokio::task;
use crate::args::Args;
use crate::data::{BotType, Coordinates, GameRules};
use crate::human_player_ws::ServerMessage;
use crate::server::start_server;
use crate::test::bot_client::ClientEndResult;
use crate::test::network_utils::wait_for_port;
use crate::test::{bot_client, TestPort};
fn check_strikes_are_linear(msg: &ServerMessage) {
if let ServerMessage::RequestFire { status } = msg {
let mut in_fire_location = true;
for y in 0..status.rules.map_height {
for x in 0..status.rules.map_width {
let c = Coordinates::new(x as i32, y as i32);
if in_fire_location {
in_fire_location = status.your_map.did_fire_at_location(c);
} else if status.your_map.did_fire_at_location(c) {
println!("Your map:");
status.print_your_map();
println!("Opponent map:");
status.print_opponent_map();
panic!("Found invalid fire location for linear bot!");
}
}
}
}
}
#[tokio::test]
async fn full_game() {
let _ = env_logger::builder().is_test(true).try_init();
let local_set = task::LocalSet::new();
local_set
.run_until(async move {
task::spawn_local(start_server(Args::for_test(TestPort::LinearBotFullGame)));
wait_for_port(TestPort::LinearBotFullGame.port()).await;
let res = bot_client::BotClient::new(TestPort::LinearBotFullGame.as_url())
.with_rules(GameRules::random_players_rules().with_bot_type(BotType::Linear))
.with_server_msg_callback(check_strikes_are_linear)
.run_client()
.await
.unwrap();
assert_eq!(res, ClientEndResult::Finished);
})
.await;
}

View File

@ -72,11 +72,11 @@ async fn full_game_no_touching_boats() {
let mut rules = GameRules::random_players_rules(); let mut rules = GameRules::random_players_rules();
rules.boats_can_touch = false; rules.boats_can_touch = false;
task::spawn_local(start_server(Args::for_test( task::spawn_local(start_server(Args::for_test(
TestPort::FullGameTouchingBoats, TestPort::FullGameNoTouchingBoats,
))); )));
wait_for_port(TestPort::FullGameTouchingBoats.port()).await; wait_for_port(TestPort::FullGameNoTouchingBoats.port()).await;
let res = bot_client::BotClient::new(TestPort::FullGameTouchingBoats.as_url()) let res = bot_client::BotClient::new(TestPort::FullGameNoTouchingBoats.as_url())
.with_rules(rules) .with_rules(rules)
.run_client() .run_client()
.await .await
@ -97,20 +97,21 @@ async fn invalid_boats_layout_number_of_boats() {
let mut rules = GameRules::random_players_rules(); let mut rules = GameRules::random_players_rules();
rules.boats_can_touch = false; rules.boats_can_touch = false;
task::spawn_local(start_server(Args::for_test( task::spawn_local(start_server(Args::for_test(
TestPort::FullGameTouchingBoats, TestPort::InvalidBoatsLayoutNumberOfBoats,
))); )));
wait_for_port(TestPort::FullGameTouchingBoats.port()).await; wait_for_port(TestPort::InvalidBoatsLayoutNumberOfBoats.port()).await;
let mut rules_modified = rules.clone(); let mut rules_modified = rules.clone();
rules_modified.pop_boat(); rules_modified.pop_boat();
let layout = BoatsLayout::gen_random_for_rules(&rules_modified).unwrap(); let layout = BoatsLayout::gen_random_for_rules(&rules_modified).unwrap();
let res = bot_client::BotClient::new(&TestPort::FullGameTouchingBoats.as_url()) let res =
.with_rules(rules) bot_client::BotClient::new(&TestPort::InvalidBoatsLayoutNumberOfBoats.as_url())
.with_layout(layout) .with_rules(rules)
.run_client() .with_layout(layout)
.await .run_client()
.unwrap(); .await
.unwrap();
assert_eq!(res, ClientEndResult::InvalidBoatsLayout); assert_eq!(res, ClientEndResult::InvalidBoatsLayout);
}) })
@ -127,16 +128,16 @@ async fn invalid_boats_layout_len_of_a_boat() {
let mut rules = GameRules::random_players_rules(); let mut rules = GameRules::random_players_rules();
rules.boats_can_touch = false; rules.boats_can_touch = false;
task::spawn_local(start_server(Args::for_test( task::spawn_local(start_server(Args::for_test(
TestPort::FullGameTouchingBoats, TestPort::InvalidBoatsLayoutLenOfABoat,
))); )));
wait_for_port(TestPort::FullGameTouchingBoats.port()).await; wait_for_port(TestPort::InvalidBoatsLayoutLenOfABoat.port()).await;
let mut rules_modified = rules.clone(); let mut rules_modified = rules.clone();
let previous = rules_modified.pop_boat(); let previous = rules_modified.pop_boat();
rules_modified.add_boat(previous - 1); rules_modified.add_boat(previous - 1);
let layout = BoatsLayout::gen_random_for_rules(&rules_modified).unwrap(); let layout = BoatsLayout::gen_random_for_rules(&rules_modified).unwrap();
let res = bot_client::BotClient::new(&TestPort::FullGameTouchingBoats.as_url()) let res = bot_client::BotClient::new(&TestPort::InvalidBoatsLayoutLenOfABoat.as_url())
.with_rules(rules) .with_rules(rules)
.with_layout(layout) .with_layout(layout)
.run_client() .run_client()
@ -155,10 +156,12 @@ async fn full_game_multiple_rematches() {
let local_set = task::LocalSet::new(); let local_set = task::LocalSet::new();
local_set local_set
.run_until(async move { .run_until(async move {
task::spawn_local(start_server(Args::for_test(TestPort::FullGame))); task::spawn_local(start_server(Args::for_test(
wait_for_port(TestPort::FullGame.port()).await; TestPort::FullGameMultipleRematch,
)));
wait_for_port(TestPort::FullGameMultipleRematch.port()).await;
let res = bot_client::BotClient::new(TestPort::FullGame.as_url()) let res = bot_client::BotClient::new(TestPort::FullGameMultipleRematch.as_url())
.with_number_plays(5) .with_number_plays(5)
.run_client() .run_client()
.await .await

View File

@ -5,7 +5,11 @@ enum TestPort {
ClientInvalidPort = 20000, ClientInvalidPort = 20000,
ClientInvalidRules, ClientInvalidRules,
FullGame, FullGame,
FullGameTouchingBoats, FullGameNoTouchingBoats,
InvalidBoatsLayoutNumberOfBoats,
InvalidBoatsLayoutLenOfABoat,
FullGameMultipleRematch,
LinearBotFullGame,
} }
impl TestPort { impl TestPort {
@ -29,5 +33,6 @@ impl Args {
#[cfg(test)] #[cfg(test)]
pub mod bot_client; pub mod bot_client;
mod bot_client_bot_play; mod bot_client_bot_linear_play;
mod bot_client_bot_random_play;
mod network_utils; mod network_utils;