Как сделать русский язык в расте
Как включить русский язык в Rust
В современном мире трудно представить себе игру, которая хотя бы частично, но не была локализирована – переведена на язык страны, где она продаётся. Любая игра имеет хотя бы русскоязычное описание, если продаётся на территории РФ.
В RUST присутствуют множество языков. Один из них – русский. Переводом игры на различные языки занимается непосредственно само комьюнити(сообщество) игры, так что перевод может быть в каких-то местах неправильным, а где-то и вовсе отсутствовать.
Как поменять язык?
Сам язык игры можно изменить в главном меню. Для этого наведите мышку в верхний правый угол, там будет нарисован азиатский символ и латинская A. Нажимайте на эту иконку, после чего в открывшемся меню выберите нужную вам страну. В нашем случае это русский. После нажатия на флаг России у вас сразу же будет русский язык в игре без необходимости в перезапуске.
Языки переключаются не только через главное меню, но и в любой удобный для вас момент — это так же можно сделать. Для этого жмём Esc, так же находим флажок в верхнем правом углу, жмём по нему и переключается на необходимый нам язык.
Однако учитывайте, что игра не будет полностью на русском языке. Какая-то часть все равно остаётся на английском. Например, меню игры и настройки.
Смена языка в главном меню
В чём отличие русской версии от английской?
Как бы удивительно это не звучало, но различия версий заключаются по большей степени в переводе. Хотя есть одно, для многих не сильно важное, отличие. При использовании русской версии игры на карте (G) исчезают почти все обозначения рэдтаунов и карьеров. В английской же версии всё на своих местах.
Карта в Rust на английской версии 
Карта в Rust на русской версии
Как сделать русский Rust
В современном мире трудно представить себе игру, которая хотя бы частично, но не была локализирована – переведена на язык страны, где она продаётся. Любая игра имеет хотя бы русскоязычное описание, если продаётся на территории РФ, например. Так и Rust частично переводится на русский язык.
У некоторых игроков возникают сложности, потому что процесс переключения игры на русский язык не происходит по стандарту: открыли меню, нашли строку со словом Language и поменяли «English» на «Russian». Тем не менее, всё хотя и нестандартно, но довольно просто.
Переводим Rust на русский язык
Заходим в игру. Дождавшись загрузки и находясь в главном меню, обратите внимание на верхний правый угол окна.
В данный момент там русский флажок. Это говорит о том, что наша игра в данный момент русифицирована.
Если вам необходимо установить английский язык или какой-либо другой, щелкаем по флажку, появляется список языков, на которые можно сделать перевод. Каждый язык обозначен иконкой флажка некоторого государства. Щелкаем по флажку и можем наслаждаться.
Обратите внимание, после выбора русского языка абсолютно ВСЁ не переведётся, но большая часть надписей будет написана на нужном вам языке. Вот английское меню опций.
Как видим, все надписи английские. Теперь выберем русский флажок.
Взгляните! Остались английские надписи «Graphics», «Audio», но появились «Ввод» и «Настройки». Произошёл не полный, а частичный перевод. Однако его нам вполне хватит для комфортной игры.
Русификация Rust идёт постепенно
Если в игре появляются какие-либо новые предметы после обновлений, а их описание выполнено на английском языке, не огорчайтесь. Спустя какое-то время, если разработчики примут окончательное решение оставить вещь в игре, к ней обязательно появится русскоязычное описание.
Довольно странно так же то, что временами в Rust попадают вещи, но на русском языке они подписываются как-то, по меньшей мере, СТРАННО. Например, с полгода – год назад компонент «Корпус полуавтомата» подписывался как «ДАТЕ ТОП КЛАН СНГ».
Ещё раньше, год – полтора назад был изменён уровень защиты от радиации у противорадиационного костюма. Раньше была защита 70%, теперь стала 50%. Когда произошло это изменение, костюм имел название «Радиация съ*би» J.
Я лично был свидетелем того, как сырое мясо оленя пару дней реального времени буквально подписывали как «порубленный человеческий (сами додумайте что)».
Пара игровых советов
Для тех, кто занимается администрированием своего сервера и хочет выдать какую-либо вещь игроку, требуется ввод специальной команды в консоли администратора. Вам нужно ввести саму команду, название выдаваемого предмета и число этих предметов. Как вы понимаете, названия эти пишутся не по-русски.
Чтобы узнать английское название вещи, прямо в игре нажимаем Esc, в меню точно так же, как описано выше, меняем флажок на британский, жмём F1, переключаемся во вкладку «Items», ищем там нужный предмет и смотрим, что написано над ним. Именно таким названием в игре будет обозначена эта вещь.
И да, языки переключаются не только через главное меню, но и в любой удобный для вас момент это так же можно сделать. Для этого жмём Esc, так же находим флажок в верхнем правом углу, жмём по нему и переключается на необходимый нам язык.
Всем спасибо за внимание, желаем вам игровых успехов. Надеемся, ваш вопрос был решён, возвращайтесь к нам за новыми гайдами по игре Rust, всегда будем рады помочь. Ну, а вообще, учите английский язык, и таких проблем у вас никогда возникать не будет, да и с иностранцами проще станет играть.
Видеогайд
Rust. Как включить русский язык
Перед тем, как включить русский язык в Rust, должен вам сразу сказать: полноценной русификации в данной игре нет, и речь пойдёт о том, как выполнить частичный перевод в лицензионной Steam – версии. Вы увидите названия практически всех предметов в русском варианте, большинство действий переведутся, но настройки, а так же недавно введённые в игру предметы, получают лишь английские наименования и описания. Так что не ждите, что прочитаете описание предмета по-русски, если он, грубо говоря, вчера был внедрён в игру.
Как включить русский язык в Rust
Всё довольно просто. Нажмите Esc, если вы в игре. Переместите указатель мыши в правый верхний угол экрана. Там можно увидеть этот флажок.
Это на самом деле кнопка. Щёлкаем по ней. Появится список языков. Их, надо сказать, довольно много, и русский входит в данный перечень. Щелкаем по русскому флажку, и игра переведётся.
Как видим, даже название предметов в консоли получили после этого переведенные наименования.
Забавно, что иногда новые вещи получают довольно «интересный» перевод. В общем-то, и со старыми компонентами порой чудят. Например, пару лет назад Корпус полуавтомата назывался «ДАТЭ ТОП КЛАН СНГ». Противорадиационный костюм можно было найти под названием «Радиация съе…» Ну, вы поняли. Так же сырое мясо оленя кто-то додумался обозначить, как «порубленный человеческий …». Угадайте, о чём речь далее.
Короче говоря, весело включить в Rust русский язык.
Заключение
Полного перевода нет. Включить и отключить можно в любой момент описанным выше способом. Да, не удивляйтесь. Иногда активировать английский тоже нужно, потому что манипуляции с предметами через плагины, если вы администрируете сервера, производятся только с английскими наименованиями. Вы всегда их можете проверить, открыв консоль и переведя игру обратно на английский язык.
Команды, естественно, останутся такими же, как были. Консоль администратора тоже не русифицируется. Плагины будут управляться лишь на международном языке. Там что из этого можно вынести, что в наше время без английского совсем никак. Учить его принуждает сама жизнь. Действуйте, и вопросов в духе данной статьи беспокоить вас начнёт гораздо меньше.
Как поменять язык в RUST, ставим любой язык в РАСТ
Кто бы как не любил оригинальные названия и описания в RUST’e, а все это, на родном языке, выглядит куда круче, а главное – удобнее.
Еще совсем недавно, в RUST – была всем привычная система выбора языков, но в летнем патче – ее переделали, а главное – разработчики сделали более правильные описания как самой игры, так и предметов, и действий. Теперь, все это, выглядит не так коряво.
Как изменить язык в RUST
Все мы помним, что раньше, при нажатии кнопки ESC – высвечивался значок страны, чей язык используется в игре. Теперь же – все работает немного иначе.
Теперь разработчики добавили внутриигровую панель навигации. Находится она – в правой части экрана. Чтобы изменить язык – вам нужно будет навестись на эту панель и выбрать последний (нижний) значок, находящийся там (ХА).
Кликаете на этот значок – и у вас откроется таблица с флагами.
Выбрав нужный флаг, вы получите соответствующий перевод.
Обратите внимание на надпись вверху.
Пускай нынешний русский перевод выглядит куда лучше, чем был до этого, он все равно далек от совершенства, но выбора – уже не будет.
Примечательно, что работает эта функция как в главном меню, так и на сервере. Так что выбрать любой, подходящий язык – вы можете быстро и в любое время.
Прочитать позже Отправить статью на e-mail 
Мы не собираем ваши данные и тем более не передаем их третьим лицам Отправить
Что делает Rust универсальным языком программирования
Долгое время Rust позиционировался исключительно как язык для системного программирования. Попытки использовать Rust для высокоуровневых прикладных задач зачастую вызывали усмешку у значительной части сообщества: зачем использовать инструмент в том качестве, на которое он не рассчитан? Какая польза от возни с типами и анализатором заимствований (borrow checker), если есть Python и Java со сборкой мусора? Но другая часть сообщества всегда видела потенциал Rust именно как языка прикладного, и даже находила его удобным в использовании для быстрого прототипирования — во многом благодаря его особенностям, а не вопреки им.
Шло время, и сейчас использование Rust для высокоуровневых прикладных задач вызывает куда меньше споров, чем раньше. Сообщество накопило практический опыт, и практика показала, что у Rust есть свои преимущества в прикладной сфере. Посмотрите, как менялось официальное определение языка, с такого:
Rust is a systems programming language that runs blazingly fast, prevents segfaults, and guarantees thread safety.
Rust — невероятно быстрый язык для системного программирования без segfault’ов и с гарантиями потокобезопасности.
A language empowering everyone to build reliable and efficient software.
Язык, позволяющий каждому создавать надёжное и эффективное программное обеспечение.
Думаю, это хорошая иллюстрация смещения акцентов в позиционировании языка.
В данной статье я хочу рассказать о важных аспектах языка Rust, которые делают его универсальным, то есть равно успешно применимым и в системном, и в прикладном программировании. Более того, попытаюсь показать, как Rust устанавливает органичную связь между этими, казалось бы независимыми и даже противоположными сферами.
Что понимать под высоким и низким уровнем?
Понятия высокого/низкого уровня, применительно к языкам программирования, уже давно перестали носить абсолютный характер. По сравнению с ассемблером, язык Си — высокоуровневый, а по сравнению с Haskell — низкоуровневый. В случае с Rust ситуация усугубляется тем, что некоторые языковые возможности в нем близки к Haskell, а некоторые — к Си. Чтобы не запутаться, что считать высоким уровнем, а что низким, я предлагаю использовать простое правило: если языковая конструкция скорее выражает что мы делаем в терминах самой задачи, то она более высокого уровня, чем та, которая скорее говорит нам как именно реализуется решение.
Интересно, что с этой точки зрения декларативный подход выше уровнем, чем императивный. Также понятно, что для системного программирования особо важно, чтобы язык мог выражать как нечто работает в системе, потому что именно это как напрямую и есть что главной задачи системного программирования. Можно сказать, что низкоуровневый по отношению к множеству разных задач язык программирования может являться одновременно высокоуровневым предметно-ориентированным языком (DSL) для сугубо системных задач, так как лучшим образом отражает архитектуру системы.
unsafe-блоки
Давайте сразу обратимся к примеру и посмотрим, как в Rust работают итераторы:
Обратите внимание, что структура Iter содержит в качестве своих полей два указателя: ptr и end (строки 2 и 3). Из-за того, что эти указатели — это обычные Си-совместимые указатели (правда NonNull дополнительно требует, чтобы указатель не был нулевым), довольно низкоуровневые ссылочные типы, их время жизни никак не отслеживается borrow checker’ом. Поэтому заданное в объявлении структуры время жизни ссылки ‘a (1) мы вынуждены добавить в «фантомное» поле с типом нулевой размерности PhantomData (4). Иначе время жизни окажется никак не используемым внутри структуры, что приведет к ошибке компиляции. То есть, другими словами: мы хотим сделать безопасный итератор, который ссылается на элементы коллекции, по которой он итерируется, и для того, чтобы он был безопасным, нам нужно учитывать время жизни ссылок. Но наша внутренняя реализация основана на указателях и потому не подразумевает никакого отслеживания времен жизни со стороны компилятора. Поэтому мы должны гарантировать своей реализацией безопасность кода, работающего с указателями (в unsafe-блоках, подобных 5), и тогда можно реализовать безопасный внешний API по всем правилам работы в safe Rust.
Это очень наглядный пример того, что представляет собой Rust на самом деле. Это высокоуровневый, безопасный язык, в котором есть низкоуровневые небезопасные возможности. Тут граница, по которой одно отделяется от другого — это определение типа, а блоки unsafe выступают маркером того, что в реализации используются весьма низкоуровневые и небезопасные средства (на самом деле в общем случае граница проходит через определение модуля: пока в язык не будет добавлена возможность помечать поля как unsafe, потенциально небезопасным становится весь код в пределах модуля, если на поведение unsafe-методов влияет содержимое полей структуры).
Важный вывод, к которому мы здесь приходим, состоит в том, что Rust — самодостаточный язык. Его высокоуровневые возможности вполне реализуются на низком уровне им же самим. И наоборот: из низкоуровневых «кирпичей» в Rust можно конструировать высокоуровневые блоки, скрывая детали реализации за безопасным API.
Теперь должно быть понятно, что unsafe, который тут и там встречается в стандартной библиотеке Rust — это не баг, а фича. Есть довольно популярный упрек к Rust со стороны: дескать, какой же это безопасный и высокоуровневый язык, если у него в std сплошные unsafe-блоки? Он либо тогда должен быть весь unsafe, либо полностью safe. Но преимущество Rust как раз состоит в том, что он позволяет делать и то и другое, при этом отделяя одно от другого. Это одна из причин, почему Rust по-настоящему универсальный язык программирования.
Макросы
Посмотрите, как организуется простейший цикл for на Python:
Они похожи, не правда ли? Но for в Rust — это просто синтаксический сахар к более низкоуровневому представлению. Вот во что разворачивается данный цикл for :
Касательно процедурных макросов: забавно, как возможность делать низкоуровневые вещи открывает языку путь к построению предельно высокоуровневых абстракций. Дело в том, что процедурные макросы в Rust — это своего рода «плагины к компилятору», которые пишутся на самом Rust. Так как Rust — это язык без сборщика мусора, то он может использоваться для создания встраиваемых компонентов. В частности, можно написать динамическую библиотеку, которую подгрузит компилятор при компиляции вашей программы, и которая будет реализовывать ваши собственные расширения языка. Взглянем на пример использования атрибутных процедурных макросов в actix-web :
Здесь #[get(..)] и #[actix_rt::main] — это пользовательские атрибуты, которые приведут при компиляции к преобразованию элементов, на которые они навешены, в соответствии с заданной программой. Вот во что развернется код выше при компиляции:
Здесь макрос позволяет указать разметку в привычном виде, декларативно, на html-подобном языке, с вкраплениями Rust-кода. Похоже на JSX, расширение языка JavaScript. Только Rust изначально обладает средствами для создания подобных расширений, для него они — обычное дело.
Возможности процедурных макросов практически безграничны. Правда, вам самим придется заботиться о семантике, так как макросы работают на синтаксическом уровне, а рефлексии в Rust не предусмотрено. Тем не менее, грамотно написанные макросы могут сильно упростить создание абстракций, специфичных для конкретной предметной области. Таким образом, сам Rust становится низкоуровневым инструментом реализации требуемого высокоуровнего предметно-ориентированного языка, предельно соответствующего решаемой задаче.
В отличие от некоторых высокоуровневых языков (таких как Python), которые служат своего рода «клеем» для низкоуровневых компонентов, написанных на других языках, Rust сам выступает и в роли «клея», и в роли инструмента реализации «склеиваемых» компонентов.
Бесплатные абстракции
Удивительно, насколько наличие абстракций с нулевой стоимостью, даже самых элементарных, упрощает прикладную разработку. Посмотрите на следующий код, который написан на языке, считающимся высокоуровневым:
И сравните с тем, как то же самое поведение реализуется в Rust:
Где вам понятнее, что происходит и где, по-вашему, вероятность ошибиться меньше? Мне кажется, что ответ очевиден.
Числовой тип — это «низкоуровневый» тип, потому что он отвечает на вопрос как значение будет представлено в памяти, а не на вопрос что оно собой представляет в контексте задачи. Но в Rust можно очень легко и элегантно вводить новые типы поверх существующих:
Несмотря на то, что оба значения a и b имеют одинаковое числовое представление, они являются объектами разных типов, и поэтому перепутать и подставить одно значение вместо другого не получится. Этот паттерн называется «Новый тип» (New type), и он совершенно бесплатен в использовании. (Подробнее о преимуществах использования паттерна «Новый тип» вы можете прочитать в замечательной статье Передача намерений.)
«Новый тип», так же как и вообще любая пользовательская структура или перечисление в Rust, может выступать границей раздела нескольких уровней программирования. И чтобы пользователь мог переходить эту границу всегда, когда это удобно для решения его задачи, эти абстракции не должны сами по себе требовать сколь-либо значимых дополнительных расходов. Иначе пользователь будет вынужден чаще пользоваться имеющимися низкоуровневыми типами, вместо того, чтобы создавать на их основе свои, высокоуровневые.
Обобщенные типы
Помимо того, что обобщенные типы избавляют от написания шаблонного кода, они являются отличным инструментом абстрагирования и высокоуровневой спецификации поведения. Вот что я имею в виду:
Выглядит как что-то низкоуровневое. Но такое поведение часто реализует определенное требование самой задачи. Например, у нас есть тип с приватным конструктором:
Можно сделать так, что UserId будет возможно сконструировать только с помощью некоего сервиса, который либо выдает новое число из глобальной последовательности идентификаторов, либо десериализует значение UserId из ранее сконструированного и сохраненного. (Подробнее о преимуществах подобного подхода к проектированию типов вы можете прочитать в статье Парсите, а не валидируйте.)
Итак, на границе высокоуровневого и низкоуровневого кода, проходящей через определения обобщенных типов, мы можем столкнуться как с высокоуровневыми, так и с низкоуровневыми ограничениями, причем далеко не всегда просто отделить одни от других. Но помочь с этим может введение новых типажей:
Теперь можно вместо набора из трех ограничений писать только одно, которое автоматически будет выполняться для всякого типа, имеющего исходные три характеристики. Таким образом можно скрыть множество низкоуровневых требований за одним высокоуровневым.
Перечисление типов
АТД во многих случаях избавляет программиста от написания низкоуровневого кода для проверки целостности и непротиворечивости типов данных. Что актуально не только для языков с динамической типизацией, но и для статически типизированных языков.
Вообще, enum в Rust используется чуть менее, чем везде — и это прекрасно! Потому что АТД — это абстракция очень высокого уровня, сравнимая с наследованием классов и полиморфизмом подтипов в ООП. Выражение традиционно низкоуровневых концепций в терминах АТД неожиданно делает их не такими уж и низкоуровневыми.
Вот как решается проблема реализации отсутствующего значения в Rust:
Подробнее об АТД и преимуществах их использования, вы можете прочитать в статье Романа Душкина «Алгебраические типы данных и их использование в программировании».
Владение
Концепция владения в Rust постулирует единственность владельца ресурса в любой момент времени. Она вводилась для решения проблемы гонки данных при конкурентном доступе и проблемы использования памяти после освобождения. Однако кроме этого, концепция владения позволила легко реализовать механизм автоматического освобождения ресурсов, где ресурсом может выступать не только память, но также файлы, сокеты и любые другие пользовательские объекты. Если владелец ресурса всегда один, то когда он выходит из области видимости и уничтожается — ресурс автоматически освобождается. Пользователь может задавать собственную процедуру освобождения, реализуя типаж Drop для своего типа.
В Java, например, с try-with-resources ответственность за корректное освобождение ресурсов перекладывается на вызывающую сторону. К тому же не всегда использование ресурсов настолько локализовано, что безошибочное использование try-with-resources очевидно. Использование Cleaner улучшает ситуацию и избавляет пользователя от необходимости следить за освобождением в тривиальных случаях, но в более сложных — головной боли не избежать (подробнее о проблемах освобождения ресурсов в Java смотрите в лекции Евгения Козлова «Вы все еще используете finalize()? Тогда мы идем к вам»).
Rust же предоставляет простой и элегантный механизм, который основан на универсальной в рамках языка концепции владения, избавляющий программиста от необходимости низкоуровневого кодирования освобождения памяти и прочих ресурсов в местах их использования.
Дополнительно, с концепцией владения тесно связан принцип перемещения по-умолчанию: если вы передаете владельца из одного места в другое, то ресурс будет перемещен (логически), а не скопирован. Это удобно использовать при реализация всевозможных переходов, например, между состояниями абстрактного автомата:
Реализация подобного сценария желательна не так уж и редко, а в некоторых случаях она крайне необходима. Так что с помощью системы владения Rust защита последовательности смены состояний становится достаточно простым делом.
Заимствование
На низком уровне заимствование означает получение ссылки на объект, время жизни которой компилятор проверит на соответствие времени жизни исходного объекта. Но при взгляде с более высокого уровня, заимствование означает получение некоего представления (view), временно соотнесенного с исходным объектом. Такое представление не обязано быть единственным.
Что же в итоге?
Как видите, Rust — это не просто очередной системный язык программирования по мотивам Си. На системный язык, обогащенный рядом высокоуровневых концепций, можно смотреть и с другой стороны: как на прикладной язык, снабженный низкоуровневым инструментарием.
Полезны ли эти низкоуровневые инструменты в прикладной раработке? Я думаю, что да. Они позволяют создавать новые эффективные высокоуровневые абстракции, расширяя арсенал разработчика. Дополнительно, наличие средств, которые позволяют изолировать и связывать между собой разные уровни, делают Rust по-настоящему универсальным языком программирования.
Полагаю, что качество Rust-кода и удобство его доработки будет напрямую зависеть от того, насколько удачно программист решил проблему инкапсуляции низких уровней относительно высоких в рамках своей задачи. Конечно, тут у Rust еще большой простор для совершенствования, но имеющихся средств уже достаточно, чтобы довольно комфортно вести прикладную, высокоуровневую разработку, а не только решать низкоуровневые системные задачи.
Upd.: Отдельное спасибо T_12 за вычитку текста статьи и дельные замечания.