Всем привет. Это небольшой гайд о том как создавать мультиплеерные игры. Я изучаю rust, так что некоторые моменты могут быть не совсем верны. Надеюсь что гуру rust поправят меня если увидят что-то не правильное.
Мы будем делать мультиплеерный пинг-понг. Исходный код доступен здесь.
Инструменты
-
Rust — язык программирования. Отличный язык программирования. Даже если вы не собираетесь на нем писать, рекомендую изучить базовые концепции языка.
-
gRPC — Фреймворк для удаленного вызова процедур. Здесь все просто. Представьте что вы хотите пообщаться с кем-то на заранее озвученные темы. Вот здесь то же самое — в Protocol Buffers (Protobuf) — формате описываются заранее оговоренные темы для общения клиента с сервером.
-
Tetra — игровой движок. Очень простой. Ничего сложного для первого проекта нам и не нужно.
Настройка проекта и gRPC
Начнем с создания проекта:
cargo new ping_pong_multiplayerВ папке src создаем два файла: client.rs и server.rs — один для клиента, другой для сервера.
В корне проекта создаем build.rs — для генерации gRPC кода.
main.rs удаляем.
Файл Cargo.toml будет выглядеть так:
[package] name = "ping_pong_multiplayer" version = "0.1.0" edition = "2018" [dependencies] prost = "^0.8.0" tonic = "^0.5.2" tetra = "^0.6.5" tokio = { version = "^1.12.0", features = ["macros", "rt-multi-thread"] } rand = "0.8.4" [build-dependencies] tonic-build = "^0.5.2" #server binary [[bin]] name = "server" path = "src/server.rs" #client binary [[bin]] name = "client" path = "src/client.rs" Зависимости prost и tonik — для gRPC, tokio — для сервера, rand — для элемента случайности в игре и tetra — игровой движок. В build-dependencies упомянут tonic-build — нужен для кодогенерации из proto-файла.
Далее, в папке src создаем новую директорию proto, внутри нее файл game.proto. Тут мы будем описывать то, о чем будут общаться клиенты с сервером. Вообще, у gRPC есть много вариантов коммуникаций и стриминг и двунаправленный стриминг. Я не буду останавливаться на каждом. Мы возьмём самый простой вариант: клиент посылает запрос, сервер возвращает ответ.
Открываем файл game.proto и печатаем:
syntax = "proto3"; package game; service GameProto { rpc PlayRequest (PlayGameRequest) returns (PlayGameResponse); } message PlayGameRequest { FloatTuple windowSize = 1; FloatTuple player1Texture = 2; FloatTuple player2Texture = 3; FloatTuple ballTexture = 4; } message PlayGameResponse { FloatTuple player1Position = 1; FloatTuple player2Position = 2; uint32 playersCount = 3; uint32 currentPlayerNumber = 4; Ball ball = 5; } message Ball { FloatTuple position = 1; FloatTuple velocity = 2; } message FloatTuple { float x = 1; float y = 2; }В первой строчке мы указываем версию синтаксиса. Дальше идет инициация пакета. В строчке
rpc PlayRequest (PlayGameRequest) returns (PlayGameResponse);описываем о чем будет клиент говорить с сервером. Здесь мы будем посылать запрос по имени PlayRequest с типом PlayGameRequest на сервер и получать в ответ тип данных PlayGameResponse. Что лежит в этих данных описано ниже:
message PlayGameRequest { FloatTuple windowSize = 1; FloatTuple player1Texture = 2; FloatTuple player2Texture = 3; FloatTuple ballTexture = 4; }При запросе к серверу от клиента на разрешение играть, мы высылаем размеры окна, размеры текстур игроков (в нашем случае — ракеток) и размеры мяча. Размеры игровых объектов можно было бы хранить на сервере чтобы не высылать их, но в этом случае у нас было бы два места, которые надо обновить если вдруг у нас поменялись текстуры — сервер и клиент.
В ответ с сервера мы отвечаем:
message PlayGameResponse { FloatTuple player1Position = 1; FloatTuple player2Position = 2; uint32 playersCount = 3; uint32 currentPlayerNumber = 4; Ball ball = 5; } Информацию где в окне должны располагаться ракетки, общее количество игроков за столом, порядковый номер текущего игрока и положение мяча.
Типы данных
message Ball { FloatTuple position = 1; FloatTuple velocity = 2; } message FloatTuple { float x = 1; float y = 2; }вспомогательные.
Все они после кодогенерации превратятся в структуры.
В данном гайде я не буду паковать данные. Например,
uint32 playersCount = 3; uint32 currentPlayerNumber = 4; Можно было бы запаковать в один uint32, потому что я сомневаюсь что мы сейчас сделаем настолько популярную игру, что количество игроков превысило бы uint16, а это 65535 в десятичной системе. Но тема упаковки данных выходит за рамки этого гайда.
Теперь мы удаляем main.rs, а в client.rs и server.rs прописываем:
fn main(){}build.rs будет выглядеть так:
fn main() -> Result<(), Box<dyn std::error::Error>> { tonic_build::configure() .compile( &["src/proto/game.proto"], &["src/proto"], ).unwrap(); Ok(()) }Чтобы сгенерировать код из proto файла, просто запускаем билд:
cargo buildВ результате в папке target\debug\build\ping_pong_multiplayer-tetra_check-e8cc5eb2d2c25880\out\ будет лежать файл game.rs. В вашем случае хэш-часть имени папки ping_pong_multiplayer-tetra_check-e8cc5eb2d2c25880 будет другой. Можете открыть этот файл — им мы будем пользоваться при написании и клиента и сервера. Мы можем регулировать куда будет сложен сгенерированный файл. Например, если мы создадим папку src\generated\ и укажем в build.rs:
fn main() -> Result<(), Box<dyn std::error::Error>> { tonic_build::configure() .out_dir("src/generated") .compile( &["src/proto/game.proto"], &["src/proto"], ).unwrap(); Ok(()) } То сгенерированный файл будет в папке src\generated\.
Сервер
Чтобы сервер и клиент имели доступ с сгенерированному файлу, создадим в папке src файл generated_shared.rs со следующим содержимым:
tonic::include_proto!("game"); Теперь у нас есть все, чтобы начать писать сервер:
use tonic::transport::Server; use generated_shared::game_proto_server::{GameProto, GameProtoServer}; use generated_shared::{Ball, FloatTuple, PlayGameRequest, PlayGameResponse}; mod generated_shared; pub struct PlayGame { } impl PlayGame { fn new() -> PlayGame { PlayGame { } } } #[tonic::async_trait] impl GameProto for PlayGame { async fn play_request( &self, request: tonic::Request<PlayGameRequest>, ) -> Result<tonic::Response<PlayGameResponse>, tonic::Status> { unimplemented!() } } #[tokio::main] async fn main() -> Result<(), Box<dyn std::error::Error>> { let addr = "[::1]:50051".parse()?; let play_game = PlayGame::new(); println!("Server listening on {}", addr); Server::builder() .add_service(GameProtoServer::new(play_game)) .serve(addr) .await?; Ok(()) } Это пустой каркас. После запуска вы увидите несколько warning. Не обращайте на них пока что внимания:
% cargo run --bin server Compiling ping_pong_multiplayer v0.1.0 warning: unused imports: `Ball`, `FloatTuple` --> src/server.rs:3:24 | 3 | use generated_shared::{Ball, FloatTuple, PlayGameRequest, PlayGameResponse}; | ^^^^ ^^^^^^^^^^ | = note: `#[warn(unused_imports)]` on by default warning: unused variable: `request` --> src/server.rs:20:9 | 20 | request: tonic::Request<PlayGameRequest>, | ^^^^^^^ help: if this is intentional, prefix it with an underscore: `_request` | = note: `#[warn(unused_variables)]` on by default warning: `ping_pong_multiplayer` (bin "server") generated 2 warnings Finished dev [unoptimized + debuginfo] target(s) in 1.70s Running `target/debug/server` Server listening on [::1]:50051 В этом коде эту часть:
async fn play_request( &self, request: tonic::Request<PlayGameRequest>, ) -> Result<tonic::Response<PlayGameResponse>, tonic::Status> { uninmplemented!(); } мы взяли из сгенерированного файла. Именно тут мы получаем на вход PlayGameRequest и отвечать клиенту будем PlayGameResponse.
Сразу приведу готовый код и прокомментирую его:
use tonic::{transport::Server, Response}; use generated_shared::game_proto_server::{GameProto, GameProtoServer}; use generated_shared::{Ball, FloatTuple, PlayGameRequest, PlayGameResponse}; use std::sync::{Mutex, Arc}; use tetra::math::Vec2; use rand::Rng; mod generated_shared; const BALL_SPEED: f32 = 5.0; #[derive(Clone)] struct Entity { texture_size: Vec2<f32>, position: Vec2<f32>, velocity: Vec2<f32>, } impl Entity { fn new(texture_size: Vec2<f32>, position: Vec2<f32>) -> Entity { Entity::with_velocity(texture_size, position, Vec2::zero()) } fn with_velocity(texture_size: Vec2<f32>, position: Vec2<f32>, velocity: Vec2<f32>) -> Entity { Entity { texture_size, position, velocity } } } #[derive(Clone)] struct World { player1: Entity, player2: Entity, ball: Entity, world_size: Vec2<f32>, winner: u32, } pub struct PlayGame { world: Arc<Mutex<Option<World>>>, players_count: Arc<Mutex<u32>>, } impl PlayGame { fn new() -> PlayGame { PlayGame { world: Arc::new(Mutex::new(None)), players_count: Arc::new(Mutex::new(0u32)), } } fn init(&self, window_size: FloatTuple, player1_texture: FloatTuple, player2_texture: FloatTuple, ball_texture: FloatTuple) { let window_width = window_size.x; let window_height = window_size.y; let world = Arc::clone(&self.world); let mut world = world.lock().unwrap(); let players_count = Arc::clone(&self.players_count); let players_count = players_count.lock().unwrap().clone(); let mut ball_velocity = 0f32; if players_count >= 2 { let num = rand::thread_rng().gen_range(0..2); if num == 0 { ball_velocity = -BALL_SPEED; } else { ball_velocity = BALL_SPEED; } } *world = Option::Some(World { player1: Entity::new( Vec2::new(player1_texture.x, player1_texture.y), Vec2::new( 16.0, (window_height - player1_texture.y) / 2.0, ), ), player2: Entity::new( Vec2::new(player2_texture.x, player2_texture.y), Vec2::new( window_width - player2_texture.y - 16.0, (window_height - player2_texture.y) / 2.0, ), ), ball: Entity::with_velocity( Vec2::new(ball_texture.x, ball_texture.y), Vec2::new( window_width / 2.0 - ball_texture.x / 2.0, window_height / 2.0 - ball_texture.y / 2.0, ), Vec2::new( ball_velocity, 0f32, ), ), world_size: Vec2::new(window_size.x, window_size.y), // No one win yet winner: 2, }); } fn increase_players_count(&self) { let players_count = Arc::clone(&self.players_count); let mut players_count = players_count.lock().unwrap(); *players_count += 1; } } #[tonic::async_trait] impl GameProto for PlayGame { async fn play_request( &self, request: tonic::Request<PlayGameRequest>, ) -> Result<tonic::Response<PlayGameResponse>, tonic::Status> { let pgr: PlayGameRequest = request.into_inner(); let window_size = pgr.window_size.unwrap(); let player1_texture = pgr.player1_texture.unwrap(); let player2_texture = pgr.player2_texture.unwrap(); let ball_texture_height = pgr.ball_texture.unwrap(); self.increase_players_count(); self.init(window_size, player1_texture, player2_texture, ball_texture_height); let world = Arc::clone(&self.world).lock().unwrap().as_ref().unwrap().clone(); let current_players = Arc::clone(&self.players_count); let current_players = current_players.lock().unwrap(); let reply = PlayGameResponse { player1_position: Option::Some(FloatTuple { x: world.player1.position.x, y: world.player1.position.y, }), player2_position: Option::Some(FloatTuple { x: world.player2.position.x, y: world.player2.position.y, }), current_player_number: current_players.clone(), players_count: current_players.clone(), ball: Option::Some(Ball { position: Option::Some(FloatTuple { x: world.ball.position.x, y: world.ball.position.y, }), velocity: Option::Some(FloatTuple { x: world.ball.velocity.x, y: world.ball.velocity.y, }), }), }; Ok(Response::new(reply)) } } #[tokio::main] async fn main() -> Result<(), Box<dyn std::error::Error>> { let addr = "[::1]:50051".parse()?; let play_game = PlayGame::new(); println!("Server listening on {}", addr); Server::builder() .add_service(GameProtoServer::new(play_game)) .serve(addr) .await?; Ok(()) } Наша «главная» структура — PlayGame. Здесь мы храним весь мир и текущее количество игроков. Оба поля обернуты в Arc<Mutex<>> потому что обращение к этим структурам будет многопоточным. Вообще, в rust просто рай для программирования многопоточных программ. Только слегка многословно получается.
Перво-наперво, мы получаем данные от клиента:
let pgr: PlayGameRequest = request.into_inner(); Эту структуру(PlayGameRequest) мы можем найти в сгенерированном файле чтобы посмотреть какие там поля. Далее, из входных данных мы вытаскиваем:
let window_size = pgr.window_size.unwrap(); let player1_texture = pgr.player1_texture.unwrap(); let player2_texture = pgr.player2_texture.unwrap(); let ball_texture_height = pgr.ball_texture.unwrap();При каждом новом клиенте, нам надо увеличить количество игроков:
fn increase_players_count(&self) { let players_count = Arc::clone(&self.players_count); let mut players_count = players_count.lock().unwrap(); *players_count += 1; }Это обычное изменение данных, обернутых в Arc<Mutex<>>.
С данными от клиента, нам надо инициализировать мир. Для этого вызываем функцию self.init(). В общем-то здесь ничего примечательного кроме
let mut ball_velocity = 0f32; if players_count >= 2 { let num = rand::thread_rng().gen_range(0..2); if num == 0 { ball_velocity = -BALL_SPEED; } else { ball_velocity = BALL_SPEED; } } Если за столом только один игрок и второго еще нет, то мяч стоит на месте — его скорость 0. Если же пришел второй игрок, то игра начинается и мяч должен начать двигаться. Хотелось бы чтобы он начинал двигаться в случайную сторону. Потому генерируется либо 0 либо 1 и в зависимости от того что выпало, мяч движется влево или вправо.
После того как мы инициировали мир для клиента, нам надо его вернуть в ответе. Для этого мы должны ответить структурой PlayGameResponse — ее поля и «внутренности» можно тоже увидеть в сгенерированном game.rs файле. Компилируем, запускаем. Проверяем что все работает:
% cargo run --bin server Compiling ping_pong_multiplayer v0.1.0 (/Users/macbook/rust/IdeaProjects/ping_pong_multiplayer) Finished dev [unoptimized + debuginfo] target(s) in 5.62s Running `target/debug/server` Server listening on [::1]:50051 Обратите внимание что все warning пропали.
Клиент
Как я уже упоминал, мы будем использовать игровой движок tetra. Он очень простой и с ним легко разобраться. Собственно, пинг-понг был выбран потому что у них на сайте есть гайд по созданию именно этой игры.
Прежде чем писать клиент, надо загрузить ресурсы. Создаем папку resources в корне проекта. Загружаем туда картинки из репозитория.
Теперь мы можем написать каркас:
use tetra::graphics::{self, Color, Texture}; use tetra::math::Vec2; use tetra::{TetraError}; use tetra::{Context, ContextBuilder, State}; mod generated_shared; const WINDOW_WIDTH: f32 = 1200.0; const WINDOW_HEIGHT: f32 = 720.0; fn main() -> Result<(), TetraError> { ContextBuilder::new("Pong", WINDOW_WIDTH as i32, WINDOW_HEIGHT as i32) .quit_on_escape(true) .build()? .run(GameState::new) } struct Entity { texture: Texture, position: Vec2<f32>, velocity: Vec2<f32>, } impl Entity { fn new(texture: &Texture, position: Vec2<f32>) -> Entity { Entity::with_velocity(&texture, position, Vec2::zero()) } fn with_velocity(texture: &Texture, position: Vec2<f32>, velocity: Vec2<f32>) -> Entity { Entity { texture: texture.clone(), position, velocity } } } struct GameState { player1: Entity, player2: Entity, ball: Entity, player_number: u32, players_count: u32, } impl GameState { fn new(ctx: &mut Context) -> tetra::Result<GameState> { let player1_texture = Texture::new(ctx, "./resources/player1.png")?; let player2_texture = Texture::new(ctx, "./resources/player2.png")?; let ball_texture = Texture::new(ctx, "./resources/ball.png")?; Ok(GameState { player1: Entity::new(&player1_texture, Vec2::new(16., 100.)), player2: Entity::new(&player2_texture, Vec2::new(116., 100.)), ball: Entity::with_velocity(&ball_texture, Vec2::new(52., 125.), Vec2::new(0., 0.)), player_number: 0u32, players_count: 0u32, }) } } impl State for GameState { fn update(&mut self, ctx: &mut Context) -> tetra::Result { Ok(()) } fn draw(&mut self, ctx: &mut Context) -> tetra::Result { graphics::clear(ctx, Color::rgb(0.392, 0.584, 0.929)); self.player1.texture.draw(ctx, self.player1.position); self.player2.texture.draw(ctx, self.player2.position); self.ball.texture.draw(ctx, self.ball.position); Ok(()) } } Можете заметить что на стороне клиента у нас тоже есть структура Entity и единственное её отличие от серверной структуры — тип данных для поля texture. Вообще, если реализовать трейт Send для типа данных Texture, то мы могли бы вынести эту структуру в общий для клиента и сервера файл. Но это слегка за рамками данного гайда.
Так же, можно обратить внимание на
impl State for GameState здесь у нас есть функции update и draw. Tetra для отображения и изменения игры, требует реализацию этих функций.
Можно запустить и посмотреть что рисуется окошко с голубым фоном, рисуются ракетки и мяч:
Чтобы общаться с сервером, напишем небольшую функцию:
async fn establish_connection() -> GameProtoClient<tonic::transport::Channel> { GameProtoClient::connect("http://[::1]:50051").await.expect("Can't connect to the server") } Опять же, GameProtoClient объявлен в сгенерированном файле. Этот коннект мы будем использовать всю нашу игру. Так как это future, мы должны остановить выполнение программы для создания коннекта. Так же, мы должны его передать дальше в контекст игры. Потому функция main теперь выглядит так:
fn main() -> Result<(), TetraError> { let rt = tokio::runtime::Runtime::new().expect("Error runtime creation"); let mut client = rt.block_on(establish_connection()); ContextBuilder::new("Pong", WINDOW_WIDTH as i32, WINDOW_HEIGHT as i32) .quit_on_escape(true) .build()? .run(|ctx|GameState::new(ctx, &mut client)) } Тут типичная работа с future. Вообще, в rust есть целый отдельный crate для работы с future, но нам он не понадобится.
Итого, у нас есть коннект, мы знаем что от нас ждет сервер и что он ответит. Осталось только написать это:
use tetra::graphics::{self, Color, Texture}; use tetra::math::Vec2; use tetra::{TetraError}; use tetra::{Context, ContextBuilder, State}; use generated_shared::game_proto_client::GameProtoClient; use generated_shared::{FloatTuple, PlayGameRequest, PlayGameResponse}; mod generated_shared; const WINDOW_WIDTH: f32 = 1200.0; const WINDOW_HEIGHT: f32 = 720.0; async fn establish_connection() -> GameProtoClient<tonic::transport::Channel> { GameProtoClient::connect("http://[::1]:50051").await.expect("Can't connect to the server") } fn main() -> Result<(), TetraError> { let rt = tokio::runtime::Runtime::new().expect("Error runtime creation"); let mut client = rt.block_on(establish_connection()); ContextBuilder::new("Pong", WINDOW_WIDTH as i32, WINDOW_HEIGHT as i32) .quit_on_escape(true) .build()? .run(|ctx|GameState::new(ctx, &mut client)) } struct Entity { texture: Texture, position: Vec2<f32>, velocity: Vec2<f32>, } impl Entity { fn new(texture: &Texture, position: Vec2<f32>) -> Entity { Entity::with_velocity(&texture, position, Vec2::zero()) } fn with_velocity(texture: &Texture, position: Vec2<f32>, velocity: Vec2<f32>) -> Entity { Entity { texture: texture.clone(), position, velocity } } } struct GameState { player1: Entity, player2: Entity, ball: Entity, player_number: u32, players_count: u32, client: GameProtoClient<tonic::transport::Channel>, } impl GameState { fn new(ctx: &mut Context, client : &mut GameProtoClient<tonic::transport::Channel>) -> tetra::Result<GameState> { let player1_texture = Texture::new(ctx, "./resources/player1.png")?; let ball_texture = Texture::new(ctx, "./resources/ball.png")?; let player2_texture = Texture::new(ctx, "./resources/player2.png")?; let play_request = GameState::play_request(&player1_texture, &player2_texture, &ball_texture, client); let ball = play_request.ball.expect("Cannot get ball's data from server"); let ball_position = ball.position.expect("Cannot get ball position from server"); let ball_position = Vec2::new( ball_position.x, ball_position.y, ); let ball_velocity = ball.velocity.expect("Cannot get ball velocity from server"); let ball_velocity = Vec2::new( ball_velocity.x, ball_velocity.y, ); let player1_position = &play_request.player1_position .expect("Cannot get player position from server"); let player1_position = Vec2::new( player1_position.x, player1_position.y, ); let player2_position = &play_request.player2_position .expect("Cannot get player position from server"); let player2_position = Vec2::new( player2_position.x, player2_position.y, ); let player_number = play_request.current_player_number; Ok(GameState { player1: Entity::new(&player1_texture, player1_position), player2: Entity::new(&player2_texture, player2_position), ball: Entity::with_velocity(&ball_texture, ball_position, ball_velocity), player_number, players_count: player_number, client: client.clone(), }) } #[tokio::main] async fn play_request(player1_texture: &Texture, player2_texture: &Texture, ball_texture: &Texture, client : &mut GameProtoClient<tonic::transport::Channel>) -> PlayGameResponse { let request = tonic::Request::new(PlayGameRequest { window_size: Some(FloatTuple { x: WINDOW_WIDTH, y: WINDOW_HEIGHT }), player1_texture: Some( FloatTuple { x: player1_texture.width() as f32, y: player1_texture.height() as f32 } ), player2_texture: Some( FloatTuple { x: player2_texture.width() as f32, y: player2_texture.height() as f32 } ), ball_texture: Some( FloatTuple { x: ball_texture.width() as f32, y: ball_texture.height() as f32 } ), }); client.play_request(request).await.expect("Cannot get Play Response the server").into_inner() } } impl State for GameState { fn update(&mut self, ctx: &mut Context) -> tetra::Result { Ok(()) } fn draw(&mut self, ctx: &mut Context) -> tetra::Result { graphics::clear(ctx, Color::rgb(0.392, 0.584, 0.929)); self.player1.texture.draw(ctx, self.player1.position); self.player2.texture.draw(ctx, self.player2.position); self.ball.texture.draw(ctx, self.ball.position); Ok(()) } } Здесь нет чего-то нового для нас. Мы создали функцию для запроса на игру: play_request. В сгенерированном файле есть функция с таким же именем — там мы посмотрели что она ждет на вход и что возвращает.
Можно запустить сервер:
% cargo run --bin server Compiling ping_pong_multiplayer v0.1.0 Finished dev [unoptimized + debuginfo] target(s) in 4.45s Running `target/debug/server` Server listening on [::1]:50051Запустить клиент. Не обращайте внимания на warning — нам эти поля понадобятся позже:
% cargo run --bin client warning: unused variable: `ctx` --> src/client.rs:104:26 | 104 | fn update(&mut self, ctx: &mut Context) -> tetra::Result { | ^^^ help: if this is intentional, prefix it with an underscore: `_ctx` | = note: `#[warn(unused_variables)]` on by default warning: field is never read: `velocity` --> src/client.rs:28:5 | 28 | velocity: Vec2<f32>, | ^^^^^^^^^^^^^^^^^^^ | = note: `#[warn(dead_code)]` on by default warning: field is never read: `player_number` --> src/client.rs:42:5 | 42 | player_number: u32, | ^^^^^^^^^^^^^^^^^^ warning: field is never read: `players_count` --> src/client.rs:43:5 | 43 | players_count: u32, | ^^^^^^^^^^^^^^^^^^ warning: field is never read: `client` --> src/client.rs:44:5 | 44 | client: GameProtoClient<tonic::transport::Channel>, | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ warning: `ping_pong_multiplayer` (bin "client") generated 5 warnings Finished dev [unoptimized + debuginfo] target(s) in 0.44s Running `target/debug/client`И увидеть что ракетки и мяч расположились в правильных местах на экране:
На этот раз все. Спасибо за внимание. В следующей части мы добавим движение объектов, управление ракетками и вывод информации о победе игрока.
ссылка на оригинал статьи https://habr.com/ru/articles/585958/
Добавить комментарий