• Шаг 1. Перейти на сайт.
• Шаг 2. Прислать фото студенческого билета.
• Шаг 3. На сайт JetBrains

Шаг 1. Перейти на сайт.

Вам нужно перейти на сайт студенческих аккаунтов GitHub https://education.github.com/.

Регистрируемся там (если у вас нет аккаунта GitHub, то сразу и на гите).

Шаг 2. Прислать фото студенческого билета.

Фото должно быть аналогично тому, что ниже

Шаг 3. На сайт JetBrains

Перейдите на сайт https://www.jetbrains.com/

Далее

Заполняем анкету через гитхаб:

Шаг 4. Радуемся

• Цели
• Программы
• Настройка терминала
• Установка Nerd Fonts
• Настройка цветов
• Starship

Цели

Сегодня при слове "терминал" есть сочетание слов типа Ubuntu, Linux ну и или MacOS. Операционная система Windows неправомерно подвержена гонению. Я намерен это исправить и создать офигенный шаблон для написания ПО в ОС Windows. Все темы бесплатны и в свободном доступе.

Иными словами, мы делаем из этого:

Это:

Программы

Для работы нам понадобится несколько программ. Для базовой работы я возьму такие приложения как:

• Sublime Text 3. Задача Sublime Text'а создать удобную среду для работы с кодом. Сейчас я больше всего пишу на Python и покажу как выглядит код в Sublime из коробки. Я использую автоматическую тему, которая подстроится под системную.

• Typora. Так как я пишу много текста про код — его нужно оформить. Я оформляю текст в маркдауне (это такой шаблон написания текста с кодом). Все PDFки, которые вы тут видите (в том числе и эту) — работа данного ПО. Тема — Night. Дополнительные темы можно посмотреть тут.

• NotePad++. Это ещё один текстовый редактор. С ним я чиню конфигурационные файлы, так как очень легко менять кодировки и размеры символов. Тема как у системы + фиолетовая.

• Windows Terminal. Это улучшенная версия системного ПО Windows (командной строки). Добавлены много фич. О них мы ещё поговорим.

На данный момент есть несколько сложностей со скачиванием всех утилит. Чтобы упростить задачу, всё что нужно дня скачивания из программ я поместил в этот архив.

Настройка терминала

Какие настройки я выставил в самом терминале. Для их настройки я перешёл во вкладку "Параметры":

По умолчанию, настройки выставятся в очень стандартный и весьма красивый вид.

Многие спрашивали меня как установить Ubuntu в терминал Windows. На самом деле, это проще чем кажется.

• Переходим в панель управления.

• Затем, выбираем пункт "Удаление программ" (не волнуйтесь, мы не будем ничего удалять).

• Выбираем в открывшемся окошке пункт "Включение или отключение компонентов Windows"

• Далее, нас интересует пункт "Подсистема Windows для Linux". Этот пункт нужно включить.

• Дальше, всё просто — заходим в MS Store и скачиваем нужную систему.

Установка Nerd Fonts

Установим крутые темы в виде текста и символов. Переходим на сайт Nerd Fonts. И нажимаем кнопочку Download. Там выбирайте любую тему, которая вам понравилась. Лично мне очень нравится тема JetBrainsMono. Её я и скачал. Ещё я использовал Hack Nerd Font.

Далее, наша задача разархивировать папку куда угодно и установить все шрифты. Самый простой способ это сделать: открыть папку, выделить все файлы (Ctrl+A), правая кнопка мыши, установить для всех пользователей.

Далее, после установки, перейдите в настройки терминала и выберите понравившейся шрифт по умолчанию.

Настройка цветов

Настройка цветов может быть любой, но я подготовил отдельный файл, в котором указаны все настройка цветовой схемы. Для её настройки, перейдите в раздел настройки терминала "Цветовые схемы" и используете готовую.

Чтобы сделать тему уникальной, можно открыть JSON файл (внизу слева) в терминале и настроить цветовую палитру детально. Тут нам тоже помогает Sublime Text

Чтобы всё работало хорошо, скопируйте и вставьте всё, что в фигурных скобках в пункте defaults, не трогайте пункт list и вставьте пункт schemes.

{
    "$help": "https://aka.ms/terminal-documentation",
    "$schema": "https://aka.ms/terminal-profiles-schema",
    "actions": [],
    "defaultProfile": "{574e775e-4f2a-5b96-ac1e-a2962a402336}",
    "firstWindowPreference": "defaultProfile",
    "profiles": 
    {
        "defaults": 
        {
            "colorScheme": "xcad",
            "cursorShape": "filledBox",
            "font": 
            {
                "face": "Hack Nerd Font",
                "size": 10
            },
            "historySize": 12000,
            "intenseTextStyle": "bright",
            "opacity": 95,
            "padding": "8",
            "scrollbarState": "visible",
            "useAcrylic": false
        },
        "list": 
        [
            {
                "commandline": "C:\\Program Files\\PowerShell\\7\\pwsh.exe --NoLogo",
                "elevate": false,
                "guid": "{574e775e-4f2a-5b96-ac1e-a2962a402336}",
                "hidden": false,
                "icon": "%userprofile%\\WindowsTerminalIcons\\ps.png",
                "name": "PowerShell",
                "source": "Windows.Terminal.PowershellCore"
            },
            {
                "guid": "{07b52e3e-de2c-5db4-bd2d-ba144ed6c273}",
                "hidden": false,
                "icon": "%userprofile%\\WindowsTerminalIcons\\ubuntu.png",
                "name": "Ubuntu Linux",
                "source": "Windows.Terminal.Wsl",
                "startingDirectory": "\\\\wsl$\\Ubuntu-20.04\\home\\xcad"
            },
            {
                "guid": "{46ca431a-3a87-5fb3-83cd-11ececc031d2}",
                "hidden": false,
                "icon": "%userprofile%\\WindowsTerminalIcons\\kali.png",
                "name": "Kali Linux",
                "source": "Windows.Terminal.Wsl",
                "startingDirectory": "\\\\wsl.localhost\\kali-linux\\home\\xcad"
            },
            {
                "guid": "{0caa0dad-35be-5f56-a8ff-afceeeaa6101}",
                "icon": "%userprofile%\\WindowsTerminalIcons\\cmd.png",
                "name": "Commandline"
            },
            {
                "guid": "{b453ae62-4e3d-5e58-b989-0a998ec441b8}",
                "hidden": true,
                "icon": "%userprofile%\\WindowsTerminalIcons\\azure.png",
                "name": "Azure Cloud Shell",
                "source": "Windows.Terminal.Azure"
            }
        ]
    },
    "schemes": 
    [
        {
            "background": "#1A1A1A",
            "black": "#121212",
            "blue": "#2B4FFF",
            "brightBlack": "#666666",
            "brightBlue": "#5C78FF",
            "brightCyan": "#5AC8FF",
            "brightGreen": "#905AFF",
            "brightPurple": "#5EA2FF",
            "brightRed": "#BA5AFF",
            "brightWhite": "#FFFFFF",
            "brightYellow": "#685AFF",
            "cursorColor": "#FFFFFF",
            "cyan": "#28B9FF",
            "foreground": "#F1F1F1",
            "green": "#7129FF",
            "name": "xcad",
            "purple": "#2883FF",
            "red": "#A52AFF",
            "selectionBackground": "#FFFFFF",
            "white": "#F1F1F1",
            "yellow": "#3D2AFF"
       lebar": true,
    "tabSwitcherMode": "inOrder",
    "useAcrylicInTabRow": true
}

Результат:

Starship

Starship

Установим крутую адаптацию. Как сами про себя пишут "Звёздные кораблики", их продукт, это минимальная, молниеносная и бесконечно настраиваемая подсказка для любой оболочки!

Установка весьма проста:

• Перейти на сайт компании.
• Установить через уже улучшенный терминал приложение (списки возможных установок написаны на сайте). Я использовал команду winget install starship.

• Следующая задача — установить нужные настройки в файлы профилей ваших сред (в которых вы пишите). Для начала, я взял самую сложную часть — работу с командной строкой. Для этого, вам нужно установить Clink.
• Перейдя на сайт книлка, вы попадёте на сложную страницу. На неё нужно перейти сразу на вкладку репозитория на гитхабе.

• Перейдя на данную страницу, нужно скачать файлы. Найти из можно на странице релиза.

• Далее, я выбрал просто доступный ассет.

• Далее, установите программу. По умолчанию, папка установки C:/Program Files (x86)/clink. Перейдите в данную папку.
• В это время, в саблайме создайте файл starship.lua и заполните его строкой
  load(io.popen('starship init cmd'):read("*a"))()

Результат:

• Вариант 0. Tor браузер.
• Вариант 1. АнтиЗапрет.
• Вариант 2. VPN.
• Вариант 2.1. Готовые сервер под L2TP.
• Вариант 2.2. Всё сам.
• Шаг 1. Арендуем VDS сервер.
• Шаг 2. Подключаемся по SSH
• Шаг 3. Устанавливаем OpenVPN
• Шаг 4. Качаем конфиг по FTP
• Шаг 5. Празднуем
• Итоги

Вариант 0. Tor браузер.

Тут всё просто. Нужно скачать Tor браузер по ссылке. Сеть тор просто так не заблокировать. В ней всегда будет анонимность и доступ к ресурсам. Но есть существенный минус — работать можно только через тулзу. Уберплюс — всё бесплатно.

Вариант 1. АнтиЗапрет.

Готовое решение из коробки и бесплатных VPN. Ещё раз скажу, чтобы точно было понятно. Оно не безопасно. Вся инструкция описана на их официальном сайте.

Вариант 2. VPN.

В посту ранее, я писал, что сам по себе VPN — бесполезен. Вариант нужно разбит на несколько задач:

• Найти внешний сервер VDS или VPS.
• Настроить форвардинг трафика через данный сервер (создали прокси).
• Фигачим на данное соединение шифрование.

Приступим.

Сразу оговорюсь, данный способ, я бы разбил на два разных. Первый попроще, второй посложнее. Обо весьма безопасны. Вопрос в целях. Если цель — скрыть своё пребывание от кучи сторонних глаз (вы творите что-то не оч хорошее), то лучше одумайтесь или используйте вариант

2.2.  Если же задача вылезти в инсту и не делать себе мозг проблемами — вариант 2.1 точно для вас.

Вариант 2.1. Готовые сервер под L2TP.

Лично я использую сервера компании Inferno Solutions. Решение такое:

• 5 видов VPN соединений: PPTP, L2TP/IPsec, WireGuard и, конечно же, OpenVPN!
• 10+ учетных записей для OpenVPN (5 TCP + 5 UDP), шифрование AES-256 2048 bit
• 2+ учетных записи для PPTP и L2TP/IPsec
• 2+ учетных записи для Socks 5 прокси (идеально для Telegram)
• Поддержка Windows, Linux, Mac OS, iOS, Android, роутеров и других систем!
• Скорость подключения 1 Gbit/s
• 22 стран на выбор (я сижу в Эстонии)

Сами Инферно делают оговорку: Только для индивидуального и легального использования!

Что это значит и как всё происходит? Вам настраивают типовой сервер на VPS. VPS — это ситуация, когда вам выдают виртуальный доступ к выделенной удалённой среде. В случае с Инферно, средой выступает CentOS 7 с характеристиками в 512 MB оперативы, 1 ядро проца, 5 Гб SSD-диска.

Вам предустанавливают систему и настраивают её. Если вы сделаете что-то нехорошее и власти запросят официальным письмом доступ к вашим данным — доступ им будет предоставлен. Но есть нюанс. Компания находится в Лондоне и запрос нужно будет делать в их юрисдикцию, а значит и нарушение, которое вы будете совершать (я надеюсь не будете), должно быть международное.

Лично меня решение от Inferno более чем устроило, так как есть подробные инструкции для моей семьи и друзей как что ткнуть чтобы работало. Второй крутой момент лично для меня — разные профили в настройках (от OpenVPN, до L2TP).

Вариант 2.2. Всё сам.

Вариант для АмаМамаКриминал. Делаем сами всё. Тут несколько шагов.

1. Аренда виртуального сервера.
2. Подключение к серверу по SSH.
3. Установка и настройка OpenVPN.
4. Скачивание конфига через FTP-клиент.
5. Подключение к VPN.

Шаг 1. Арендуем VDS сервер.

Лично я рекомендую арендовать ваш собственный сервер. Таким образом вы избавитесь от внешних проблем с безопасностью. От физических атак на весь сервер (там ваш и не ваш виртуальные сервера) — упадут все.

Компаний-поставщиков услуг VDS просто дикое количество. Выбирайте по странам близлежащие страны вне запретов, чтобы уменьшить пинг (Латвия, Эстония, Литва, Нидерланды, Филиппины).

Установите на ваш сервер Ubuntu 20.04. Чаще всего, она предустановлена. После оплаты и активации вам придут доступы к серверу, которые понадобятся для дальнейшей работы: логин, пароль и IP-адрес.

Шаг 2. Подключаемся по SSH

SSH — это протокол, позволяющий производить удаленное управление операционной системой. С помощью SSH-клиента (специальной программы) можно подключаться к VDS/VPS и производить необходимые настройки.

Чтобы не мучать ни вас, ни себя критериями выбора программ, скажу просто — Putty классная тулза. Она бесплатная и скачать её можно с официального сайта.

Открываем Putty, в поле «Host Name» вводим IP-адрес сервера, в поле «Port» оставляем «22» (SSH). Нажимаем кнопку «Open». Откроется консоль, в которой мы будем работать с сервером.

Вводим логин (можно сразу под «root») и нажимаем Enter. Вводим пароль от сервера и нажимаем Enter. Подключение прошло успешно. Обратите внимание, пароль не отображается в интерфейсе Putty — не пугайтесь, это нормально.

Шаг 3. Устанавливаем OpenVPN

Чтобы установить OpenVPN на сервер, вводим следующую команду и нажимаем Enter:

Запустится процесс установки. Далее выполним настройку и создадим конфигурационный файл:

1. Which protocol should OpenVPN use? Выбираем протокол: вводим цифру «1» (UDP) и нажимаем Enter. Можно и TCP, но подключаться будем дольше через трёхфакторное рукопожатие.
2. What port should OpenVPN listen to? Ничего не вводим и просто нажимаем Enter.
3. Select a DNS server for the clients. Выбираем DNS-сервер: например, вводим цифру «2» (Google) и нажимаем Enter.
4. Enter a name for the first client. Придумываем имя клиента на английском языке (оно может быть любым) и нажимаем Enter.

Далее нажимаем любую кнопку для начала установки и ждем завершения.

Шаг 4. Качаем конфиг по FTP

FTP — протокол передачи файлов по сети, а FTP-клиент — специальная программа для упрощения доступа к FTP-серверу. С помощью этой программы мы подключимся к VDS и скачаем созданный конфигурационный файл.

Опять таки, не разглагольствуя о великом, мой выбор — FileZilla (качать тут).

Открываем FileZilla. В поле «Хост» вводим:

Имя пользователя и пароль — берем из доступов (их вам должны были прислать при закупке VDS). Нажимаем кнопку «Быстрое соединение». После подключения в интерфейсе справа отобразятся папки на сервере, а слева — на вашем компьютере. Находим конфигурационный файл на сервере и сохраняем его у себя на компьютере (с помощью мыши перетаскиваем в левую часть экрана в интерфейсе FileZilla).

Чтобы открыть конфигурационный файл, нужно скачать программу OpenVPN с официального сайта.

Шаг 5. Празднуем

После установки OpenVPN нажимаем на конфигурационный файл два раза и нажимаем «Да». Обратите внимание, файл сохранился в папке на нашем компьютере, которая была выбрана в программе FileZilla при скачивании.

Итоги

Надеюсь, установка прошла успешно! Пишите что думаете и как вы обходите блокировки. Всех люблю!

Разрабы. Сетевики. Диайвайщики. Прочие айтишники. Когда-то давно четыре народа жили в мире. Но всё изменилось, когда Народ прочих айтишников развязал войну. Только Хабрахабр, властелин всех четырёх платформ, мог остановить захватчиков. Но, когда мир нуждался в Хабрахабре больше всего, он исчез. Прошло сто лет, и я нашёл новый Хабр, в стоке прочих комьюнити именуемых «Флудилки». И хотя его искусство покорения статей было велико, ему предстояло ещё многому научиться. Но я верил, что Хабр спасёт мир!

Книга 1. Статьи.

Чтобы точно не потерять кто понаписал это послание, сразу представлюсь:

Валерий Линьков

Писал сам, без угроз и кредитов

Мой путь в Хабр начался с далёкого 2016 года. Я был супер-активным читателем, так как был школолошником, который фанател об IT и боготворил всех людей внутри. Конечно! Они же пьют сидр, вумничают и получают много деняк! Сердце школьника покорено на ровне со стримлерами.

Как же долго я пытался попасть на Хабр. Писал новости, статьи, пытался извергнуть из себя мысль как мог и каждый раз НЛО меня динамило. Я понимал, что недотягиваю до звания пре-джуна и нифига не понимаю в IT. Боже, как я переживал по этому поводу. Как самый дёрганный чувак по поводу своих знаний, читал всё что было написано на русском, ломаном английском и мечтал быть среди тех крутых ребят из аськи. Я ждал каждый раз общения со старшими товарищами из индустрии и рвал все жилы, чтобы добиться признания от Хабр.

И вот, международный женский день 2018 года. Меня приняло НЛО! Моему счастью не было придела. Теперь, я уже не школьник, а работник офиса, цискарь, студент технического ВУЗа и препод инфы в школе. Конечно, я ещё не айти, но уже айтёныш.

Меня читали! Знаете какая оценка у статьи? Не догадываетесь? +4. Ну я же не айти, я айтёныш (ну недоучка в айти). А знаете сколько комментов? Немножко... 54... Что же мне писали:

Есть к чему стремиться! Мотивация поднята! Работаем! Пишем следующую статью, где учёл недостатки.

+1... Комменты (а их всего 15):

Ну да, ну да. Пошёл я нафиг. Буду работать ещё! Потом 6 статей и все до +9. Мало! Надо лучше! Карма болтается на 10. Я айтёныш, а хочу быть айти!

Дебют! Моя статья написанная с помощью Алексея Лукацкого (кто не знает, это бизнес-консультант циски в те годы, а сейчас на похожей должности в Positive Technologies). Вот он АЙТИ! Скоро будет круто:

И тут уже +16! Ура! Я счастлив! Теперь не так мало. Комментов 24 и из них ничего особо интересного, так пара замечаний, что теперь «маркетинговы булшит».

В любом случае, это успех! Я рад и хочу выпустить новую статью. Ручки трясутся, ведь не хочется уровень опускать. А я ж айтёныш. Та статья была популярна только благодаря Лукацкому. Вот он айти, а я... ну вы поняли...

Год паузы (чуть меньше) и снова 8 марта я пишу статью о сериале, который покорил моё сморщенное айтёнышное сердечко: "Мистер Робот". Ииииииии. Я в шоке:

Оценки +29, комментов 162! Офигеть! И нет негатива. Все благодарят за разбор крутого сериала. Вау!

Тут меня начинают покорять смутные сомнения "А может я уже айти?! Или людям просто понравился сериал?". Надо проверить! Следующая статья через месяц:

-3. Я чмоня. Похороните меня за плинтусом. Далее, я думаю "Может я журналист про сериалы?". Далее выпускаю несколько статей и карма уже +20 где-то. Ура! А может что-то интересное сделать? Попробую. Пишу про историю с попыткой Хуавей сделать что-то на примере Кремневой долины в IT. Беру интервью с Егором Бугаенко. Нуууу и просто 0. Хмм... Ну хоть не минус.

Далее, рассказывать про мои статьи не очень интересно. Мой рекорд по статья +43. И это статья про игры.

Что я понял из своего опыта:

• Хабру интересно читать про личный опыт работы с конкретной штукой (желательно нишевой);
• Хабру интересно посмотреть что-то прикольное для себя;
• На Хабре любят холеварить.

Книга 2. Технотекст

У Хабра есть такой прикольный конкурс как «Технотекст». Писал статьи в Технотекст я с 2021 года. Что‑то нравилось, что‑то нет. Но я понимал почему я не побеждаю. И вот долгожданная обнова платформы и у нас есть 3 уровня сложности:

Итак, я на середнячка точно уж тяну. Я ж теперь работаю сеньором в сетях и лидом в проектах. Я справлюсь! Беру супер-неудобную тему и пишу про то как сделать Зельду на питоне. Момент истины и оценки +42 (мы не обогнали игры), но хоть людям интересно. Да же? Или нет?

А посмотрите, сколько прочтений на статье про сети или IP-адреса и сколько тут. Время? Да ну ладно! Оно же не так сильно влияет. Можно всё посчитать. Мы же умеем! Даже если до конца года меня прочитает х2 человек и спрос падать не будет (что уже невозможно), то за 5 лет я наберу только 100к прочтений. Как побить 400к с +1?

Комитет Хабра (тут мне прям хочется назвать их этим словом). Несколько раз переносит выкладывание списка победителей и ночью приходит сообщение. Конечно, меня там нет. Я не расстроился, но хотел узнать, кто победил в номинации «Геймдев на уровне мидл»:

Сам автор пишет, что его уровень статьи "простой", а не "средний". А знаете какие у него оценки? +258. Чего?!...

Сейчас важное уточнение. Мне самому понравилась статья. Автор классно рассказал про то, как и что реально работает в геймдеве. Я ни коем образом не хочу обидеть автора. Он заслужил своего признания. Лично меня интересует как идёт подсчёт голосов. Кто эксперты? Как и что они оценивали? Ведь, в пунктах указано, что важна техничность статьи. Ну ладно, может я чего не понимаю? Иду спрашивать:

Ответ был странным:

Следующий день:

Выложенная статья про "Золотую клаву":

Комментов от организаторов не последовало. Почему‑то. Но я стал победителем Технотекста 2023. Рад ли я? Ну честно, вообще ХЗ. С одной стороны, теперь я точно уж айти, а с другой — а почему так? Что я сделал лучше или хуже? Или я просто «наныл на победу»? Я так не хочу.

Мне прислали мерч. Футболку, свитшот, значок и грамоту. Мне приятно. Я хожу в мерче, но как вы думаете сколько людей спросили про него и обратили не него внимание? Пара человек отметили, что мерч сделан красиво (понравилось как нарисована картинка, но люди от айти сильно далеки).

Прошло уже достаточно времени с события, чтобы я мог с холодной головой задать простой вопрос:

Книга 3. Карма

Ну ладно, все эти конкурсы, победы, проигрыши, баллы и лайки с прочтениями — всё это приходит и уходит, но карма остаётся. У меня максимум был +45. Для Хабра это не много и не мало.

И вот, наступает момент, когда я подготовил для сообщества компании, где работаю (это самый крупная Ed-Tech платформа) целую историю как я хотел переехать на Go, но забил и стал дальше писать на шарпе и питоне. Я очень переживал, что меня закидают тухлыми помидорами фразами "Ты ничё не понимаешь! Вот то ли дело...".

И каково было моё удивление, когда люди со мной просто обсудили простой вопрос "что на чём писать удобнее и лучше". И там были и мидлы, и сеньоры, и лиды (и я в числе тех же). И все уважительно друг с другом говорили и рассуждали. Преза была на 20 минут, а мы сидели час с лишним.

Тут я начинаю задумываться, а почему же так нельзя тут. И вот, наш деврел выкладывает текстовую версию моего рассказа. Ииииииииии:

Конечно, после карма немного упала, но я задумался и что? Ведь есть это:

Как-то я встречал чувака с -300 кармой. Я не знаю что он сделал, но походу убил кого-то текстом. А какой ограничение? Никакого! Он просто не может публиковать новые статьи. Ну а если надо — да без проблем смени почту и снова получи инвайд от НЛО или попроси у кого-то с высокой кармой. И всё...

Финал

Жаль, что не получилась история, где Хабр победил лорда Тролля и сообщество становится только токсичнее. Я искренне не понимаю зачем мне оно надо. Зачем мне писать статьи сюда? Я хотел вести личный блог, чтобы следить за своим прогрессом. Он у меня есть: Кудрявый микрофон в ТГ-шке (кому надо, тот найдёт). А тут прогресс кому нравится какой сериал...

Я хотел принять участие в новом технотексте, но опять таки... Зачем?! Оно ничего не даёт. Ни признания, ни экспертности, ни интересного времени-препровождения. Как написал какой-то комментатор под статьёй с победителями:

Меня узнавали как автора Хакера, как международного спикера, а не как чувачка-дурачка с докладом, о том что я не дурачок. Мне искренне стало от это грустно. Не яростно, не холиварно. Теперь, я буду писать книги или статьи, но за вознаграждения, как это в том же Хакере, а что-то для себя, я буду писать у себя в ТГ-шке (там, где мне это комфортно). Это я делаю выбирая себя.

Если вы задаётесь вопросом "А нафига я это читаю?", отвечу просто: "Подумайте надо ли вам писать на Хабре и трястись над кармой от таких приколов, как на картинке ниже, ещё и за бесплатно...".

Увидимся в мире! Всем его и желаю!

Введение

Хабры и Хаброчки, я хотел бы перед самой статьёй обсудить вопрос целесообразности писать свой движок, вместо готовых решений. Есть куча статей, которые опишут разные движки от более популярных до менее. Я бы хотел затронуть немного другой вопрос: "Как человеку, который изучал программирование много лет заняться геймдевом?". Обычно, есть два пути в геймдев:

1. Умышленный путь. Это когда человек, который играет в игры рано или поздно решит их создать. Тогда, он выбирает где ему учиться этому и выучивает игровые движки и C-образные языки к ним (чаще всего, C#).
2. Путь прогеров. Программист увлекается математикой и пишет код. Так или иначе, везде где есть код — есть компьютер. Цифровые развлечения (в том числе и игры) не проходят мимо тех людей, который постоянно пишут код. Так, часть прогеров решает написать свою игру и начать свой путь в геймдев. Об этом пути мы и поговорим.

Конечно можно сказать, что если ты хочешь работать — иди учись и получай нужные навыки. Осваивай Unity или Unreal и работай в крутой геймдев-компании. В этом есть доля правды. Однако, превращать любое своё хобби в работу — дело не благоразумное. Выгорание скажет об этом достаточно понятно. Тогда вам могут предложить сделать либо мод на игру (например, на движке Source) или поиграть в Грёзы, которая тоже очень популярна. Такой вариант вполне подойдёт, но появляется новая проблема: "Выбор варианта работы".

Выбор варианта работы

Всего есть три варианта работы над игрой:

1. Создать игру на известном движке-конструкторе
2. Сделать мод на существующий движок
3. Создать свой движок и написать игру

Каждый из этих вариантов хорош по-своему, но и имеет ряд недоработок. Например, выбрав путь создания игры на популярном движке вы столкнётесь с проблемами самого движка, а главное — с проблемами монетизации проекта. Если выбрать модопуть — вы сразу столкнётесь с тем, что не каждый движок открыт для написания игр, а также, не каждый движок позволяет продавать мод хоть за какую-то цену. Путь написания своего движка вызывает в геймдеве дикий припадок, мол "Да зачем опять идти очень сложно, когда сроки горят, а сам ты ещё не доработал концепцию?". Данный путь весьма не популярен для общества из-за сложности реализации и проблем с набором хоть какой-то команды, ведь если вы пишете движок, кому-то с ним работать.

Так зачем выбирать "сложный" путь? Во-первых, не для всех он сложнее. Лично мне сложнее перейти на C# с использованием Unity, чем написать новый проект на Python. Во-вторых, люди не всегда понимают сам движок. Сейчас я преподаю в институте "Бизнеса и Дизайна". Это один из первых профильных учреждений, занимающихся геймдевом. И вот у студентов я спросил зачем им движок. Каково было моё удивление, что далеко не все понимаю, вообще зачем он нужен. Спойлер, не из-за пресетов.

Зачем вам движок?!

По сути, движок решает всего лишь три, но очень важных вопроса:

1. Физика. Если вы окончили физмат, вы понимаете насколько сложно определить и прописать траекторию падения стеклянного шара весом в 2 килограмма на доску из дуба, которая лежит под углом 32 градуса. Также, нужно не забыть прописать с какой высоты должен упасть шар, чтобы разбиться. Движок прописывает эту физику за вас, а вы лишь обращаетесь к тем или иным объектам.
2. Тайлсеты. Тайл — это маленькие картинки для прорисовки графики (чаще всего, карт). Процесс создания тайлов весьма энергозатратный, а наложение этих тайлов достаточно простое дело. Просто выбрать где лежит камень, а где земля или вода. В движках типа Unreal или Unity вы можете просто выбрать слой карты и нарисовать клеточками из тайтлов карту.
3. Анимация. Самый спорный пункт. В движках все элементы на карте — это объекты. Каждый объект имеет форму по координатам x, y, z и их можно менять прямо в самом движке путём перемещения, сжатия или растягивания объекта. Но важное уточнение, прорисовывать анимацию по x, y, z — не самая лучшая идея. Куда надёжнее, красивее и вообще правильнее прописывать каждый шаг объекта путём перемещения по пресету персонажа по графике.

Иными словами, сам игровой движок — это автоматизирующая система, которая позволяет упростить разработку. Однако, при использовании движка теряется часть гибкости в настройках. Моя задача — описать как можно более подробный процесс написания игры по самому сложному пути, хотя Python и упрощает часть вещей. Что ж, хватит слов и давайте к делу!

Подготовка

Для начала, давайте создадим папку проекта. Я назвал проект PyZelda и в папке проекта есть ещё 4 директории: audio, code, graphic и map.

Далее, в папке code создадим три файла:

• main.py — основной файл игры
• settings.py — настройки игры (тут мы укажем настройки полей и основных данных по окну и прорисовке)
• debug.py — файл дебагинга

Перед работой, не забудьте скачать библиотеку PyGame (pip install pygame)

Файл main:

import pygame, sys #импортируем библиотеки PyGame и Sys
from settings import * #импорт из файла settings

class Game: #основной класс игры
	def __init__(self): #создаём конструктор класса
		pygame.init() #конструктор использует конструкции из библиотеки PyGame
		self.screen = pygame.display.set_mode((WIDTH,HEIGTH)) #забирает из нашего проекта экран в виде размеров в ширину и высоту
		pygame.display.set_caption("PyZelda") #Устанавливаем название нашего окна
		self.clock = pygame.time.Clock() #а также, забирает из проекта время

	def run(self): #функция запуска игры
		while True: #до выхода из игры она активна
			for event in pygame.event.get(): #просмотр событий в игре
				if event.type == pygame.QUIT: #сейчас мы можем только выйти и при выходе:
					pygame.quit() #вызываем метод закрытия игры
					sys.exit() #и закрываем окно системы
			self.screen.fill('green') #помимо событий, указываем цвет экрана
			pygame.display.update() #обновляем экран
			self.clock.tick(FPS) #запрашиваем FPS

if __name__ == '__main__': #запуск игры только из main-файла
	game = Game() #Если файл main, то сама игра вызывает класс...
	game.run() #...и запускает функцию run из класса

В файле main мы запускаем саму игру. Создаём конструктор на базе PyGame и работаем с входными файлами и данными.

Файл setting.py:

WIDTH = 1280 #Ширина экрана
HEIGTH = 720 #Высота экрана
FPS = 60 #Число FPS
TILESIZE = 64 #Размер тайла (квадрата текстуры)

WORLD_MAP = [ #Карта мира игры. Она состоит из 20х20 квадратов
['x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x'],
['x', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', 'x'],
['x', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', 'x'],
['x', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', 'x'],
['x', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', 'x'],
['x', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', 'x'],
['x', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', 'x'],
['x', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', 'x'],
['x', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', 'x'],
['x', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', 'x'],
['x', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', 'x'],
['x', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', 'x'],
['x', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', 'x'],
['x', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', 'x'],
['x', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', 'x'],
['x', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', 'x'],
['x', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', 'x'],
['x', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', 'x'],
['x', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', ',', 'x'],
['x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x'],
]

Далее, файл debug.py:

import pygame #Снова обращаемся к PyGame
pygame.init() #Используем базовый конструктор
font = pygame.font.Font(None, 30) #Указываем шрифт

def debug(info, y = 10, x = 10):  #Сама функция дебага
	display_surface = pygame.display.get_surface() #Получаем ссылку на текущую установленную поверхность отображения в игре
	debug_surf = font.render(str(info), True, "Red") #Рендерим текст (я сделал его красным)
	debug_rect = debug_surf.get_rect(topleft = (x, y)) #Указывамем место отображения инфы на экране (левый верхний угол)
	pygame.draw.rect(display_surface, "White", debug_rect) #Делаем микро-консоль в виде прямоугольника (и да он белый, будет белая консоль с красным текстом)
	display_surface.blit(debug_surf, debug_rect) #Собираем нашу микро-консоль с параметрами текста

В данном файле мы создадим дебаг игры. Это поле, которое мы выводим вверху слева экрана и в нём показываем нужный нам текст. Для запуска дебага, нужно импортировать debug в main-файл и вывести что-то после отрисовки окна. Примерно так (файл main.py):

import pygame, sys #импортируем библиотеки PyGame и Sys
from settings import * #импорт из файла settings
from debug import debug #импортируем дебаг <------------------

class Game: #основной класс игры
	def __init__(self): #создаём конструктор класса
		pygame.init() #конструктор использует конструкции из библиотеки PyGame
		self.screen = pygame.display.set_mode((WIDTH,HEIGTH)) #забирает из нашего проекта экран в виде размеров в ширину и высоту
		pygame.display.set_caption("PyZelda") #Устанавливаем название нашего окна
		self.clock = pygame.time.Clock() #а также, забирает из проекта время

	def run(self): #функция запуска игры
		while True: #до выхода из игры она активна
			for event in pygame.event.get(): #просмотр событий в игре
				if event.type == pygame.QUIT: #сейчас мы можем только выйти и при выходе:
					pygame.quit() #вызываем метод закрытия игры
					sys.exit() #и закрываем окно системы
			self.screen.fill('green') #помимо событий, указываем цвет экрана
			debug('Чё как? Я дебаг!') #Дебажим <------------------
			pygame.display.update() #обновляем экран
			self.clock.tick(FPS) #запрашиваем FPS

if __name__ == '__main__': #запуск игры только из main-файла
	game = Game() #Если файл main, то сама игра вызывает класс...
	game.run() #...и запускает функцию run из класса

Получим феерическую игру цветов:

Стартовый набор файлов для скачивания.

Пишем уровень

Итак, для начала давайте разберёмся в понятии "класс" в концепции ООП (объектно-ориентированного программирования). Сейчас мы создадим класс Level. В этом классе есть всё необходимое для работы с объектами внутри. По сути, класс Level и есть наша игра, так как именно этот класс собирает все спрайты (игрок, враги, карта мира и т.д.). Помимо самих спрайтов, нас интересует набор элементов связанных с подсчётом тех или иных пунктов. Как я говорил ранее, движок нужен для прописывания физики, а физика — это математический способ описать поведение объекта. Таким образом, мы взаимодействуем с числами и параметрами. Это тоже находится в классе Level. Например, если игрока ударит враг, то игрок потеряет 5% здоровья — это и есть наши параметры.

Но есть одна проблема. Объектов очень много. Чтобы не рыскать в коде в поисках конкретного камня №67, код будем разбивать группами объектов. Сейчас мы создадим две группы: visible_sprites и obstacle_sprites. Как вы уже поняли, группа visible_sprites отвечает за все объекты, которые пользователь видит (например, карту мира и персонажа), а obstacle_sprites — это объекты, которые нужны для технического использования. Все объекты можно сослать на конкретные группы или на набор групп. Так, объект "кот" может быть в группе объектов движущихся, но не взаимодействующих с игроком. Если же добавить кота в обе группы, он будет отображён и активен.

Приступим к коду. Создадим новый файл level.py. Пропишем в нём следующий код:

import pygame

class Level: #Создали класс
	def __init__(self): #Базовые параметры
		self.visible_sprites = pygame.sprite.Group() #Создали группу видимых элементов
		self.obstacle_sprites = pygame.sprite.Group() #Создали группу технических элементов

	def run(self): #Создали метод в классе
		pass

Мы просто создали класс и в нём 2 группы, а затем в классе создали метод вызова данного класса. Далее, нужно вернуться в main-файл и импортировать класс Level (from level import Level), объявить класс Level (self.level = Level()), а таже запустить его в самом run-методе в main (self.level.run()). Я решил пока убрать дебаг из проекта, так как сейчас дебажить нечего и финальный код в main-файле выглядит так:

import pygame, sys #импортируем библиотеки PyGame и Sys
from settings import * #импорт из файла settings
from level import Level #+++ импорт из файла level класс Level +++

class Game: #основной класс игры
	def __init__(self): #создаём конструктор класса
		pygame.init() #конструктор использует конструкции из библиотеки PyGame
		self.screen = pygame.display.set_mode((WIDTH,HEIGTH)) #забирает из нашего проекта экран в виде размеров в ширину и высоту
		pygame.display.set_caption("PyZelda") #Устанавливаем название нашего окна
		self.clock = pygame.time.Clock() #а также, забирает из проекта время
		self.level = Level() #+++ объёвили Level +++

	def run(self): #функция запуска игры
		while True: #до выхода из игры она активна
			for event in pygame.event.get(): #просмотр событий в игре
				if event.type == pygame.QUIT: #сейчас мы можем только выйти и при выходе:
					pygame.quit() #вызываем метод закрытия игры
					sys.exit() #и закрываем окно системы
			self.screen.fill('green') #помимо событий, указываем цвет экрана
			self.level.run() #+++ запустили функцию run в файле level в классе Level +++
			pygame.display.update() #обновляем экран
			self.clock.tick(FPS) #запрашиваем FPS

if __name__ == '__main__': #запуск игры только из main-файла
	game = Game() #Если файл main, то сама игра вызывает класс...
	game.run() #...и запускает функцию run из класса

Давайте далее, пропишем что-то в классе Level. Таким образом, мы создадим подложку из зелёного фона, а сверху наложим новые объекты. Для этого, мы воспользуемся простым методом, как в и в дебаге: display_surface = pygame.display.get_surface(). В коде с Level оно выглядит так:

import pygame

class Level: #создали класс
	def __init__(self): #базовые параметры
		self.display_surface = pygame.display.get_surface() #создали новый слой объектов
		self.visible_sprites = pygame.sprite.Group() #создали группу видимых элементов
		self.obstacle_sprites = pygame.sprite.Group() #создали группу технических элементов

	def run(self): #создали метод в классе
		pass

Сейчас ничего не поменяется, так как мы объявили что будем что-то рисовать, но ничего не нарисовали. Давайте приступим к процессу отрисовки. Для этого создадим новый файл tile.py.

import pygame
from settings import *

class Tile(pygame.sprite.Sprite):
	def __init__(self, pos, groups):
		super().__init__(groups) #наследуем все группы
		self.image = pygame.image.load('../graphic/box.png').convert_alpha() #указываем адрес картинки
		self.rect = self.image.get_rect(topleft = pos) #указываем позицию отрисовки (левый верхний угол)

Интересного в этом коде мало. Мы просто импортируем сам pygame (снова и снова), из файла settings.py мы берём всю информацию по разметке поля (потому, мы его и оставляем тут). Далее, мы создаём новый класс Tile. В нём создаём параметры себя, позицию и группу наследования. Далее, командой super() мы включаем наследование. Далее, указываем картинки самих предметов и rect данных картинок. Из интересного, convert_alpha(). Эта функция пайгейма создает новую копию поверхности с желаемым форматом пикселей. Суровая необходимость, чтобы пайгейм понял что мы делаем.

Ровно такой же код создадим в файле player.py:

import pygame
from settings import *

class Player(pygame.sprite.Sprite):
	def __init__(self, pos, groups):
		super().__init__(groups)
		self.image = pygame.image.load('../graphic/link.png').convert_alpha()
		self.rect = self.image.get_rect(topleft = pos)

Отличие данного кода лишь в двух местах:

• Я создал класс Player вместо Tile
• Заменили картинку с коробок на героя Хайрула :)

Все пресеты картинок я взял из проекта NinjaAdventure. Там есть способ скачать бесплатные сеты графики. Обрезал картики в фотошопе и получил мини-изображения.

Теперь, давайте отобразим нашу мировую карту. Делать мы это будем в файле level.py, так как именно в нём мы храним всю нужную инфу про конкретный уровень. Сразу импортируем settings.py и обратимся к карте. Финал работы будет выглядеть так:

import pygame
from settings import *

class Level: #создали класс
	def __init__(self): #базовые параметры
		self.display_surface = pygame.display.get_surface() #создали новый слой объектов
		self.visible_sprites = pygame.sprite.Group() #создали группу видимых элементов
		self.obstacle_sprites = pygame.sprite.Group() #создали группу технических элементов
		self.create_map()

	def create_map(self):
		for row in WORLD_MAP:
			print(row)

	def run(self): #создали метод в классе
		pass

После запуска main-файла, сама игра никак не поменялась, но мы в терминале отпечатали нашу карту.

Про карту. Для упрощения работы, я создал клетку (напомню, что она размером 64 на 64 пикселя) и указываю символами что куда ставить. Поставил карту я так: 'x' — это коробки, ',' — пустое место, а 'p' — это наш герой.

Это, конечно, круто, но вот я хотел бы нарисовать карту в игре, а не в терминале. Для этого, модернизируем код. Работаем только с файлом level.py:

import pygame
from settings import *
from tile import Tile
from player import Player

class Level: #создали класс
	def __init__(self): #базовые параметры
		self.display_surface = pygame.display.get_surface() #создали новый слой объектов
		self.visible_sprites = pygame.sprite.Group() #создали группу видимых элементов
		self.obstacle_sprites = pygame.sprite.Group() #создали группу технических элементов
		self.create_map()

	def create_map(self):
		for row_index, row in enumerate(WORLD_MAP):
			for col_index, col in enumerate(row):
				x = col_index * TILESIZE
				y = row_index * TILESIZE
				if col == 'x':
					Tile((x, y), [self.visible_sprites])
				if col == 'p':
					Player((x, y), [self.visible_sprites])

	def run(self): #создали метод в классе
		self.visible_sprites.draw(self.display_surface)

Всё что я делаю — это прохожу массив данных и умножаю элемент на 64, так как размер моего тайла равен 64 пикселям. Далее, если элемент равен 'x' заменяю его на коробку, а если 'p', то на героя. Далее, я прописал в методе запуска метод отрисовки поля. Также, на карте я заменил одну ',' на 'p'. И результат:

В main-файле заменив цвет фона на чёрный, а размер тайла на 32 пикселя, я получил это:

Файлы данного этапа для скачивания. Сразу оговорюсь, что отображение не совсем корректное из-за самих картинок. Я не подбивал их к размеру 64 на 64 пикселя. Далее я исправил это и вернул размер тайла в 64 на 64 пикселя.

Создаём игрока

Сам игрок должен мочь передвигаться и сталкиваться с существующими объектами. Для начала, запишем его движения. Переходим в player.py и прописываем функцию перемещения. Код в player.py:

import pygame
from settings import *

class Player(pygame.sprite.Sprite):
	def __init__(self, pos, groups):
		super().__init__(groups)
		self.image = pygame.image.load('../graphic/link.png').convert_alpha()
		self.rect = self.image.get_rect(topleft = pos)

		self.direction = pygame.math.Vector2() #обращаемся к направлению через вектор

	def input(self): #варьируем кнопки
		keys = pygame.key.get_pressed()

		if keys[pygame.K_UP]:
			self.direction.y = -1
		elif keys[pygame.K_DOWN]:
			self.direction.y = 1
		else:
			self.direction.y = 0

		if keys[pygame.K_LEFT]:
			self.direction.x = -1
		elif keys[pygame.K_RIGHT]:
			self.direction.x = 1
		else:
			self.direction.x = 0

	def update(self):
		self.input()

Тут с кодом достаточно просто. В функции self.direction = pygame.math.Vector2() мы задаём вектор точке. Точка — это наш герой, а его вектор болтается в диапазоне от -1 до 1. Функция keys = pygame.key.get_pressed() позволяет продолжать нажатие и тогда, герой должен разгоняться. Если нажатия нет — вектор равен 0 и герой тормозит. Это очень условное, но приписывание инерции.

Ещё в файле level.py в функции run я записал обновление всех спрайтов. Это строчка кода вида:

self.visible_sprites.update()

Ещё, я переписал в том же файле вызов героя. Мне это нужно для глобализации позиции героя. Из строки

Player((x, y), [self.visible_sprites])

Я сделал

self.player = Player((x, y), [self.visible_sprites])

Продолжим прорисовку движений в файле player.py. Создадим ещё один параметр — скорость. Для этого в глобальные параметры (__init__) добавим строчку self.speed = 5

Также напишем функцию move:

def move(self, speed):
		self.rect.center += self.direction * speed

И в update-функции пропишем движения персонажа: self.move(self.speed).

Результат:

Если приглядеться, то по диагонали, Линк бежит чуть быстрее. Дело в том, что он бежит по диагонали со скоростью корень из двух, что примерно равно 1.4. Мы прописали скорость вверх, вниз, влево и вправо равной 1, а вот по диагонали из правил математики, можно понять, что длина гипотенузы равна сумме квадратов длин оснований квадрата под корнем, то есть корень из (1^2 + 1^2). Исправим данный баг нормализацией от PyGame (да-да, как в Unity). Исправленная функция движения:

def move(self, speed):
	if self.direction.magnitude() != 0:
	    self.direction = self.direction.normalize()
	self.rect.center += self.direction * speed

Теперь вторая проблема. Линк — танк. Он сбивает всё на своём пути. Нам нужны объекты и прописать столкновения с ними. Не забывайте, что все объекты у нас — квадраты тайлами.

Сейчас у нас есть проблема — файл player.py не знает о наличии тайлов, которые отображаются через файл уровня. Поэтому, дадим нашему файлу новый аргумент. Добавим его в init и назовём obstacle_sprites. Также, не забудьте в файле самого уровня сослаться на obstacle_sprites в отрисовке точки игрока. Для этого в файле level.py замените строку:

self.player = Player((x, y), [self.visible_sprites])

На строку:

self.player = Player((x, y), [self.visible_sprites], self.obstacle_sprites)

В самом файле игрока, создадим метод столкновений под название collision. Сама функция:

def collision(self, direction):
	if direction == 'horizontal':
		for sprite in self.obstacle_sprites:
			if sprite.rect.colliderect(self.rect):
				if self.direction.x > 0: #двигаем вправо
					self.rect.right = sprite.rect.left
				if self.direction.x < 0: #двигаем влево
					self.rect.left = sprite.rect.right

	if direction == 'vertical':
		for sprite in self.obstacle_sprites:
			if sprite.rect.colliderect(self.rect):
				if self.direction.y > 0: #двигаем вниз
					self.rect.bottom = sprite.rect.top
				if self.direction.y < 0: #двигаем вверх
					self.rect.top = sprite.rect.bottom

В ней всё разделено на две координаты. По горизонтальной оси — x, по вертикальной — y. Если столкновение произошло по горизонтали, то делаем смещения (вправо или влево). Тоже самое по вертикали, но там вниз и вверх. Последний шаг — разделить метод в движении на два варианта: вертикальный и горизонтальный. То есть, из строки:

self.rect.center += self.direction * speed

Делаем структуру:

self.rect.x += self.direction.x * speed
self.collision('horizontal')
self.rect.y += self.direction.y * speed
self.collision('vertical')

Получаем героя Хайрула без наклонностей в приведение:

Из предыдущей гифки видна следующая задача — создать камеру. Этим и займёмся. Ссылка на этот этап.

Создание камеры

Создать камеру я предлагаю с учётом вектора направления движения персонажа. Мы будем двигать камеру вместе с персонажем. Переходим к файлу уровня и создаём новый класс.

class YSortCameraGroup(pygame.sprite.Group):
	def __init__(self):
		super().__init__()

По сути, всё что я сделал сейчас — создал новый класс пустой и с наследованием всего и вся. Далее, применяем его вместо pygame.sprite.Group() в visible_sprites, дабы не тавтологироваться, а ссылаться на класс с более тонкими настройками. Теперь к тонкостям:

class YSortCameraGroup(pygame.sprite.Group):
	def __init__(self):
		super().__init__()
		self.display_surface = pygame.display.get_surface()

	def custom_draw(self):
		for sprite in self.sprites():
			self.display_surface.blit(sprite.image, sprite.rect) #прорисуем новую поверхность и отрисуем её

Тут я добавил тех же отображений новых поверхностей в главного демона с наследованием и создал метод ручной отрисовки (custom_draw). Там самый интересный пункт в display_surface.blit. Сам Surface создаёт новый слой объектов, а blit отрисовывет их. Далее мы передаём сами картинки и фигуры. Скоро и это перепишем, так как нам нужны векторы. Этим и займёмся. Сам вектор знаком вам по ходьбе Линка. Далее, снова улучшим класс:

class YSortCameraGroup(pygame.sprite.Group):
	def __init__(self):
		super().__init__()
		self.display_surface = pygame.display.get_surface()
		self.offset = pygame.math.Vector2()

	def custom_draw(self):
		for sprite in self.sprites():
			offset_pos = sprite.rect.topleft + self.offset #определяем позицию путём сравнения верхнего левого угла с вектором направления
			self.display_surface.blit(sprite.image, offset_pos) #прорисуем новую поверхность и отрисуем её

Тут из нового только одна конструкция в самом методе. Она направлена на определение верхнего левого угла, отрисовку и последующую сумму с вектором направления. Далее, в run-методе, не забудьте поменять отрисовку с базовой на нашу кастомную. Примерно так:

self.visible_sprites.custom_draw()

Если вы сделали всё верно, вставив в вектор 2 значения (x и y), вы увидите перемещение карты. Я поставил -150 и -150 и получил это:

Собственно, осталось перемещаться зацепившись за героя. Его мы оставим по центру экрана (да здравствует эпохе Dendy). Наш код по доработке:

class YSortCameraGroup(pygame.sprite.Group):
	def __init__(self):
		super().__init__()
		self.display_surface = pygame.display.get_surface()
		self.half_width = self.display_surface.get_size()[0] // 2 #середина отрисованного экрана по ширине
		self.half_heigth = self.display_surface.get_size()[1] // 2 #середина отрисованного экрана по высоте
		self.offset = pygame.math.Vector2()

	def custom_draw(self, player):
		self.offset.x = player.rect.centerx - self.half_width #координата x Линка
		self.offset.y = player.rect.centery - self.half_heigth #координата y Линка
		for sprite in self.sprites():
			offset_pos = sprite.rect.topleft - self.offset #определяем позицию путём сравнения верхнего левого угла с вектором направления
			self.display_surface.blit(sprite.image, offset_pos) #прорисуем новую поверхность и отрисуем её

В базовых демонов мы добавили размеры экрана и центр экрана (нацело делим пополам). В нашу кастомную рисовалку передадим координаты игрока и по x, y офсетам высчитаем их. Чтобы избавиться от "пьяной камеры", я вычитаю вектор направления, а не прибавляю его. Не забудьте run-методе передать self.player. Результат:

Теперь нужно разобраться с хитбоксами. Сейчас, у нас графика из Денди, где каждый объект стоит по конкретным клеткам (тайлам). Нужно это исправить. Для начала, перейдем к настройкам тайла и допишем один демон-элемент:

self.hitbox = self.rect.inflate(0, -10)

Таким образом, мы уменьшили хитбокс на 10 пикселей. Так как отрисовка идёт из центра — мы уменьшаем хитбокс сверху и снизу на 5 пикселей. В демонах игрока пропишем тот же код, но уменьшим хитбокс на 26 пикселей. Далее, наша задача двигаться и проверять коллизии через хитбоксы. Для этого объекты с rect.x заменим на hitbox.x. Тогда move-функция выглядит так:

def move(self, speed):
	if self.direction.magnitude() != 0:
		self.direction = self.direction.normalize()
	self.hitbox.x += self.direction.x * speed
	self.collision('horizontal')
	self.hitbox.y += self.direction.y * speed
	self.collision('vertical')
	self.rect.center = self.hitbox.center

Также, починим коллизии:

def collision(self, direction):
	if direction == 'horizontal':
		for sprite in self.obstacle_sprites:
			if sprite.hitbox.colliderect(self.hitbox):
				if self.direction.x > 0: #двигаем вправо
					self.hitbox.right = sprite.hitbox.left
				if self.direction.x < 0: #двигаем влево
					self.hitbox.left = sprite.hitbox.right

	if direction == 'vertical':
		for sprite in self.obstacle_sprites:
			if sprite.hitbox.colliderect(self.hitbox):
				if self.direction.y > 0: #двигаем вниз
					self.hitbox.bottom = sprite.hitbox.top
				if self.direction.y < 0: #двигаем вверх
					self.hitbox.top = sprite.hitbox.bottom

Результат:

Линку отрывает шапку. Это происходит из-за того, что изображения рандомно находятся на поверхности. Какие-то выше, какие-то ниже. Нужно это исправить. Исправим это через класс YSort (не просто же так мы мы назвали класс YSortCameraGroup). Поправим только одну строку:

for sprite in self.sprites():

На строку:

for sprite in sorted(self.sprites(), key = lambda sprite: sprite.rect.centery):

По сути, мы просто сделали сортировку по y-координате. Про лямбду можно отдельно почитать, но если сказать грубо — лямбда-функция — функция, которая работает в с анонимными функциями.

Итог:

Ссылка на этап проекта.

Графика

Тут мне пришлось освоить для себя новую прогу. Она была очень дружелюбной и со второго раза, я смог нарисовать поле игры. Программа называется Tiled. В ней можно с лёгкости настраивать карты. Сразу оговорюсь, что это мой первый опыт работы с картами. Это сыграло со мной злую шутку. Дважды.

Чуть ранее я писал про проблемы с ассетами. Дело в том, что я выбрал размер тайла 64 пикселя. Это стандартное разрешение для игр в ряд, но я не учёл один момент — все ассеты, которые были у Ninja Adventure были в разрешении 16 на 16 пикселей. Это нормально для пиксельной графики. В общем, была задача поправить это расхождение. Поправка была простой — я увеличил размер нужных мне тайлов в 4 раза в фотошопе. В итоге, получилось из этого:

Сделать это:

Для отрисовки самой карты, я взял 3 файла (TilesetFloor.png, TilesetFloorDetails.png и TilesetWater.png):

Что-то типа ворнинга. Тут будьте осторожны. Мне пришлось перерисовать карту и сделать из разных картинок с тайлами одну. Не повторяйте моих ошибок и сначала прочитайте что происходит ниже в разделе "Монстры".

Помимо прочего, я создал зелёный квадрат 64 на 64 и красный такой же с прозрачностью в 20%, чтобы поставить точку спауна Линка и невидимые стены для него. Приступим к отрисовки карты.

Открываем Tiled и я выставил следующие настройки. Ортогональная карта лежит в координатах x и y, что нам и подходит. Слой будет выводиться в формате CSV и отрисовываться справа снизу. Размеры карты будут 80 на 60 тайлов, а это значит 80 на 64 = 5120 и 60 на 64 = 3840 пикселей.

Создав карту, получим своё рабочее поле и приступим к рисованию:

Час работы и результат:

Сейчас работа очень грубая. Нужно добавить деталей. Займёмся этим. Вот что получилось спустя минут 20:

Далее, я добавил тайлы-блоки, чтобы за них Линк не выбрался (куда ж без невидимых стен). Главное — все поля должны быть замкнуты, чтобы Линк внезапно не залетал. У меня получилось как-то так:

Потом я выключил данный слой, чтобы он не отвлекал. Далее, проставим места спауна врагов (бебов) и ГГ (Линка):

Добавим пару объектов:

Конечно, карта может быть детальнее проработана, ну да это не моя задача. Моя задача — проверить как там игродев на змейке.

Всю графику я перенёс в папку graphic, а также выгрузил карту в .csv-формате в папку map.

Приступим к коду. Для начала, я скинул в папку Test нашего Линка и коробку и поправил пути в проекте в файлах player.py и title.py. После запуска ничего не поменялось. Далее, я решил положить подложкой на чёрный экран нашу карту. Я просто экспортировал картинку без спауна и дополнительных объектов и установил её выше чёрного экрана, но ниже Линка с коробками. Для этого в файле level.py я для начала объявил о наличии таких файлов двумя строками кода в демонах класса YSortCameraGroup:

self.floor_surf = pygame.image.load('../graphic/map+det.png').convert() #добавили задник карты
self.floor_rect = self.floor_surf.get_rect(topleft = (0, 0)) #отрисовка карты с левого верхнего угла

Далее в методе custom_draw вычисляем отрисовку с офсетами для камерами (всё ровно также, как и ранее):

floor_offset_pos = self.floor_rect.topleft - self.offset
self.display_surface.blit(self.floor_surf, floor_offset_pos)

Результат:

Происходит наслоение старой карты и новой. Исправим этою Удалим всё в методе create_map в level.py. Немного переписав метод, я привёл его к следующему виду:

def create_map(self):
	self.player = Player((1000, 1000), [self.visible_sprites], self.obstacle_sprites)

Всё что я оставил — это отрисовку места Линка на карте. Просто указал координату.

Теперь наша задача провзаимодействовать с файлом tile.py эму нужны настройки более детальные для прорисовки объектов и картинок конкретного размера. Приступим.

Для начала, помимо прочих элементов, демонам нужно передавать новые два аргумента sprite_type и surface = pygame.Surface((TILESIZE, TILESIZE)). Думаю, по названия понятно, что они будут передавать сам тип спрайта и его размер из файла settings.py. Ещё немного переработаем файл и получим упрощение конструкции с ссылкой на себя:

import pygame
from settings import *

class Tile(pygame.sprite.Sprite):
	def __init__(self, pos, groups, sprite_type, surface = pygame.Surface((TILESIZE, TILESIZE))):
		super().__init__(groups) #наследуем все группы
		self.sprite_type = sprite_type
		self.image = surface
		self.rect = self.image.get_rect(topleft = pos) #указываем позицию отрисовки (левый верхний угол)
		self.hitbox = self.rect.inflate(0, -10) #делаем по 5 пискселей сверху и снизу от самого объекта, до хитбокса

Вернёмся в creat_map. Создадим новый словарь на основе csv-файлов:

layout = {
		'boundary': import_csv_layout('../map/map_Block.csv')
}

Метод import_csv_layout нам не знаком. Напишем его в новой файле support.py.

from csv import reader

def import_csv_layout(path):
	with open(path) as level_map:
		layout = reader(level_map, delimiter = ',')
		for row in layout:
			print(row)

import_csv_layout('../map/map_Block.csv')

В данном коде идёт чтение csv-файла. А при чтении "1" — означает, что объект там есть, а "-1" — его там нет.

Результат вывода support.py:

Чуть подправим, чтобы у нас на выходе была матрица (массив из выведенных строк) и функция готова:

from csv import reader

def import_csv_layout(path):
	terrain_map = []
	with open(path) as level_map:
		layout = reader(level_map, delimiter = ',')
		for row in layout:
			terrain_map.append(list(row))
		return terrain_map

Теперь, вернёмся к creat_map и допишем функцию очень похожую на то, что было ранее (не забудьте импортировать support):

def create_map(self):
	layout = {
			'boundary': import_csv_layout('../map/map_Block.csv')
	}
	for style, layout in layout.items():
		for row_index, row in enumerate(layout):
			for col_index, col in enumerate(row):
				if col != '-1':
					x = col_index * TILESIZE
					y = row_index * TILESIZE
					if style == 'boundary':
						Tile((x, y), [self.visible_sprites, self.obstacle_sprites], 'invisible')
	self.player = Player((1000, 1000), [self.visible_sprites], self.obstacle_sprites)

Итог:

Чёрные края — это невидимые стены. Осталось их только сделать невидимыми. Удалим self.visible_sprites.

Создадим ещё один вариант стиля — objects. Тут нам потребуется сразу несколько картинок. Чтобы не перебирать их вручную в support.py создадим новый метод поиска картинок при помощи знакомым многим функции walk:

def import_folder(path):
	for _, __, img_files in walk(path):
		for image in img_files:
			full_path = path + '/' + image
			print(full_path)

Получим вывод:

Немного перепишем метод под pygame:

def import_folder(path):
	surface_list = []
	for _, __, img_files in walk(path):
		for image in img_files:
			full_path = path + '/' + image
			image_surf = pygame.image.load(full_path).convert_alpha()
			surface_list.append(image_surf)
	return surface_list

Сам метод отрисовки объектов:

if style == 'objects':
	surf = graphics['objects'][int(col)]
	Tile((x, y), [self.visible_sprites, self.obstacle_sprites], 'object', surf)

Тут мы просто перебором по всем файлам выставляем объекты. Есть только одна проблема. Если объекты были друг за другом — они рандомно ставятся. Нужно это исправить. Исправим это в tile.py:

if sprite_type == 'object':
	self.rect = self.image.get_rect(topleft = (pos[0], pos[1] - TILESIZE))
else:
	self.rect = self.image.get_rect(topleft = pos) #указываем позицию отрисовки (левый верхний угол)

В этом моменте мы отключили перекрытие объектом других объектов. Итого, Линк гуляет в лесу!

Результат работы по ссылке. Помимо прочего, я оставил проект в Tiled, чтобы вы сами могли "поиграться" с ним. Далее, мы поговорим об анимации.

Анимация Линка

Для начала, нужно добавить действие и кнопку. На атаку будет стоять кнопка "Пробел". Пропишем это в player.py:

if keys[pygame.K_SPACE] and not self.attacking:
	self.attacking = True

Тут непонятно что такое self.attacking. В демоны файла я добавил три параметра: статус атаки (self.attacking = False), кулдаун после атаки (self.attack_cooldown = 400) и время атаки (self.attack_time = None).

Добавим время между атаками. Для этого, после успешной атаки, создадим конструкцию: self.attack_time = pygame.time.get_ticks() сразу после объявление атаки флагом True. Далее, перейдём к настройке нового метода cooldowns. Сам метод:

def cooldowns(self):
	current_time = pygame.time.get_ticks()

	if self.attacking:
		if current_time - self.attack_time >= self.attack_cooldown:
			self.attacking = False

На самом деле конструкция очень проста. Если разница во времени после нажатия меньше кулдауна атаки (в моём случае 400 мс), запрещать атаку. Не забудьте закинуть функцию cooldowns в update-функцию.

Далее, пропишем метод import_player_assets:

def import_player_assets(self):
	character_path = '../graphic/Link/'
	self.animations = {'up': [], 'down': [], 'left': [], 'right': [],
	'right_idle': [], 'left_idle': [], 'up_idle': [], 'down_idle': [],
	'right_attack': [], 'left_attack': [], 'up_attack': [], 'down_attack': []}

В нём прописаны все возможности передвижения. Они лежат в папке "Link":

Не забудьте закинуть в базовых демонов Player-класса наши ассеты: self.import_player_assets(). Далее, "пробежимся" по нашим папкам благодаря методу import_folder в support.py:

for animation in self.animations.keys():
	full_path = character_path + animation
	self.animations[animation] = import_folder(full_path)

Теперь мы модем открыть все файлы, но есть дополнительная проблема — нужно прописать статусы и анимации при нажатии на кнопку. Статус по умолчанию укажем в демоне и по умолчанию Линк будет смотреть вниз (self.status = 'down'). Но этого мало. Нужно получать статус автоматически, а это значит новый метод:

def get_status(self):
	if self.direction.x == 0 and self.direction.y == 0:
		self.status = self.status + '_idle'

Тут мы прописываем название файла "стояния" героя. Стояние — _idle, а статус будет меняться от нажатия кнопок. Закидываем get_status() в update-метод.

Далее, пропишем статусы для наших методов хождения:

if keys[pygame.K_UP]:
	self.direction.y = -1
	self.status = 'up'
elif keys[pygame.K_DOWN]:
	self.direction.y = 1
	self.status = 'down'
else:
	self.direction.y = 0

if keys[pygame.K_LEFT]:
	self.direction.x = -1
	self.status = 'left'
elif keys[pygame.K_RIGHT]:
	self.direction.x = 1
	self.status = 'right'

Тут всё достаточно прозрачно. Движение = статусу. Подправим функцию статуса:

if not 'idle' in self.status:
	self.status = self.status + '_idle'

Теперь, если мы отпускаем кнопку — статус равен idle, а если держим просто название направления.

Теперь окончательно проапгрейдим код для атак и комбинаций с "_idle":

def get_status(self):
	if self.direction.x == 0 and self.direction.y == 0:
		if not 'idle' in self.status and not 'attack' in self.status:
			self.status = self.status + '_idle'
	if self.attacking:
		self.direction.x = 0 #координаты по x
		self.direction.y = 0 #координаты по y
		if not 'attack' in self.status: #если нет подписи "attack"
			if 'idle' in self.status: #но есть "idle"
				self.status = self.status.replace('_idle', '_attack') #убираем _idle, но оставляем _attack
			else:
				self.status = self.status + '_attack' #если idle не было, просто стави attack
	else:
		if 'attack' in self.status:
			self.status = self.status.replace('_attack', '') #удаляем attack при завершении статуса

Наконец, заанимируем Линка. Установим два новых демона self.frame_index = 0 — индекс первой картинки и скорость смены картинок — self.animation_speed = 0.15. Далее, создадим метод animate():

def animate(self):
	animation = self.animations[self.status] #узнаём статус для ссылки на нужный файл
	self.frame_index += self.animation_speed #добовляем нашу скорость и когда добавится единица (из 0.15), сменяем картинку
	if self.frame_index >= len(animation): #при вылете из массива
		self.frame_index = 0 #возвращаемся к начальной картинке и тем самым зацикливаемся
	self.image = animation[int(self.frame_index)] #указываем картику
	self.rect = self.image.get_rect(center = self.hitbox.center) #указываем хитбокс

Всё что тут происходит, мы перебираем все наши картинки и главное — их зациклить, как в рилсах. Не забываем в update-функцию self.animate().

Тут у меня залогала анимация атаки, так как кнопка продолжала нажиматься. Исправим это в input-методе:

def input(self): #варьируем кнопки
	if not self.attacking:
		keys = pygame.key.get_pressed()

		if keys[pygame.K_UP]:
			self.direction.y = -1
			self.status = 'up'
		elif keys[pygame.K_DOWN]:
			self.direction.y = 1
			self.status = 'down'
		else:
			self.direction.y = 0

		if keys[pygame.K_LEFT]:
			self.direction.x = -1
			self.status = 'left'
		elif keys[pygame.K_RIGHT]:
			self.direction.x = 1
			self.status = 'right'
		else:
			self.direction.x = 0

		if keys[pygame.K_SPACE]:
			self.attacking = True
			self.attack_time = pygame.time.get_ticks()

Итог:

Далее, прорисуем оружие. Файлы этого этапа.

Оружие героя

Тут я немного поменял карту, так как Линк врезался в мосты, которые соединяют нижние острова. Изменения делала непосредственно в Tiles и сохранял карту и csv-файлы. Чтобы всё было канонично, Линку выдадим меч. Спрайты на мечи я тоже отрисовал. Он лежит в папке weapons/sword. Там 5 картинок, где full обозначает сам меч, а остальные 4 — направления меча. Приступим к коду.

В файле setting.py, я создал словарь из оружий. У меня будет только один меч, но вы можете добавить больше оружия. Сам словарь:

weapon_data = {'sword': {'cooldown': 300, 'damage': 15, 'graphic':'../graphic/weapons/sword/full.png'}}

Далее, создадим новый файл с настойкой оружия weapon.py:

import pygame

class Weapon(pygame.sprite.Sprite):
	def __init__(self, player, groups):
		super().__init__(groups)
		self.image = pygame.Surface((40, 40)) #сама графика
		self.rect = self.image.get_rect(center = player.rect.center) #место отрисовки

Тут всё традиционно и без нового. Мы центруемся от самого игрока последней строкой в коде. Сейчас посередине будет рисоваться чёрный квадрат 40 на 40 пикселей. Импортируем новый файл в Level и создаём новый метод create_attack.

def create_attack(self):
	Weapon(self.player, [self.visible_sprites])	

Далее, в самой отрисовке игрока, добавим наш метод как ссылку на него:

self.player = Player((1000, 1000), [self.visible_sprites], self.obstacle_sprites, self.create_attack)

Далее, перейдём в файл player.py и там передадим create_attack и создадим демона. Также, при нажатии на пробел, добавим метод self.create_attak(). Теперь можем вернуться к отрисовке нашего оружия:

import pygame

class Weapon(pygame.sprite.Sprite):
	def __init__(self, player, groups):
		super().__init__(groups)
		direction = player.status.split('_')[0] #обрезаем строку по "_" чтобы понимать куда он смотрит
		full_path = f'../graphic/weapons/{player.weapon}/{direction}.png' #адрес оружия
		self.image = pygame.image.load(full_path).convert_alpha() #сама графика
		if direction == 'right':
			self.rect = self.image.get_rect(midleft = player.rect.midright + pygame.math.Vector2(-10, 16))
		elif direction == 'left':
			self.rect = self.image.get_rect(midright = player.rect.midleft + pygame.math.Vector2(10, 16))
		elif direction == 'down':
			self.rect = self.image.get_rect(midtop = player.rect.midbottom + pygame.math.Vector2(-15, 0))
		else:
			self.rect = self.image.get_rect(midbottom = player.rect.midtop + pygame.math.Vector2(-15, 0))

Тут появилось несколько интересного. Во-первых, мы обрезаем строку по "_" чтобы понять куда смотрит герой (неважно с "attack" или без). Далее, отрисовка. Нам нужно чтобы меч рисовался в руке у Линка. Я выбрал следующий метод, если меч слева, то "приклеиться" он должен справа от Линка, то есть midleft = player.rect.midright + pygame.math.Vector2(-10, 16). Далее, плюсуем вектор направления чтобы меч был ровно в руке. Далее, всё повторяется в зависимости от направления.

Добавим в player.py новых демонов:

self.create_attak = create_attak #создали атаку
self.weapon_index = 0 #номер оружия (если у вас будет несколько орудий пыток монстров)
self.weapon = list(weapon_data.keys())[self.weapon_index] #выбрали конкретное оружие и все его параметры= None

Теперь есть меч, но есть проблема. Мечи не исчезают:

Что ж, создадим новый метод в level.py: destroy_weapon. Помимо прочего, нужно немного переработать код в самом level.py. Создадим нового демона self.current_attack = None, а также переработаем метод create_attack.

def create_attack(self):
	self.current_attack = Weapon(self.player, [self.visible_sprites])	

def destroy_weapon(self):
	if self.current_attack:
		self.current_attack.kill()
	self.current_attack = None

Таким образом, при наличии атаки, мы убиваем процесс и обнуляем указатель атаки (current_attak). Нужен ещё кулдаун. Также, не забудьте сослаться на self.destroy_weapon в player:

self.player = Player((1000, 1000), [self.visible_sprites], self.obstacle_sprites, self.create_attack, self.destroy_weapon)

Далее пропишем метод в player.py и внесём в кулдаун новую функцию: self.destroy_weapon(). Результат:

Файлы этапа можно скачать здесь. Далее, настроим интерфейс.

Интерфейс

Наша задача — сделать интерфейс игры. Первым делом, нужно создать такие простые вещи как базовые параметры. У нас уже есть один параметр. Это скорость. Сейчас допишем остальные параметры. В демоны в файле player.py запишем следующие параметры:

self.stats = {'health': 100, 'energy': 60, 'attack': 10, 'speed': 5} #все параметры героя
self.health = self.stats['health'] #соотношение со здоровьем
self.energy = self.stats['energy'] #соотношение с энергией
self.exp = 4221 #количество очков
self.speed = self.stats['speed'] #скорость игрока

Все параметры указаны и можно удалить параметр скорости из демона ранее. Особенно хорошо, что Линк уже набрал 4221 очка за просмотр себя на ютюбе у Артура из Уфы. В файле settings.py Добавим немного параметров отображения:

BAR_HEIGHT = 20 #толщина всех панелек
HEALTH_BAR_WIDTH = 200  #длина панельки здоровья
ENERGY_BAR_WIDTH = 140 #длина панельки энергии
ITEM_BOX_SIZE = 80 #размер значка под предмет
UI_FONT = '../graphic/font/joystix.ttf' #основной шрифт
UI_FONT_SIZE = 18 #кегель шрифта

UI_BG_COLOR = '#222222' #цвет задника
UI_BORDER_COLOR = '#111111' #цвет обводки
TEXT_COLOR = '#EEEEEE' #цвет текста

HEALTH_COLOR = 'red' #цвет здоровья
ENERGY_COLOR = 'green' #цвет энергии

Тут самый важный момент — добавить шрифт. Самый его большой плюс это то, что он поддерживает русский язык. Теперь, в настройках уровня укажем нового демона self.ui = UI() и импортируем сам файл в проект. Под конец, добавим в run-метод правило отрисовки:

self.ui.display(self.player)

Теперь создадим новый файл ui.py:

import pygame
from settings import *

class UI:
	def __init__(self):
		self.display_surface = pygame.display.get_surface() #прорисовка самого экрана
		self.font = pygame.font.Font(UI_FONT, UI_FONT_SIZE) #добавление стандартного шрифта
		self.healt_bar_rect = pygame.Rect(10, 10, HEALTH_BAR_WIDTH, BAR_HEIGHT) #панелька для здоровья
		self.energy_bar_rect = pygame.Rect(10, 34, ENERGY_BAR_WIDTH, BAR_HEIGHT) #панелька для энергии

	def show_bar(self, current, max_amountm, bg_rect, color):
		pygame.draw.rect(self.display_surface, UI_BG_COLOR, bg_rect) #отрисовка задника панельки
		ratio = current / max_amountm
		current_with = bg_rect.width * ratio
		current_rect = bg_rect.copy()
		current_rect.width = current_with
		pygame.draw.rect(self.display_surface, color, current_rect) #рисование панельки
		pygame.draw.rect(self.display_surface, UI_BORDER_COLOR, bg_rect, 3) #рисование обводки панельки

	def display(self, player):
		self.show_bar(player.health, player.stats['health'], self.healt_bar_rect, HEALTH_COLOR) #обращение к отрисовке панели здоровья
		self.show_bar(player.energy, player.stats['energy'], self.energy_bar_rect, ENERGY_COLOR) #обращение к отрисовке панели энергии

Из интересного, тут есть строки расчётов:

ratio = current / max_amountm
current_with = bg_rect.width * ratio
current_rect = bg_rect.copy()
current_rect.width = current_with

Тут мы переводим значения нашего здоровья в проценты прорисовки в поле пикселей. Нам нужно перевести даже 140 очков здоровья в 100%. Для этого, мы запрашиваем current — очки здоровья и делим их на длину нашего поля здоровья (max_amountm), далее перемножаем это с bg_rect.width для отображения в поле. Я поставил в player.py значение здоровья на -10 и -50 на энергию:

self.health = self.stats['health'] - 10 #соотношение со здоровьем
self.energy = self.stats['energy'] - 50 #соотношение с энергией

Результат:

Нарисуем же наши очки. Переходим опять к ui.py и создадим новый метод show_exp:

def show_exp(self, exp):
	text_surf = self.font.render(str(int(exp)), False, TEXT_COLOR) #рендер шрифта с экспой, без сглаживания и с цветом
	x = self.display_surface.get_size()[0] - 20 #отступ снизу на 20 пикселей по x
	y = self.display_surface.get_size()[1] - 20 #отступ снизу на 20 пикселей по y
	text_rect = text_surf.get_rect(bottomright = (x, y)) #цепляемся за низ экрана справа

	pygame.draw.rect(self.display_surface, UI_BG_COLOR, text_rect.inflate(20, 20)) #цепляемся за низ экрана справа
	self.display_surface.blit(text_surf, text_rect) #отображаем панельку
	pygame.draw.rect(self.display_surface, UI_BORDER_COLOR, text_rect.inflate(20, 20), 3) #обводка панели

Из интересного, тут стоит False в методе self.font.render. Данный метод выключает сглаживание, так как у меня пиксельный шрифт. А также, pygame сделали крутой метод text_rect.inflate, который помогает вписать текст в панельку. Результат удивительно прекрасен:

Последний шаг — прорисовка меча Линка. Для начала, нужно прописать в базовых демонов наш список оружия. У меня в наличии только одно оружие, так что этот кусок кода можно упростить, но я оставил возможность подбирать оружие и добавить его в словарь оружия, а затем и в этот список:

self.weapon_graphics = []
for weapon in weapon_data.values():
	path = weapon['graphic']
	weapon = pygame.image.load(path).convert_alpha()
	self.weapon_graphics.append(weapon)

Далее, пишем простой метод для отображения предметов:

def weapon_overlay(self, weapon_index):
	bg_rect = pygame.Rect(10, 630, ITEM_BOX_SIZE, ITEM_BOX_SIZE)
	pygame.draw.rect(self.display_surface, UI_BG_COLOR, bg_rect)
	weapon_surf = self.weapon_graphics[weapon_index]
	weapon_rect = weapon_surf.get_rect(center = bg_rect.center)

	self.display_surface.blit(weapon_surf, weapon_rect)

В конце не забудьте добавить отображение оружия в display-методе: self.weapon_overlay(player.weapon_index).

Результат:

Файлы проекта и дальше будем писать монстров (более известных как бебы).

Монстры

Для начала, я прописал референсы для монстров. Они хранятся в папке graphic/monsters. Также, я добавил звуки ударов и закинул их в папку audio/attack Далее, в setting.py прописаны их входные данные:

monster_data = {
	'axalot': {'health': 200, 'exp': 400, 'damage': 40, 'attack_type': 'slash', 'attack_sound': '../audio/attack/slash.wav', 'speed': 3, 'resistance': 3, 'attack_radius': 80, 'notice_radius': 300},
	'lizard': {'health': 50, 'exp': 100, 'damage': 15,'attack_type': 'claw',  'attack_sound': '../audio/attack/claw.wav', 'speed': 2, 'resistance': 3, 'attack_radius': 100, 'notice_radius': 400},
	'snake': {'health': 100,'exp':100,'damage': 10,'attack_type': 'claw', 'attack_sound': '../audio/attack/claw.wav', 'speed': 4, 'resistance': 3, 'attack_radius': 80, 'notice_radius': 350},
	'spirit': {'health': 150,'exp':200,'damage': 15,'attack_type': 'claw', 'attack_sound': '../audio/attack/claw.wav', 'speed': 3, 'resistance': 3, 'attack_radius': 100, 'notice_radius': 400}}

Давайте пробежимся по параметрам:

• health — здоровье беба
• exp — сколько очков за смерть беба
• damage — какой урон он нанесёт герою
• attack_type — тип атаки
• attack_sound — звук удара
• speed — скорость зверька
• resistance — на сколько враг отлетит после нашего удара
• attack_radius — радиус, с которого беб опасен и может ударить
• notice_radius — радиус зрения вражины

Далее, создадим новый файл сущностей (entity.py) и добавим туда супер демона с наследованием групп:

import pygame

class Entity(pygame.sprite.Sprite):
	def __init__(self, groups):
		super().__init__(groups)

Скопируем методы move и collision из player.py. Теперь удаляем из player.py эти методы и ссылаться будем в классе не на pygame.sprite.Sprite, а на Entity (не забывайте импортировать файл). Эти небольшие танцы с бубном нужны для того, чтобы не переписывать каждый раз правила движений для нашего героя и врагов. Все они — одинаковые сущности. Также я перенёс демонов скорости анимации, фрейма и определения вектора скорости. Когда всё сделаете, перепроверьте, что всё работает.

Затем, наконец, создадим файл enemy.py:

import pygame
from settings import *
from entity import Entity

class Enemy(Entity):
	def __init__(self, monster_name, pos, groups):
		super().__init__(groups)
		self.sprite_type = 'enemy' #новый тип спрайтов — враги
		self.image = pygame.Surface((64, 64)) #наш традиционный размер тайла
		self.rect = self.image.get_rect(topleft = pos) #традиционная отрисовка

Перейдём к настройке уровня. Для начала, сделаем так, чтобы наш герой спаунился там, где надо (зелёный квадрат на карте). Для этого, нам нужно импортировать новый csv-файл из уже созданной карты 'entities': import_csv_layout('../map/map_Spawn.csv'). И пропишем в методе creat_map новый объект:

if style == 'entities':
	if col == '8':
	self.player = Player((x, y), [self.visible_sprites], self.obstacle_sprites, self.create_attack, self.destroy_weapon)

Результат вас удивит:

Герои Хайрула размножились. Проблема в том, что я прорисовывал карту разными наборами элементов. Не повторяйте моих ошибок и давайте всё исправлять. Дело в том, что номер тайла автоматически рассчитывается программой Tiles, а я указал, разные тайлы и номера задублировались, так как у меня был отдельный файл Bebs.png для спауна врагов и Link_and_block.png для Линка и блоков-стен. Теперь я объединил два набора тайлов и присвоил линку номер 16. Результат:

Линк на своём законном месте. Давайте заспаумим врагов, добавив лишь один else:

else:
	Enemy('monster', (x, y), [self.visible_sprites])

Монстры отобразились, но теперь нужно отобразить их верно. Работаем с файлом enemy.py:

import pygame
from settings import *
from entity import Entity
from support import *

class Enemy(Entity):
	def __init__(self, monster_name, pos, groups):
		super().__init__(groups)
		self.sprite_type = 'enemy' #новый тип спрайтов — враги
		self.import_graphics(monster_name) #обращаемся к новой функции перебора картинок
		self.status = 'idle' #установим базовый статус
		self.image = self.animations[self.status][self.frame_index] #перебираем номер фрейма в папке из функции ниже
		self.rect = self.image.get_rect(topleft = pos) #традиционная отрисовка

	def import_graphics(self, monster_name):
		self.animations = {'idle': [], 'move': [], 'attack': []} #перебираем возможные варианты анимаций в папках
		main_path = f'../graphic/monsters/{monster_name}/' #обращаемся к монстру по имени :)
		for animation in self.animations.keys(): #перебираем все картинки
			self.animations[animation] = import_folder(main_path + animation) #перебор благодаря support-файлу

Тут мы делаем всё ровно также, как и ранее, но если в файле level.py мы внесём имя любого монстра, то получим картинку монстра на карте:

Осталось только перебрать монстров по их номерам тайлов на карте:

else:
	if col == '0':
		monster_name = 'axolot'
	elif col == '4':
		monster_name = 'lizard'
	elif col == '8':
		monster_name = 'snake'
	else:
	monster_name = 'spirit'

	Enemy(monster_name, (x, y), [self.visible_sprites])

Теперь, добавим аргумент obstacle_sprites в нашу конструкцию, что бебы могли взаимодействовать с Линком. Далее, создадим update-метод для файла enemy.py:

def update(self):
	self.move(self.speed)

Далее, нужно прописать несколько статусов для наших плохишей. Добавим их в демонов данного файла:

self.monster_name = monster_name #имя монстра
monster_info = monster_data[self.monster_name] #перехват данных монстра по имени
self.health = monster_info['health']
self.exp = monster_info['exp']
self.speed = monster_info['speed']
self.attack_damage = monster_info['damage']
self.resistance = monster_info['resistance']
self.attack_radius = monster_info['attack_radius']
self.notice_radius = monster_info['notice_radius']
self.attack_type = monster_info['attack_type']

Тут мы ссылаемся на файл settings.py и перехватываем все параметры монстров оттуда. Теперь наша задача прописать метод определения дистанции до объекта. Я думал, что эта задача непроста, так как координаты объекта рассчитываются с верхнего левого угла, у них есть свои вектора (скорости), да ещё и нужна нормализация для предотвращения "диагонального чита" (как это было у Линка). Собственно весь метод:

def get_player_distance_direction(self, player):
	enemy_vec = pygame.math.Vector2(self.rect.center) #координата врага
	player_vec = pygame.math.Vector2(player.rect.center) #координата Линка
	distance = (player_vec - enemy_vec).magnitude() #Евклидова величина
	if distance > 0:
		direction = (player_vec - enemy_vec).normalize() #вычисление вектора сближения
	else:
		direction = pygame.math.Vector2() #точка, мы друг в друге
	return(distance, direction)

Я искренне не ожидал, что это так просто. По сути, все сложные методы вычисления Евклидовой величины по поиску дистанции мы переложили на функцию magnitude(), а с читерской функцией normalize() вы уже знакомы. И зачем я учил математику? Далее, пропишем метод определения статуса беба по отношению к Линку:

def get_status(self, player):
	distance = self.get_player_distance_direction(player)[0]
	if distance <= self.attack_radius:
		self.status = 'attack'
	elif distance <= self.notice_radius:
		self.status = 'move'
	else:
		self.status = 'idle'

Тут мы отсекаем изнутри во вне "окружности" зрения (близко — атака, средняя дистанция — преследование, далеко — idle), но чтобы оно заработало, нам нужно обновлять данные в фале level.py:

def enemy_update(self, player):
	enemy_sprites = [sprite for sprite in self.sprites() if hasattr(sprite,'sprite_type') and sprite.sprite_type == 'enemy']
	for enemy in enemy_sprites:
		enemy.enemy_update(player)

Тут самая интересная строка — строка прорисовывания спрайтов для врага. Тут можно как в анекдоте: "Потерядлся атрибут? Ничего страшного! Всегда есть метод hasattr". Далее, в run-методе пропишем отрисовку спрайтов врага:

self.visible_sprites.enemy_update(self.player)

Теперь мы сможем замкнуть врага на игрока, а игрока на уровень. Для этого пропишем новый метод в enemy.py:

def enemy_update(self, player):
	self.get_status(player)

Теперь, у нас есть способ получения методов, но мы с ними не взаимодействуем. Исправим это новым методом:

def actions(self, player):
	if self.status == 'attack':
		print('attack') #тут мы только пишем в терминале атаку
	elif self.status == 'move':
		self.direction = self.get_player_distance_direction(player)[1] #нанюхивать Линка
	else:
		self.direction = pygame.math.Vector2() #остановиться по координатам

В этом методе всё ровно также как мы работали ранее, но не забудьте закинуть его вызов в enemy_update-функцию командой self.actions(player). Тетерь пропишем анимацию. Она полностью аналогична анимации Линка:

def animate(self):
	animation = self.animations[self.status]
	self.frame_index += self.animation_speed
	if self.frame_index >= len(animation):
		self.frame_index = 0
	self.image = animation[int(self.frame_index)]
	self.rect = self.image.get_rect(center = self.hitbox.center)

Также, добавьте animate в update-функцию. Теперь можно получить ачивку: "Собрал всех чушпанов с района":

Но есть проблема. Они атакуют несчастного Линка толпой без остановки. Это нужно исправить, а значит время нового метода и нового кулдауна. Для начала, я добавил нового демона self.can_attack = True. Это флаг, который будет указывать на то, что беб может пнуть Линка. Соответственно, нужно подправить условие атаки и помимо дистанции, указать данный флаг. Если вы добавили флаг на True, то обязательно сразу нужно прописать ситуацию, когда он будет опускаться (положение False). Запишем этот пункт в методе анимации:

if self.frame_index >= len(animation):
	if self.status == 'attack':
		self.can_attack = False

Немного объясню происходящее. Анимация атаки не должна прерывать анимацию перехода и если мы завершили весь цикл из переходов от картинки к картинке, то только тогда можно менять флаг на опущенное состояние. Простыми словами, все враги могут ударить нас только 1 раз, так как флаг не поднимается обратно. Поднимать тот самый флаг мы будем по кулдауну через паузу. То есть, я дабалвю два демона, которые будут обозначать время атаки и кулдаун после атаки:

self.attack_time = None
self.attack_cooldown = 400

Теперь пропишем сам метод кулдауна по вычислению разницы текущего времени и времени задержки:

def cooldown(self):
	if not self.can_attack:
		current_time = pygame.time.get_ticks()
		if current_time - self.attack_time >= self.attack_cooldown:
			self.can_attack = True

Тут самое главное, не забыть про место старта времени, то есть про установку времени на момент атаки:

self.attack_time = pygame.time.get_ticks()

После этого, не забудьте закинуть метод в update-метод. Результат:

Мы не закончили работу с врагами, но давайте оставлю бэкап проекта сейчас и в следующей части создадим методы взаимодействия нас с врагами и врагов с нами.

Драки с бебами

Итак, для начала создадим два новых демона для атак в level.py:

self.attack_sprites = pygame.sprite.Group() #атакующий спрайт
self.attackable_sprites = pygame.sprite.Group() #атакуемый спрайт

Думаю, по названиям понятно, что демоны нужны для обозначения процесса атаки. Дополним метод вызова врагов помимо видимых спрайтов, атакуемыми спрайтами (self.attack_sprites):

Enemy(monster_name, (x, y), [self.visible_sprites, self.attackable_sprites], self.obstacle_sprites)

Также, дополним метод create_attack атакующим спрайтом (self.attack_sprites) :

def create_attack(self):
	self.current_attack = Weapon(self.player, [self.visible_sprites, self.attack_sprites])

Далее, пропишем новый метод с логикой атаки игрока:

def player_attack_logic(self):
	if self.attack_sprites:
		for attack_sprites in self.attack_sprites:
			collision_sprites = pygame.sprite.spritecollide(attack_sprites, self.attackable_sprites, False)
			if collision_sprites:
				for target_sprite in collision_sprites:
					target_sprite.kill()

Самая интересная строка тут, это строка с методом пайгейма pygame.sprite.spritecollide. Данный метод позволяет удалять спрайт из группы. Первый аргумент функции — спрайты для атаки, второй — группа спрайтов из которой мы будем удалять спрайт, третий — DoKill. Если у DoKill установлено значение True, все спрайты, которые сталкиваются, будут удалены из группы. Далее, в run-методе пропишем наш метод. Исход:

Немного улучшим метод player_attack_logic:

if target_sprite.sprite_type == 'enemy':
	target_sprite.get_damage(self.player, attack_sprites.sprite_type)

Мы стали сопоставлять наши спрайты по типам. В моём проекте, типов только два (enemy и weapon). Я прописал в файле weapon.py в демоне строку для присваивания ему нового типа:

self.sprite_type = 'weapon'

Далее, нам не нужно удалять врага при ударе. Нам нужно прописывать ему урон от нашего оружия. Собственно, теперь нужно в файле enemy.py прописать новый метод — get_damage:

def get_damage(player, attack_type):
	if attack_type == 'weapon':
	    self.health -= player.get_full_weapon_damage()

Тут мы прописываем новый метод (get_full_weapon_damage), который должен высчитывать сумму урона от оружия и от силы самого Линка (прямо как в Dark Souls). Пропишем же данный метод в player.py:

def get_full_weapon_damage(self):
	base_damage = self.stats['attack'] #урон самого Линка
	weapon_damage = weapon_data[self.weapon]['damage'] #урон от выбранного оружия
	return base_damage + weapon_damage

Тут мы находим и складываем уроны их наших списков. Возможно, тут встанет вопрос: "Зачем так сложно, если у нас только один меч и всё?". Я хотел бы сделать проект так, чтобы вы могли самостоятельно с ним "поиграться". Собственно и цель статьи не номинация "Игра года" в The Game Awards, а лишь попытка продемонстрировать работоспособность языка Python как неплохого движка. Ну да вернёмся к коду. Помимо урона, я решил сразу прописать кулдаун оружия и заменил строку:

if current_time - self.attack_time >= self.attack_cooldown

На строку:

if current_time - self.attack_time >= self.attack_cooldown + weapon_data[self.weapon]['cooldown']

Напишем новый метод в enemy.py на проверку смерти вражины:

def check_death(self):
	if self.health <= 0:
		self.kill()

Тут я даже не знаю что ещё подсветить в коде :) Не забудьте добавить данный метод в update-метод. Теперь один удар приводит к смерти врага. Таким образов, PyGame считает, что пока оружие соприкасается с врагом (вызывается метод коллизий), удары наносятся один за другим. Как итог — Линк танк, который уничтожает всё на своём пути. Исправим это. Для начала, создадим новых демонов enemy.py:

self.vulnerable = True #флаг уязвимости
self.hit_time = None #время удара
self.invincibility_duration = 300 #продолжительность неуязвимости

Тут достаточно прозрачные демоны. Важный момент — флаг уязвимости. Если он поднят — враг может получать урон. Теперь встроим их в get_damage:

def get_damage(self, player, attack_type):
	if self.vulnerable:	
		if attack_type == 'weapon':
			self.health -= player.get_full_weapon_damage()
		self.hit_time = pygame.time

Далее, необходимо дополнить код cooldown-метода:

if not self.vulnerable:
	if current_time - self.hit_time >= self.invincibility_duration:
		self.vulnerable = True

Тут, как я говорил ранее, мы сразу добавляем вариацию флага. У нас было место, где флаг опускается и теперь в cooldown-методе он поднимается по истечению указанного времени неуязвимости. Теперь все враги убиваются весьма приятно. Теперь, нужно добавить отбивание врага на дистанцию, которая указана у каждого врага. Создадим ещё метод:

def hit_reaction(self):
	if not self.vulnerable:
		self.direction *= -self.resistance

Осталось вычислить положение в методе get_damage:

self.direction = self.get_player_distance_direction(player)[1]

Теперь добавим мерцание во время удара, чтобы понять что удар был сделан. В PyGame все сигнатуры (синусоидные функции) лежат в диапазоне от -255 до 255, а позиции удобно брать из синусоид, так как интерпретация в Python будет работать на основе степеней (как и любой калькулятор), а затем будет процесс получения точки на синусоиде. Этот процесс я описывал дольше, чем будет писаться метод отображения пульсации:

def wave_value(self):
	value = sin(pygame.time.get_ticks())
	if value >= 0:
		return 255
	else:
		return 0

Данный метод написан в entity.py. Не забудьте импортировать sin-метод из библиотеки math. Теперь вызовем данный метод при ударе по врагу в методе animate:

if not self.vulnerable:
	alpha = self.wave_value()
	self.image.set_alpha(alpha)
else:
	self.image.set_alpha(255)

Итак, сейчас мы бьём врагов абсолютно верно и можем отследить когда враги атакуют нас (в терминал приходит сообщение "attack"). Осталось сделать метод, который коцает нашего Линка. Пропишем его в level.py:

def damage_player(self, amount, attack_type):
	if self.player.vulnerable:
		self.player.health -= amount
		self.player.vulnerable = False
		self.player.hurt_time = pygame.time.get_ticks()

Дополним в create_map в строку вызова врагов нанесение урона Линку:

Enemy(monster_name, (x, y), [self.visible_sprites, self.attackable_sprites], self.obstacle_sprites, self.damage_player)

Добавим в Enemy-класс наш новый только созданный параметр (damage_player) и пропишем нового демона — self.damage_player = damage_player. Теперь вместо простого вывода сообщения "attack" выполним вызов нашего метода:

self.damage_player(amount, attack_type)

Добавим параметры таймеров в демонов нашего player-класса:

self.vulnerable = True
self.hurt_time = None
self.invulnerablity_duration = 500

Они аналогичны демонам в enemy.py. Далее, традиционно пропишем смену флага в наш кулдаун-метод:

if not self.vulnerable:
	if current_time - self.hurt_time >= self.invulnerablity_duration:
		self.vulnerable = True

Теперь пропишем наше мерцание. Тут всё также, как и ранее. Прописывать будем в animate-методе:

if not self.vulnerable:
	alpha = self.wave_value()
	self.image.set_alpha(alpha)
else:
	self.image.set_alpha(255)

Теперь нам нужно восстанавливать энергию (повторим механику из Dark Souls). Для этого создадим метод energy_recover:

def energy_recover(self):
	if self.energy < self.stats['energy']:
		self.energy += 0.1
	else:
		self.energy = self.stats['energy']

Далее, пропишем, что при ударе у нас теряется 10 очков стамины, а если её не хватает — атака не проходит:

if keys[pygame.K_SPACE]:
	if self.energy >= 10:
		self.energy -= 10
		self.attacking = True
		self.attack_time = pygame.time.get_ticks()
		self.create_attak()
		self.weapon_attack_sound.play()

Последнее, что я хотел бы сделать — добавить экспу за убийство врага в level.py:

def add_xp(self, amount):
	self.player.exp += amount

Добавим этот же метод для create_map в Enemy. Далее, повторим всё, что делали ранее с damage_player.

Файлы данного шага тут и давайте приступим к последнему шагу — музыке.

Музыка

Мы на финишной прямой. В нашего player.py добавим демонов:

self.weapon_attack_sound = pygame.mixer.Sound('../audio/attack/slash.wav')
self.weapon_attack_sound.set_volume(0.4)

Первый демон укажет на название файла, а второй на громкость. Далее, вызовем звук при нажатии на клавишу:

self.weapon_attack_sound.play()

Повторим успех с ударом от монстра:

self.hit_sound = pygame.mixer.Sound('../audio/attack/claw.wav')
self.hit_sound.set_volume(0.4)

self.hit_sound.play()

Данный метод я вызвал в get_damage после успешного попадания. Теперь мы слышим попадания при ударе. А враг? Сейчас сделаем. Добавим ещё пару демонов и вызов:

self.attack_sound = pygame.mixer.Sound(monster_info['attack_sound'])
self.attack_sound.set_volume(0.3)

self.attack_sound.play()

Вызов функции в методе actions-методе в enemy.py. Осталось только главная музыка игры. Переходим в main.py:

main_sound = pygame.mixer.Sound('../audio/main.wav')
main_sound.play(loops = -1)

Это два новых демона. Отличие только одно — метод play(loops = -1). Тут мы создаём музыку, которая будет играть снова и снова во время игры и не закончится до выхода.

В конце, я забыл, что игра не заканчивается. Я исправил это функцией final в level.py:

def final(self):
	if self.player.health <= 0:
		print('\n', '\n', 'Линк умер. Хана Хайрулу')
		exit()
	if self.player.exp > 5000:
		print('\n', '\n', 'Линк победил')
		exit()

Тут всё просто. При получении более 5000 очков — вы победили, менее — проиграли. Ну и конечно, вернул здоровье и энергию на 100%, а экспу на 0. Все файлы с доработками оставлю тут. Вот что получилось:

Итоги

В результате работы мы создали игру на голом Python только с библиотекой PyGame. Было использовано ещё парочка для обхода директорий, но можно было и без них. Выводы данной статьи, которые я хотел бы сделать не заключаются в том, чтобы подчёркивать мысль о том, что Python скоро заменит C# с Unity и Unreal. Цель статьи — продемонстрировать возможность работы с Python как с движком для программирования игр. В России, я думаю, этот вариант написания игр будет популярен. Не из-за World Of Tanks, который написан на Python, а из-за мультиплатформенности интерпретируемого языка программирования. Данный код я могу спокойно запускать из любой Unix-системы и это круто. Но встаёт пара вопросов:

1. Насколько сложно написать игру самому с нуля? Если вы только входите в геймдев и вообще не понимаете что происходит с играми — не используйте питон. Данный сектор сейчас очень узок и вряд ли вы сможете быстро найти работу (как и вообще в геймдеве). Выбирайте Unity. Он проще Unreal Engine, но при этом весьма работоспособен. Если же вы понимаете язык программирования Python и хотите сделать игру — делайте её на Python. Нет смысла выучивать новый язык только для создания игры. Python весьма на многое способен. В качестве доказательств моих слов, могу сослаться на игры написанные на Python, а могу и на 3D-движок, который набирает обороты под название HARFANG. Он ничем не хуже Unity.
2. Ну а как быть с опытом разработчиков? На Unity и Unreal много пресетов. Это правда. Но и на Python не меньше. Я не геймдевер, как можно было понять из введения в статью. Я системный администратор со знанием Python на +/- Middle-уровне (да простят меня разрабы). Я писал код для оптимизации работы в сетях, а вот с играми знаком только как игрок со стажем или программист крестиков-ноликов. Всё что я сделал — я начал изучать вопрос. И каково было моё удивление в том, что есть куча людей, которые помогают написать игру на Python. Лично я пользовался гайдами от Clear Code (чувак очень подробно рассказывает на какие библиотеки в PyGame ссылаться), собственно, официальным мануалом по PyGame и книгой Making Games with Python & Pygame (внутри базовые математические концепции игр). Эти три элемента позволили мне написать игру меньше чем за месяц.

Конечно, мой проект по ПуЗельде можно долго дорабатывать. Можно сделать фон из деревьев, чтобы экран не оставался чёрным, добавить оружия, подбираемых предметов. Можно сделать больших боссов. Можно создать менюшку с перезапуском и выходом из игры. В общем, есть много точек роста. Весь проект я оставляю вам на обсуждение и возможные доработки. Надеюсь было интересно! Закончу как один известный выпускник 13 школы.

Последние коммиты на GitVerse!

Ииииииииииииииииииииииииии помните! Питон — игривая змея!

• Приложения
• Sub-GHz
• 125 кГц RFID
• NFC
• Инфракрасный порт
• GPIO
• iButton
• Bad USB
• U2F
• Часы и настройки
• Прошивки
• Где, что и как купить?
• А кому оно надо?

Не так давно, примерно год назад я наконец получил свою долгожданную посылку. Flipper Zero. Для тех кто не знает, Flipper Zero - это небольшое устройство, которое позволяет заниматься всякими весёлыми затеями в жизни. Веселье начинается с Sub-1 GHz антенны и продолжается микро-скриптами для ПК. Интересующихся, прошу под кат.

Ваше знакомство буду выполнять в хронологическом порядке разделов в меню самого флипера.

Приложения

Я бы не стал выбирать самым основным пунктом данный, так как задача флипера, на мой взгляд, работа с физическим миром вокруг нас, а не программные приколюхи внутри устройства. Как устройство по работе с приложениями - флипер не лучший вариант. Я бы рекомендовал использовать Raspberry Pi или на худой конец Arduino.

Тем не менее, внутри достаточно много приложений уже написанных прекрасными пользователями интернета. Скажу сразу, я установил себе кастомную прошивку DarkFlipper. Об этом позже.

Из предустановок - 8-битные игры типа DOOM, надстройки для распиновки GPIO, аудио-проигрыватель, калькуляторы и доп. приложения и доп. приложения для антенны в 1 ГГц.

Повторюсь, данный раздел совсем не самый интересный.

Sub-GHz

Тут всё просто. В диапазоне от 300 до 928 МГц в AM и FM модификациях можно сканировать все сырые и не сырые данные.

Для тех, кто не очень понимает зачем, могу привести простой пример - коды шлагбаумов. В данном диапазоне передаются данные в шлагбаумы. Как пример, я смог скопировать свой ключ от шлагбаума. Любых шлагбаумов и ворот.

Как это можно реализовать? Расскажу свою историю. Я живу в центре города, где есть такое поверие: "нет шлагбаума - нет парковки". Живя в уникальном, не побоюсь этого слова, доме, где в один небольшой двор размером с небольшой "плевочек" с детской площадкой и местом для парковки примерно на 30 машин установили аж 3 шлагбаума. Три, Карл!

Боль данного пункта заключается в том, что шлагбаумы были установлены трёх разных фирм, трёх разных диапазонов, да ещё и двух типов закрытия. Будучи законопослушным гражданином, я решил запросить данный пульт для парковки своего авто. Позвонив по номерам, которые были упорно замазаны на шлагбауме, я попал не много, не мало в город Реутов (сам нахожусь я в Москве). Там, мне сказали, что сделать можно, но без физического ключа - ничего не получится. На вопрос где его добыть, я получил неутешительный ответ: "Не знаю". Месяц поисков и чудом я выяснил у соседей, что данный ключ находится у "старшей по подъезду" (рубрика "Центр Москвы"). Старшая по подъезду переехала, а подъезд остался. Не ленясь, я дозвонился до данной хозяйки медного шлагбаума. Выяснилось, что данные три шлагбаума были установлены до закона о централизованной установке шлагбаумов и каждый подъезд поставил то что хочет и то как хочет данный аппарат. Каждый шлагбаум - совместная собственность, где все бумаги носит при себе старшая по подъезду. Цирк продолжился. Требования для получения заветного ключа были следующие:

1. Заплатить 7 тысяч рублей за вызов бригады (оно и понятно, из Реутова-то ехать)
2. Купить резидентную парковку для бесплатной парковки в районе дома, что стоило 3 тысячи рублей в год. Она у меня была, так как ставить машину у дома я не мог.
3. Отдать "на сканирование в архив" старшей по подъезду, проживающей в другом доме все документы на машину и меня.

Если первые два пункта были хотя бы понятны и хоть на сколько-то разумны (хотя сейчас резидентной парковки сейчас у меня нет, так как ставя машину в дворовой территории, она не нужна), то последний пункт меня возмутил. И я бы не против был бы и купить за 10 тысяч "ключик от домика", даже был бы не против купить данную подписку у женщины, которая поставила данный шлагбаум, ведь благодаря ней, во дворе уменьшилось количество такси и сторонних машин. Но вот отдавать документы куда-то в другой дом незнакомому человеку, как-то не хотелось. Я любезно отказался от данного предложения.

Шаг в сторону парковки подарила мне компания Прайм Пульт. Вопрос решился просто.

Кто не понял - это ключ, который копирует сигнал. Нужно было просто понять в каком диапазоне работает ключ. Цена вопроса за 10 ключей была 3 тысячи рублей.

Зная фирму производителя (в моём случае Nice Flor-S), можно узнать герцовку данного производителя (в моём случае 433,92 МГц). Далее - всё просто.

Флиппер же помог мне сделать то же самое, но не в отдельном шлагбауме, а на всех трёх простым чтением сырых (RAW) данных. Также, в кастомной прошивке есть подбор ключей по диапазону (приложение находится в отдельной папке в меню Applications).

125 кГц RFID

Переводя с русского на русский, данный раздел нужен для чтения ключей и смарт карт доступа.

Данные ключи сейчас активно используются в новостройках для открытия балконов или (простите) комнат для мусора. В многих учреждениях, открывается турникеты для входа в помещения.

Я работаю в университете и у нас такие же ключи доступа. Как прочитать её - просто. Нажать кнопку "Read" и положить её под флипер. Примерно так:

NFC

Аналог ключей, но с большей защитой. Бывает два типа защиты - PSK. В нём - всё также как и в 125 кГц ключах.

Второй вариант - ASK.

Тут нужно сделать 2 пункта - записать ключ и считыватель. Мужчина на видео по ASK - создатель флипера Павел Жовнер @zhovner

Инфракрасный порт

Инфракрасный излучатель позволяет управлять всем с ИК-приёмником. Тут справится даже ребёнок. Выбираем универсальный пульт:

Затем, выбираем конкретный тип прибора:

Далее, переворачиваем флипер, так чтобы сверху оказался ИК-передатчик и после нажатия на кнопку - отправляются все типы ИК-сигналов.

GPIO

Жаба меня задушила купить Wi-Fi модуль для флипера. По нему не смогу ничего рассказать. Спасибо YouTube за контент.

Как дополнение, распиновка:

iButton

Под надписью iButton спрятался сканнер ключей. Работает всё просто. Сканируем ключ на + и - к разным выпирающим точкам:

Далее, эмулируем их же и подносим к домофону:

Bad USB

Мой любимый раздел. По умолчанию, доступно всего 2 демо для Mac и Windows. Так как сижу на винде, скриншот вывода:

Конечно, этим всё не заканчивается. Далеко не заканчивается. Из моих любимых уже готовых скриптов под винду на PowerShell - разработка от Jakoby. Там много различных вариаций использования от простой смены обоев, до Wi-Fi стиллера.

U2F

Двухфакторная аутентификация возможна и на флипере. Всё что нужно - подключить его без утилиты qFlipper.

К слову про qFlipper. Приложение можно скачать здесь. Смысл приложения прост - работа со сторонним устройством (ПК или же телефоном). Также есть работа через блютуз.

Часы и настройки

Тут что-то добавить сложно. Часы необходимы, если хотите узнать время, а в настройках можно доработать ваш флипер.

Прошивки

Из моих фаворитов кастомных прошивок - DarkFlippers.

На мой взгляд, данная прошивка самая стабильная из кастомных. Изменений довольно много. Все они описаны по ссылке на репозиторий гитхаба.

Второй крутой вариант - вариант от TalkingSasquach. Там также есть крутые обои такого типа:

Где, что и как купить?

Сейчас с поставками флипера сложности. Я свой флипер получил спустя почти год после его официального выхода, как пользователь поддерживающий проект на кикстарте. В комплекте: коробочка, USB type-C, стикер и инструкция по быстрому старту.

Сам флипер, как сказано в официальном телеграмм-канале Павла, купить можно через Joom. Всё остальное (чехол, Wi-Fi модуль, плату) можно купить в Амперке.

А кому оно надо?

Как итог моего использования, могу сказать следующее (учтите, это только моё мнение): устройство прикольное, но нужно "понимающим" пользователям или тем, у кого много ключ-карт и всякого рода пультов.

В реальной жизни я использовал флипер порой и веселее включая кондиционеры и проекторы в кабинетах, где оно всё терялось. Ну и конечно, убивалка времени - классная. Лично для меня - устройство очень удобно и главное - приятно. Однако, есть два момента. Первый - я гик и кайфую с этого. Второй - купил я устройство в хорошие годы за 8 000 - 10 000 тысяч рублей (в зависимости от курса банка за евробаксы). Особые весельчаки взламывают лючки теслы.

Потенциал у устройства есть. Об этом потенциале говорит Линус Себастьян (канал Linus Tech Tips). По мнению Себастьяна, Flipper Zero — это на самом деле это один из самых универсальных хакерских инструментов, которые когда-либо появлялись на рынке.

Как всегда, выбор остаётся за вами. Я же пойду дальше юзать свой флипер и играться с новыми и новыми прошивками.

• Проблематика концепции мировой сети
• WWW
• WEB 1.0
• WEB 2.0
• Теория детерминизма
• Криптовалюта
• WEB 3.0
• Необходимость WEB 3.0
• (Не)возможность WEB 3.0

Пишу вам о наболевшем. О WEB 3.0. Понимаю, что и информация была много где и много разрозненной информации, но в этой статье я постарался рассказать всю основную информацию по всем основным понятиям. Часть из информации понятна мастодонтам в области, часть очень ознакомительна, однако, думаю, информация будет интересна многим и надеюсь весьма понятна. Не будем откладывать вопрос в долгий ящик и приступим.

Проблематика концепции мировой сети

Для обсуждения вопроса мировой сети, нужно дать определение сети, а также сказать о том, как сеть стала мировой паутиной, хотя изначально предполагалась библиотечным хранилищем.

Информационная сеть – коммуникационная сеть, в которой информация выступает в качестве продукта создания, переработки, хранения и использования. С появлением персональных компьютеров стали широко распространятся компьютерные сети. Начиная с Тима-Бёрнса Ли, более известного как основателя Интернета, была ключевая концепция Интернета как киберпространства. Под киберпространством в данном контексте подразумевается виртуальная реальность, т.е. второй мир как «внутри» компьютеров, так и «внутри» компьютерных сетей. Было понятие сеть и Интернет (от англ. InterNet, где Inter - интернациональная, Net - сеть). Интернет был ключевым разделом в системе связанных воедино устройств. Смысл данного раздела, который получил своё название уже после создания 29 октября 1969 на базе ARPANET, был в хранении, передачи и работе с информацией. Соответственно, было необходимо создать систему, которая будет хранить информацию и прописывать доступ к ней путём иерархических подходов (аутентификации по ассиметричному или же симметричному шифрованию). Концепция разрасталась и ARPANET стал Интернетом, который правильно писать именно с заглавной буквы как название, а не с прописной как устоявшийся объект в реальной жизни.

Изначальная концепция предполагала, что сеть станет подобием цифровой библиотеки с множеством разветвлений и простыми алгоритмами поиска как по тексту, так и по более сложному содержанию. Можно сказать, что концепция не поменялась, однако на практике нынешний Интернет не используется по назначению и концепция требовала тотального пересмотра и расширения.

Сейчас не существует общепринятого определения Интернета, поэтому мною дается не само понятие, а концепция, в которой описано какие идеи вкладывали в это создатели сайтов и технологий. Даже само понимание «Отец» Интернета – звучит очень странно. Тим-Бёрнс Ли создал протоколы (правила) работы библиотечной системы отправки и получения данных, пользователи же вместе с инженерами изменили привычную идею (концепцию), после чего родилось новое виденье сети в целом и Интернета в частности.

WWW

В сетях и Интернете, в частности, используется аббревиатура Всемирной паутины - WWW или World Wide Web. Всемирная паутина — это распределённая система, предоставляющая доступ к связанным между собой документам, расположенным на различных компьютерах, подключённых к сети Интернет. Для обозначения Всемирной паутины также используют слово веб (англ. web «паутина»). К этому слову мы вернёмся в следующем разделе данной работы.

Мировая паутина представляет из себя сложную систему, и как любую сложную систему её разбили на более простые уровни для удобства работы. Разбитие было названо моделью OSI или ISO, так как читать её можно сверху вниз и снизу вверх, не боясь потерять смысл. Сетевая модель OSI (The Open Systems Interconnection model) — сетевая модель стека (набора) сетевых протоколов OSI/ISO. Сама модель выглядит сейчас концептуально иначе:

Разница заключается в отступлении от стандартных приложений и протоколов, но переход к новым стандартам логического мышления, дабы открыть доступ инженерам нового времени к созданию совершенно других технологий, которые базировались бы на старой логике. Проблема в том, что модель OSI описывает логистику, а уровни Интернета демонстрируют технологию, разработанную на том или ином уровне. Как бы то ни было, нас волнует технология Всемирной паутины и её концептуальное представление ранее и сейчас.

WEB 1.0

Концепция WEB 1.0 появилась не сразу, а после появления в 2005 году концепции WEB 2.0. С приходом нового устарело то, что было ранее (иными словами, появление WEB 2.0 породило WEB 1.0, как предшественника), и получило своё название на полках истории. О WEB 2.0 мы поговорим в следующем разделе, а про ретроспективно созданную WEB 1.0 необходимо расписать ключевые данные в этом разделе.

WEB 1.0 продлился с 1991 по 2004 год. Работа велась следующим образом: в случае, если был инженер, который хотел поделиться с миром своим сайтом, он писал его самостоятельно и после чего выгружал его на удалённый сервер, затем пользователь, обладающий компьютером и браузером (программный продукт для просмотра страниц в Интернете) на нём, а также купленным у провайдера доступом к Интернету, мог открыть и посмотреть содержимое сайта инженера.

Сайты выглядели тоже весьма посредственно, так как доработка требовала большое количество итерационных действий, и для введения одного нового слова на страницу, приходилось переписывать сайт полностью.

Альтернативное название сети WEB 1.0 было Read-Only Web (от англ. только для чтения). Это был ключевой и фатальный недостаток технологии (речь идёт о наборе технологий WEB 1.0, а не о конкретном протоколе), так как люди делились на тех, кто может только писать книги и тех, кто мог только читать. Также было с реальными книгами логично поначалу, но весьма неудобно в результате, так как многие читатели хотели также доработать контент на сайте, написать свой сайт или вообще сделать иной сервис, а сделать это было весьма проблематично. Проблема была не столько в цене (за данную услугу платили неохотно и не много), сколько в отсутствии необходимости и логичности, так как Интернет в то время был малопопулярен с точки зрения самопродвигающейся социальной площадки. Как итог, в WEB 1.0 получилось: отсутствие интерактивности и автоматизации, минимальное участие пользователей в формировании контента и примитивный дизайн.

WEB 2.0

Всё поменял Тим О’Райли. В 2005 году американский издатель и активист движения за свободное программное обеспечение опубликовал статью What Is Web 2.0, которая датируется 30 сентября 2005 года. В ней изложены все основные изменения концепции по сравнению с WEB 1.0. К основным изменениям относят: пользователи могут сами участвовать в жизни Интернета и наполнять его контентом, появились тренды на рынке и крупные корпорации стали их негласными законодателями (всё это произошло в результате капиталистического подхода к сетям), исходя из предыдущего пункта, пользовательские данные стали «товаром» для рекламодателей. Ключевой неизменный пункт - информация по-прежнему хранится на единых серверах и выдается по требованию. Схема подключения аналогична схеме ниже.

Чтобы увидеть сайт исконно WEB 2.0 - откройте сайты типа Instagram.com или, например habr.com. Все пользователи могу писать статьи, выдавать контент и писать комментарии, однако они не стали сетевыми мастерами и не стали владеть индустрией. Сейчас происходит мировой апокалипсис WEB 2.0.

Апокалипсис можно условно назвать так: "Эра таргетированной рекламы и недостатка приватности". Произошло это по двум причинам: развитие социальных функций Сети и потеря контроля пользователями своих данных. Как результат: корпорации могут удалять, сохранять, изменять, приватизировать и патентовать любой контент. Для упрощения контроля появилась технология RSS.

Из определения: RSS (англ. Rich Site Summary — обогащённая сводка сайта) — семейство XML-форматов, предназначенных для описания лент новостей, анонсов статей, изменений в блогах и т. п. Информация из различных источников, представленная в формате RSS, может быть собрана, обработана и представлена пользователю в удобном для него виде специальными программами-агрегаторами или-сервисами.

Таким образом - все стали знать всё про всех. Конечно, вопрос в том, что можно не вылезать в Интернет и/или ничего там не выкладывать, но тогда получается жесточайшая цензура путём запугивания людей открытостью их жизни. Появилась ценность приватности. За переписки или фото опубликованные заранее стали платить астрономические суммы.

Пример от 7 марта 2023 года. Русскоязычные хакеры BlackСat опубликовали в даркнете интимные фото больных раком, после того как группа здравоохранения Пенсильвании отказалась платить выкуп. LVHN заявляет, что этот поступок является отвратительным и жестоким по отношению к пациентам, которые получают лечение от онкологии.

Или другой пример от 23 марта 2022 года. Крупная база данных клиентов «Яндекс.Еды» была опубликована в интернете. В ней указаны местоположение заказчика, электронная почта, номера телефонов и еще несколько строк информации. Самый полный список данных содержит: Ф.И.О; адрес местоположения, этаж, квартира, электронная почта, модель телефона (iOS или Android), код домофона и сумма, потраченная на заказы за последние полгода.

Проблема сейчас встала очень остро и решение было предложено философским сообществом в далёком 2007 году.

Теория детерминизма

Детерминизм — это философское учение о закономерной универсальной взаимосвязи и взаимообусловленности явлений объективной действительности. Понятие "детерминизм" в философском поле сформулировали в древней Греции. Его изучали материалисты-атомисты. Позже, понятие детерминизма начинает приобретать новый смысл — смысл обусловленности — и употребляется в этике для выражения позиции, противостоящей «свободе воли». В XVII веке в период выработки элементарных понятий механики происходит сближение понятия детерминизма и причинности, устанавливается тесная связь категории закономерности и причинности, закладываются основы механистического детерминизма. Успехи механики закрепляют представления об исключительно динамическом характере закономерностей, об универсальности причинной обусловленности.

Таким образом, если извлечь из философского учения нужное для технологий знание, можно извлечь следующую мысль. Детерминизм — это условные рельсы, по которым движется технологический прогресс. Другого варианта, как сделать ровно так как есть сейчас быть не могло и не может. Было только "до" и есть только "после". На каждое "после" влияет своё "до".

Взяв это умозаключение за основу, можно дойти до очень интересных процессов. Например, как появились нейронные сети - вполне объяснимо, однако почему они работают именно так, как работают - понять до сих пор не удаётся. Значит можно изучить всё прошлое и восстановить точную картину вплоть до Иисуса Христа или даже динозавров, лишь при достаточно больших вычислительных мощностях (данная концепция была описана в сериале "Devs"). Раз так, то почему нельзя структурировать данные в детерминистическом поле путём банальной реверс-инженерии рельс жизни? Данные есть, но существует проблема вычислительных мощностей, которые сейчас весьма развиты, но недостаточно для того, чтобы сотворить такое. Итог - развитие квантовых компьютеров, которые кратно быстрее всех ныне изученных компьютеров. В сентябре 2019 года Google удалось достичь квантового превосходства — квантовый компьютер выполнил за 200 секунд вычисления, на которые у мощнейшего обычного компьютера ушло бы 10 тысячелетий. В декабре 2020 года о достижении квантового превосходства заявили и китайские исследователи. Прототип квантового компьютера из Поднебесной сумел за три минуты решить задачу, на которую у самого быстрого в мире компьютера уйдет более 600 млн лет. И снова недостаток мощностей и слишком большая цена разработки. Однако данная проблема целиком и полностью придумана маркетингом.

Криптовалюта

Кто разогнал и "обжил" квантовый компьютер до скоростей, что описаны выше? Мировой лидер в области IT - копания Google. На момент 26 октября 2006 г.; 22:52 МСК тройка лидеров мирового технологического рынка выглядела так: 1 место. Microsoft ($281,85 млрд), 2 место. Google ($147,77 млрд), 3 место. Cisco ($147,08 млрд). Компании Microsoft и Cisco также применяют технологии квантовых вычислений, и весь мир надеется на их успех. Но он вовсе не нужен. Это было активно продемонстрировано в 2018-19 годах майнингом криптовалют в России и мире. Впервые о добыче цифровой валюты заговорили более десяти лет назад. С того момента курс биткоина вырос в сотни раз, а за криптовалютой начали охотиться тысячи людей со всего мира.

Слово «майнинг» (от англ. mining — добыча полезных ископаемых) в контексте финансов и информационных технологий добывается криптовалюта. Майнинг – это добыча цифровой валюты с помощью специального оборудования. Криптовалюта — разновидность цифровой валюты, учёт внутренних расчётных единиц которой обеспечивает децентрализованная платёжная система, работающая в полностью автоматическом режиме.

Таким образом, майнинг - инструмент добычи некой субстанции, которая не существует в реальной природе, однако стоит реальных денег. Всё дело в вычислительных мощностях. Криптовалюта - цена за вычисление (точнее за железо). Как только в мире появилась реальная цена за железку, на которой работает человек - появилась ферма по майнингу криптовалюты, а соответственно и денег "из воздуха". Многие люди, которые были далеки от науки, но близки к понятию "деньги" были в диком восторге от идеи и начали создавать фермы валют в каждом подъезде. Итог - дикий прирост биткоина (главной криптовалюты) в несколько раз (см. скриншот ниже).

Смысл технологии майнинговых ферм заключался в том, чтобы объединить несколько устройств и благодаря большому количеству мощных устройств добиться большой мощности. В то время, как компании создают одну и супермощную систему – квантовый компьютер. Если же объединить даже двадцатую часть мощностей носимой электроники, получится устройство (или система устройств) в разы, обгоняющая один квантовый компьютер.

О чём можно судить, заводя разговор про криптовалютный рынок? Вычислительные мощности необходимы для ряда техник в реальной жизни и бой за очередной капиталистический рынок (теперь под названием "Биткойн"). А что, если применить все эти вычисления не только в Биткойн, но и во все криптовалюты? А что, если объединять не специально созданные фермы, а просто все устройства? Последний iPhone 14 Pro Max мощнее любого компьютера 2007 года. А если их объединить?

WEB 3.0

Если объединить все устройства - получится WEB 3.0 или бессерверная архитектура Интернета, более известная как децентрализованная сеть (сеть без почти центра).

Основные концепции Web 3.0 обозначил руководитель компании Netscape Джейсон Калаканис (Jason Calacanis). Основной проблемой руководитель считает обесценивание ресурсов и сервисов: относительная простота создания сайтов повлияла на возникновение однообразия. Тим О’Райли поддержал в свое время идеи Калаканиса, а также отметил, что Web 3.0 должен выйти за рамки привычного понимания Сети и начать «взаимодействовать с физическим миром».

Концепция децентрализованного Интернета базируется на следующих идеях:

• Данные хранятся децентрализовано. Данные хранятся на всех устройствах частично, и никто не может прочитать данные друг друга, так как нет единого центра. Только ссылки друг на друга. Помимо этого - нет ценности красть ссылку, так как вашу можно также без проблем украсть. Отсутствует неравенство систем безопасности.Для примера возьмём две компании. Компания «Один» будет иметь кучу сложных и дорогостоящих устройств (Cisco ASA как межсетевой экран, новейшие маршрутизаторы и т.п.). Компания «Два» будет иметь один самый дешёвый роутер от провайдера. Понятно, что для взлома компании «Один» потребуется гораздо больше времени и сил, однако цена устройств разительно выше, в то время как компания «Два» - лёгкая «добыча». В случае, когда все компании (в том числе «Один» и «Два» работают в одной сети – безопасность будет на одном уровне и иерархии. Для одной компании технологии станут сильно дешевле, для другой – надёжнее.
• Наполнение контентом - дело человека. В отсутствии машинных сайтов, сайтов компании - нет разницы в цене и нет отличий в дизайне. Каждый пользователь создаёт свой уникальный контент, а это значит, что будет оплата не за дизайн сайта, а за работу (постоянную работу) дизайнера.В идеальном мире WEB 3.0 – сайты не необходимость, а желание и искусство. Как сейчас стало искусством – картины. Есть именитый художник, а есть начинающий, оба создают работы и оба продают их на условном аукционе и как итог – деньги и слава художнику, чья работа лучше.
• Открытая архитектура. Всё, что есть в Интернете не зашифровано, а значит открыто как для преступников, так и для правозащитников. Всё как в жизни.
• Модерацией контента будут заниматься сообщества. Правила сообщества - правила участия в нём и публикации в сети сообщества.Наглядный пример предыдущих двух пунктов – открытое общество с членством. Если вы живёте в городе – вы существуете и занимаетесь своими делами. Если вы захотите стать частью какого-то ни было клуба – придётся выполнить ряд его условий. При принадлежности к клубу – будет ряд условий, по которым вы сможете лишиться членства в клубе по внутренним правилам сообщества.

В сети можно найти список сайтов, децентрализованных приложений dApps и сервисов, которые устроены по принципу Web 3.0. Вот некоторые из них:

• Браузер Decenternet. Использует технологию блокчейна для создания бесшовной архитектуры. В нем есть встроенный VPN, он устраняет навязчивую рекламу, обеспечивает более высокую скорость просмотра и не отслеживает поведение пользователей в интернете.
• Маркетплейс Mysterium Network. Платформа peer-to-peer, где пользователи могут обмениваться данными. Платформа защищена от несанкционированного доступа, анонимная и зашифрованная, но с удобным интерфейсом для пользователя.
• Платформа Steemit. Аналог Reddit, где пользователи могут создавать аккаунты и обмениваться сообщениями. Ценный контент вознаграждается криптовалютой Steem.
• Платформа фрилансеров Atlas Work. Работодатели могут размещать на платформе разные задания и оплачивать их криптовалютой. Алгоритмы машинного обучения предлагают кандидатуры работодателей и исполнителей друг другу.
• Платформа для потокового видео DTube. Аналог YouTube: пользователи могут загружать на платформу свои видео. Платформа предлагает инструменты поощрения за загрузки и количество просмотров криптовалютой.
• Плеер Audius. Сервис позволяет артистам монетизировать музыку с помощью криптовалюты и общаться со своими слушателями.
• Платежный сервис Biconomy. Предлагает возможность оплаты несколькими криптовалютами, его можно интегрировать в свою систему с помощью API.
• Сервис конференций Huddle01. В нем реализована децентрализованная система видеозвонков — это помогает контролировать нагрузку и улучшает качество конференций.
• Браузер Brave. В браузер встроена технология быстрого просмотра и блокировки рекламы, есть интеграция с блокчейном и собственная криптовалюта BAT.
• Криптоприложение BitPay. Пользователи могут покупать, хранить, обменивать и тратить криптовалюту. Могут превратить биткоин в доллары и расплачиваться валютой с помощью криптовалютной дебетовой карты.

Для поддержки интернета будущего был создан специальный фонд и инструменты разработчика Web 3.0:

• Фонд поддержки Web 3.0. Он финансирует проекты, освещает и продвигает их в СМИ, предлагает консультации экспертов.
• Платформа для разработки Moralis. Большая часть проектов для блокчейна создана с помощью Moralis.
• Платформа для создания приложений Hardhat. Масштабируемая платформа, которая позволяет разработчикам создавать dApps c низкими комиссиями за транзакции без ущерба для безопасности.
• Платформа Polygon. Разные решения для работы с Etherium.
• Инструмент ConsenSys. Позволяет создавать децентрализованные приложения и инструменты для конечных пользователей.
• Инструмент KoineArth. Помогает преобразовывать физические продукты, материалы и документы в NFT, чтобы отслеживать их по всей цепочке поставок.

Необходимость WEB 3.0

Говоря о самой технологии WEB 3.0, технические специалисты начинают впадать в мир грёз о лучшем мире, однако обычным пользователям не понятно, с чем это связано. Связано это с концептуально иным подходом к технологиям. Если объяснить простыми словами, то WEB 3.0 – это технология (или набор технологий), к которому стремилось мировое IT-сообщество. А именно:

• Доступность Интернета. Входной билет в сеть – устройство с антенной или сетевой картой.
• Свобода слова. Свобода всего, так как не будет каких-либо регуляторных инструментов со стороны «крупных игроков» на рынке.
• Полная анонимность и защищённость. Нет разницы в цене устройств и в правилах настройки – тотальная анонимность.

(Не)возможность WEB 3.0

Данная концепция при всех плюсах, возможности продемонстрированной криптовалютой и выгодах для человечества на пути к мировым идеалам не поддерживается ни одной крупной компанией в мире. Поддержка компании чаще всего выражается в количестве инвестиций. Инвестиции должны приносить обратные инвестиции (откат), а при развитии WEB 3.0 компании потеряют статусность и необходимость и автоматически станут банкротами.

Обратная сторона медали - не противление идеям, так как многие IT-специалисты готовы работать с WEB 3.0, так как понимают ценность данный технологии для человека и человечества. Итог один - всё в наших руках.

• Главные файндеры IT профессий
• Карта IT
• Юзверь
• Эникейщик
• Сетевик
• ИБшник
• Хелпдеск
• Админ
• Юрист
• Аналитик
• Программисты
• И это всё?!
• Почему стоит слушать нас?

Доброго времени суток, прекрасные покорители гор знаний! Сегодня я пришёл с размышлениями о простом вопросе к себе - "Кто такой ITшник?". Вопрос кажется простым, пока не начинаешь его обсуждать. Собственно, я постараюсь начать отвечать на данный вопрос, а что вышло - сейчас расскажу. Милости прошу под кат!

Стоит начать с того, откуда взялся вопрос. Мне задала его жена. Она философ. Дело в том, что философы - такие люди, которые задают вопросы про все базовые понятия. Например: "Что такое любовь?", "В чём смысл смысла?", "Создатель и Бог - в чём принципиальное отличие?". В общем, люди интересующиеся миром. И вот как-то раз Настя спросила меня "Валер, а кем ты работаешь?". Я встал в ступор, услышав такой вопрос от жены. Когда я немного смутившись ответил на вопрос: "Айтишником...", Настя продолжила: "А кто это?". Собственно, с результатами я и пришёл.

Главные файндеры IT профессий

Ваш покорный слуга, которые вот уже 7 лет работает в IT сфере и где его (то есть меня) только черти не душили. От эникейщика до ген. директора компании, через инженера ИБ Cisco.

Моя любимая супруга. Человек, который обожает задавать вопросы, на которые сложно дать простые односложные ответы. Магистр философских наук в МГУ, автор ряда статей по этике и IT-этике.

Мы поставили себе задачу понять кто такой IT-специалист и выработать какую-то дорожную карту всех IT-шников.

Необходимо обсудить один момент. Каждый айтишник понимает чем он занимается и чем занимается его коллега, который скажет простую для него фразу: "Ну я на фулстеке с пыхой и явой сижу". Для обычного человека (даже понимающего английский, что уже не минимум) фраза будет звучать типа "Ну он полностью прокурен сигаретами "Ява"". И теперь становиться понятно, что человек вообще не от мира сего и делает он что-то нереальное. Когда же обычный человек переспросит чем же занимается его друг, он получит ответ типа "Ну сайты пишу"...

Карта IT

Чтобы упростить себе задачу рассказывания, а вам чтения, позвольте продемонстрировать условную карту, которую я позволил себе предположить. Она описывает моё виденье IT. Это не истина, но и не абсолютно далёкая от реальности картина. Схему можно читать сверху вниз и снизу вверх.

Итак, давайте расскажу как устроена схема. Я буду рассказывать про неё снизу вверх.

Юзверь

Есть обычный человек. Если он не пользуется технологиями он не очень интересен нам, так как мы IT-шники, то есть специалисты Information Technologies (И-информация, Т-технология), работаем с технологиями. Когда человек хочет узнать что-то новое, поработать с информацией и он пользуется каким-либо технологическим устройством, он приобретает статус - пользователь.

Пользователи ничего не понимают в IT. И не должны они только пользуются технологиями, которые мы им поставляем. Однако, есть пара оговорок, которые я хотел бы рассказать каждому пользователю, которые читает данную статью. Есть несколько основных пунктов:

1. Наши услуги стоят денег. Пользователи платят IT-шникам не за условное время потраченное на фрилансе (хотя и это тоже), а за своё знание. Знание мы получаем не с неба, и применить это большая проблема. Дети с начальной школы идут в программисты, и далеко не все "доходят" до конца обучения в институте. Одно ЕГЭ по информатике до сих пор считается одним из самых сложных (после обществознания).
2. Вы должны выполнять наши указания в системах в точности, как мы описали. Конечно, если хотите, чтобы система работала как надо. Пользователи же, которые не выполняют это условия сразу окрещаются IT-спецами как "юзверь" (от слова User - пользователь и зверь).

Почему я так резок? Сейчас поясню. Первый пункт пошёл от умозаключения: "Ну айтишник - куча бабла из воздуха". Во-первых, далеко не куча, во-вторых, не из воздуха. Давайте в цифрах.

Согласно данным Росстата, по итогам 2021 года средняя заработная плата в Москве составила 111 092 рубля. По промежуточным результатам 2022 года (январь — май) средняя зарплата в Москве составляет 116 354 рубля (источник). Понимаю, что данные очень расплывчаты и могут быть не точны, но тем не менее - чем не мерило? По данным сайта zarplan.com средняя зарплата по должности 'IT-инженер' составляет 109 857 рублей (источник) по Москве. Получается ниже средней. К слову, сам сайт имеет оговорку.

Как мы считали. Средние и медианные зарплаты рассчитаны на основе найденных свежих вакансий с указанной предлагаемой заработной платой. Таким образом, рассчитанные зарплаты характеризуют в большей степени предложение рынка труда (на основе вакансий), а НЕ реальные зарплаты, которые получают работники. Рассчитанные зарплаты имеют приблизительные значения.

Становится понятно, что всё не так однозначно.

На счёт юзверей и второго пункта. Мы, конечно, понимаем, что работаем с пользователями, которые не знают как пользоваться новейшими решениями и просим что-то запускать, а что-то не трогать, но юзверь - везде юзверь.

История из реальной практики, которая произошла со мной буквально 2 месяца назад. Меня попросили починить сайт на Битриксе. Сайт работал исправно, но часть функционала была ограничена. Я залез на сайт и понял, что проблема была связана со стилем, который съел этот функционал. Починил и попросил не трогать стилистическое оформление до демонстрации директору (разговаривал с заказчиком в лице маркетолога). Итог - чуть не сломали сайт играя со шрифтами и внося изменения в стиль. Вопрос: Зачем?!.

Юзверь - это не человек, это - состояние души. Когда слушать исполнителя - не важно. И когда можно потестить "как бы систему сломать" и маяться с кучей проблем.

Если говорить серьёзно, то пользователи в большинстве своём приятные люди, которые не являются диванными анархистами, а просто хотят получить качественный продукт. Соответственно, наша задача - им помочь.

Эникейщик

Первый помощник - это человек-швейцарский нож, более известный как эникейщик. Он способен сделать всё (от настройки ПК, до сборки сервера и написания сайтов). Одна оговорка. Он способен на всё, но плохо. Плохо не в том плане, что человек плохой работник, а в том плане, что он знает IT сферы поверхностно. Потом из эникейщика вырастает специалист в конкретной области, исходя из своих предпочтений.

Эникейщик самый младший специалист в нашей сфере, поэтому его не очень уважают, однако, он - очень важен, так как благодаря ему пользователи понимают что и как делать с созданной нами же системой. Но чаще всего, они завалены бумагой, деталями и работой в целом.

Сетевик

Самый частый рост эникейщика - это сетевой инженер. Это человек, который работает с передачей информации. Он занимается связкой сетей, их настройкой и общей коммутацией с новыми устройствами и новыми пользователями. Также его задача работать с подключениями всего и вся и настройкой интернета. Сайт он не пишет, он делает его доступным.

ИБшник

Специалист информационной безопасности. Этого человека также называют хакером. Он работает над технической защитой информации. Как с железом, так и с программами. Профессия своеобразная (к ней я себя причисляю уже давно). Своеобразие в том, что кто-то будет систему защищать, а кто-то прибегнет к древней мудрости: лучшая защита - это нападение, и станет хакером. Хакер - специалист по взлому систем. Ну а сериал про эту прекрасную профессию - Мистер Робот. В нём и расскажут как работает специалист по безопасности одной компании.

Хелпдеск

Человек помогающий пользователям уже удалённо и по конкретному вопросу. Грубо говоря эникейщик, но на своей системе. Он выше эникейщика за счёт того, что должен разбираться в конкретной системе и работе с ней. Им посвящён целый сериал - Компьютерщики (The IT Crowd).

Админ

Сетевой или системный администратор. Человек, занимающийся продумыванием крупных сетей и систем. Он является своего рода архитектором сетей/систем. Если вы являетесь бизнесменом, то ваш прямой путь - к нему. Он поможет и расскажет, что и как делать на старте, рассчитает и расскажет, как сетевику собрать, что он придумал. К слову, про него есть отдельная бесплатная статья в журнале Xakep от вашего покорного слуги.

Юрист

IT-юрист, это как обычный юрист, но в сфере IT. Про него все очень часто забывают, но он пусть и не является ITшником, но ни одна крупная IT-компания не может обойтись без него. Вспомните сериал "Кремниевая долина" и вам всё станет понятно.

Аналитик

Бизнес-аналитик в IT - очень нудная нужная вещь, так как аналитики занимаются сбором требований от заказчика и передачей этих требований техническим специалистам. Звучит просто, но на деле человек должен понимать и сторону IT, и сторону бизнеса. К слову, есть очень крутой подкаст о том, кто такие аналитики в айти и как ими стать.

Программисты

Если первый уровень карты я рассказал, то на втором появился мифический объект - программист. Я ни в коем случае не хочу сказать, что программисты лучше остальных ITшников. Нет. Они просто другие. Большинство программистов получили статус "Не от мира сего" и не просто так.

Во-первых, они учат кучу языков программирования. Не один десяток лет.

Во-вторых, они чаще других имеют свой язык общения и не только относительно пользователей, но и относительно друг друга.

В-третьих, программисты работают ближе к информации и дальше от пользователей, а из это вытекает четвёртое и самое главное.

Программисты способны создать что-то уникальное. Это не значит, что условный сетевик не может. Каждый человек способен совершить открытие, однако кто-то работает в располагающей для этого среде, а кто-то - нет.

Яркий пример такого расположение - программисты. Они все знают опыт предыдущих поколений, а также умеют создавать что-то новое и ключевой навык - создание. Их также называют разрабами (Deus Devs). У них есть своя внутренняя философия и взгляд на жизнь и себя в ней.

И это всё?!

Нет. Далеко не всё. Каждый из перечисленных мной IT-спецов имеют свои собственные разделения и точки роста. Программисты могут знать много языков и разбираться в сетях или вообще уйти в лидов и админов, сетевики часть переходят в белый хакинг, а затем и в чёрный минуя серый, ИБшники могут стать крутыми разрабами нового защитного ПО.

Очень сложно (я бы сказал невозможно), описать каждого специалиста в одной статье, да и читать это будет очень не просто. Поэтому мы запустили свой подкаст. Лежачий подкаст.

В нём мы и будем рассказывать более детально про каждого разработчика и я, уважаемые читатели хабра, прошу вас об услуге. Если среди вас есть специалист, который готов поделиться с нами своим опытом в подкасте, пожалуйста, свяжитесь со мной через Хабр. Расскажите свою историю всему миру!

Почему стоит слушать нас?

К сожалению, простому человеку сложно понять, кто такой айтишник, однако мы сами, отвечая на вопрос "кем ты работаешь?" чаще всего отвечаем "айтишником", потому что объяснить всё, что ты делаешь - довольно проблематично. Тут и возникает проблема - айтишник становится мифическим существом. Тем не менее, программист и сетевик - совершенно разные профессии (что было для моей жены открытием). Поэтому хотим простым языком объяснить тем, кто хочет разобраться, кто мы такие и почему не все айтишники умеют писать сайты, ставить винду и чинить принтер

Я знаю, что есть куча подкастов от разных площадок IT-обучалок. Я сам работаю в ряде из них, поэтому мы и хотели бы работать с вами без рекламы, без "красивых" историй с хеппи-эндом, без цензуры и без проплаченного мнения. Как думаете, получится?

У меня на этом всё! Поздравляю всех наступающим новым 2023 годом и надеюсь в новом году мы сможем плодотворно посотрудничать!

P.S. Статья была написана не с целью рекламы, а с целью привлечения внимания к проблеме недопонимания IT-профессионалов с рядовыми пользователями. Надеюсь, у меня получилось!

• Быстрый перевод из системы в систему
• Задача 2
• Задача 5
• Задача 6
• Задача 12
• Задача 14
• Задача 16
• Задача 17
• Задача 19, 20 и 21
• Задача 22

В сегодняшней статье поговорим о насущной для многих выпускников школ теме - ЕГЭ. Да-да-да! Ребят опять посадили на дистант. Пока не ясно на какой период, но уже сейчас можно сказать, что ЕГЭ по информатике будет на компьютерах и его можно зарешать при помощи языка Python.

Вот я и подумал, чтобы не получилось как в песне, стоит этим заняться. Я расскажу про все задачи первой части и их решения на примере демо варианта ЕГЭ за октябрь.

Всех желающих - приглашаю ниже!

Быстрый перевод из системы в систему

В Python есть интересные функции bin(), oct() и hex(). Работают данные функции очень просто:

bin(156) #Выводит '0b10011100'
oct(156) #Выводит '0o234'
hex(156) #Выводит '0x9c'

Как вы видите, выводится строка, где 0b - означает, что число далее в двоичной системе счисления, 0o - в восьмеричной, а 0x - в шестнадцатеричной. Но это стандартные системы, а есть и необычные...

Давайте посмотрим и на них:

n = int(input()) #Вводим целое число
 
b = '' #Формируем пустую строку
 
while n > 0: #Пока число не ноль
    b = str(n % 2) + b #Остатот от деления нужной системы (в нашем сл записываем слева
    n = n // 2 #Целочисленное деление
 
print(b) #Вывод

Данная программа будет работать при переводе из десятичной системы счисления в любую до 9, так как у нас нет букв. Давайте добавим буквы:

n = int(input()) #Вводим целое число

b = '' #Формируем пустую строку

while n > 0: #Пока число не ноль
    if (n % 21) > 9: #Если остаток от деления больше 9...
        if n % 21 == 10: #... и равен 10...
            b = 'A' + b #... запишем слева A
        elif n % 21 == 11:#... и равен 11...
            b = 'B' + b#... запишем слева B

'''

И так далее, пока не дойдём до системы счисления -1 (я переводил в 21-ную систему и шёл до 20)

'''

        elif n % 21 == 11:
            b = 'B' + b
        elif n % 21 == 12:
            b = 'C' + b
        elif n % 21 == 13:
            b = 'D' + b
        elif n % 21 == 14:
            b = 'E' + b
        elif n % 21 == 15:
            b = 'F' + b
        elif n % 21 == 16:
            b = 'G' + b
        elif n % 21 == 17:
            b = 'H' + b
        elif n % 21 == 18:
            b = 'I' + b
        elif n % 21 == 19:
            b = 'J' + b
        elif n % 21 == 20:
            b = 'K' + b
    else: #Иначе (остаток меньше 10)
        b = str(n % 21) + b #Остатот от деления записываем слева
    n = n // 21 #Целочисленное деление

print(b) #Вывод

Способ объёмен, но понятен. Теперь давайте используем тот же функцию перевода из любой системы счисления в любую:

def convert_base(num, to_base=10, from_base=10):
    # Перевод в десятичную систему
    if isinstance(num, str): # Если число - строка, то ...
        n = int(num, from_base) # ... переводим его в нужную систему счисления
    else: # Если же ввели число, то ...
        n = int(num) # ... просто воспринять его как число
    # Перевод десятичной в 'to_base' систему
    alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ" # Берём алфавит
    if n < to_base: # Если число меньше системы счисления в которую переводить...
        return alphabet[n] # ... вернуть значения номера в алфавите (остаток от деления)
    else: # Иначе...
        return convert_base(n // to_base, to_base) + alphabet[n % to_base] # ... рекурсивно обратиться к функии нахождения остатка

Вызвав функцию вывода print(convert_base(156, 16, 10)) мы переведём 156 из 10 в 16 систему счисления, а введя print(convert_base('23', 21, 4)) переведёт 23 из 4-ичной в 21-ичную систему (ответ: B).

Задача 2

Все задания беру из первого октябрьского варианта (он же вариант № 9325894) с сайта Решу.ЕГЭ.

Решение данной задачи совсем простое: банальный перебор.

print('y', 'x', 'z', 'F') #Напечатаем заголовки таблицы
for y in range(2): #Берём все переменные и меняем их в циклах '0' и '1'
    for x in range(2):
        for z in range(2):
            for w in range(2):
                F = ((not x or y) == (not z or w)) or (x and w) #Записываем функцию
                print(x, y, z, F) #Выводим результат

Результат:

Нам вывелась вся таблица истинности (1 = True, 0 = False). Но это не очень удобно. Обратите внимание, что в задании, функция равно 0, так и давайте подправим код:

print('y', 'x', 'z', 'F') #Напечатаем заголовки таблицы
for y in range(2): #Берём все переменные и меняем их в циклах '0' и '1'
    for x in range(2):
        for z in range(2):
            for w in range(2):
                F = ((not x or y) == (not z or w)) or (x and w) #Записываем функцию
                if not F:
                    print(x, y, z, F) #Выводим результат

Результат:

Далее - простой анализ.

Задача 5

Данная задача легко решается простой последовательностью действий в интерпретационном режиме:

Задача 6

Перепечатали и получили ответ:

s = 0
k = 1
while s < 66:
    k += 3
    s += k
print(k)

Задача 12

В очередной раз, просто заменим слова на код:

a = '9' * 1000

while '999' in a or '888' in a:
    if '888' in a:
        a = a.replace('888', '9', 1)
    else:
        a = a.replace('999', '8', 1)
print(a)

Задача 14

Компьютер железный, он всё посчитает:

a = 4 ** 2020 + 2 ** 2017 - 15
k = 0

while a > 0:
    if a % 2 == 1:
      	k += 1
    a = a // 2
 
print(k)

Задача 16

Опять же, просто дублируем программу в python:

def F(n):
    if n > 0:
        F(n // 4)
        print(n)
        F (n - 1)
print(F(5))

Результат:

Задача 17

Задача с файлом. Самое сложное - достать данные из файла. Но где наша не пропадала?!

with open("17.txt", "r") as f: #Открыли файл 17.txt для чтения
    text = f.read() #В переменную text запихнули строку целиком
a = text.split("\n") #Разбили строку энтерами (\n - знак перехода на новую строку)

k = 0 #Стандартно обнуляем количество
m = -20001 #Так как у нас сумма 2-ух чисел и минимальное равно -10000, то минимум по условию равен -20000, поэтому...

for i in range(len(a)): #Обходим все элементы массива
    if (int(a[i - 1]) % 3 == 0) or (int(a[i]) % 3 == 0): #Условное условие
        k += 1 #Счётчик
        if int(a[i - 1]) + int(a[i]) > m: #Нахождение минимума
            m = int(a[i - 1]) + int(a[i])

print(k, m) #Вывод

Немного пояснений. Функция with() открывает файл считывает данные при помощи функции read() и закрывает файл. В остальном - задача стандартна.

Задача 19, 20 и 21

Все три задачи - задачи на рекурсию. Задачи идентичны, а вопросы разные. Итак, первая задача:

Пишем рекурсивную функцию и цикл перебора S:

def f(x, y, p): #Рекурсивная функция
    if x + y >= 69 or p > 3: #Условия завершения игры
        return p == 3
    return f(x + 1, y, p + 1) or f(x, y + 1, p + 1) or\
           f(x * 2, y, p + 1) or f(x, y * 3, p + 1) #Варианты действий

for s in range (1, 58 + 1): #Перебор S
    if f(10, s, 1): #Начали с 10 камней
        print(s)
        break

Немного пояснений. В рекурсивной функции существует 3 переменные x - число камней в первой куче, y - число камней во второй куче, p - позиция. Позиция рассчитывается по таблице:

Далее - всё по условию задачи.

Вторая задача на теорию игр:

Все отличия в рамке. Ну и код, соответственно, не сильно отличается:

def f(x, y, p): #Рекурсивная функция
    if x + y >= 69 or p > 4: #Условия завершения игры
        return p == 4
    if p % 2 != 0:
        return f(x + 1, y, p + 1) or f(x, y + 1, p + 1) or\
               f(x * 2, y, p + 1) or f(x, y * 3, p + 1) #Варианты действий
    else:
        return f(x + 1, y, p + 1) and f(x, y + 1, p + 1) and\
               f(x * 2, y, p + 1) and f(x, y * 3, p + 1) #Варианты действий


for s in range (1, 58 + 1): #Перебор S
    if f(10, s, 1): #Начали с 10 камней
        print(s)

Отличия:

1. Выиграл Петя, соответственно, позиция 4
2. Так как Петя не может выиграть за один ход - он выигрывает за 2 хода (and, а не or на нечётных позициях (играх Пети))
3. Убрали break, так как нам нужны все S, а не единственный

Последняя вариация задачи:

Сразу код:

def f(x, y, p): #Рекурсивная функция
    if x + y >= 69 or p > 5: #Условия завершения игры
        return p == 3 or p == 5
    if p % 2 == 0:
        return f(x + 1, y, p + 1) or f(x, y + 1, p + 1) or\
               f(x * 2, y, p + 1) or f(x, y * 3, p + 1) #Варианты действий
    else:
        return f(x + 1, y, p + 1) and f(x, y + 1, p + 1) and\
               f(x * 2, y, p + 1) and f(x, y * 3, p + 1) #Варианты действий


for s in range (1, 58 + 1): #Перебор S
    if f(10, s, 1): #Начали с 10 камней
        print(s)

Ну и всего лишь 2 отличия:

1. Позиции 3 или 5, а не 4, так как выиграл Ваня
2. На второй ход выигрывает Ваня и нам нужно or и and поменять. Я заменил только кратность 2.

Задача 22

Ctrl+C, Ctrl+V - наше всё! :)

for i in range(1, 100000):
    x = i
    L = 0
    M = 0
    while x > 0 :
        L = L+1
        if (x % 2) != 0:
            M = M + x % 8
        x = x // 8
    if L == 3 and M == 6:
        print(i)

Итак, код:

def f(x, y):
    if x > y: #Перегнали цель
        return 0
    if x == y:  #Догнали цель
        return 1
    if x < y: #Догоняем цель тремя методами
        return f(x + 1, y) + f(x + 2, y) + f(x * 2, y)

print(f(3, 10) * f(10, 12)) #Прошло через 10, значит догнали 10 и от де догоняем 12

Так как в условии задачи мы увеличиваем число, но будем числа "догонять". Три метода описаны, ну а пройти через 10 - значит дойти до него и идти от него.

Собственно, это и есть вся первая часть ЕГЭ по информатике решённая на Python.

Ссылка на репозиторий со всеми программами.

Надеюсь, что смог помочь в своей статье выпускникам и готовящимся ;)

Остался один вопрос - нужен ли разбор второй части ЕГЭ по информатике на Python? Оставлю этот вопрос на ваше голосование.

Всем удачи!

Оглавление

• Зачем изучать блочную модель CSS?
• Структура блочной модели CSS
• Свойство Padding
• Свойство Border
• Свойство Margin
• Свойство box-sizing
• Content-box VS Border-box

Зачем изучать блочную модель CSS?

Блочная модель CSS состоит из свойств: box-sizing, padding и margin. Если их не использовать, то получим что-то похожее ​

Но если вы будете правильно использовать свойства блочной модели, ваш сайт будет выглядеть так ​

Выглядит гораздо более привлекательно, не так ли? Если вы хотите создать свой сайт с точными расчетами, как тот, что указан выше​, то вы попали по адресу. Изучение блочной модели CSS - один из многих способов, которые помогут вам сделать веб-сайты, идеальные до пикселя.

В этой статье мы поговорим о том, как использовать эти свойства:

• Padding
• Margin
• Border
• box-sizing

Как использовать свойства блочной модели CSS

Давайте посмотрим на несколько примеров, где мы можем использовать свойства блочной модели CSS. Мы собираемся проанализировать сайт, показанный выше. ​

Давайте внимательнее посмотрим на навигационную панель (navbar). Вы можете заметить разницу между примером, в котором используется свойство padding, и примером, в котором его нет:

Теперь давайте подробнее рассмотрим раздел содержимого вместе с кнопками. Опять же, вы заметите разницу - на правой картинке также используется свойство padding.

Структура блочной модели CSS

Говоря о блочной модели, стоит воспринимать её как луковицу. И эта "луковица" имеет 4 слоя:

• 1 слой: Content
• 2 слой: Padding
• 3 слой: Border
• 4 слой: Margin

1 слой блочной модели: Content

В HTML все ведет себя как ящик с контентом. Давайте вставим контент с изображением котенка. ​

2 слой блочной модели: Padding

Следующий слой блочной модели CSS - это слой заполнения. Он обертывает наш контент следующим образом ​

3 слой блочной модели: Border

Следующий слой блочной модели CSS - это пограничный слой. Он обертывает наш контент + отступы следующим образом ​

4 слой блочной модели: Margin

Следующим и последним слоем блочной модели CSS является слой полей. Он обертывает наш контент + отступ + границу следующим образом ​

Итак, давайте посмотрим, как эти свойства работают в проекте.

Как настроить проект

Это руководство подходит для всех, в том числе для новичков. Если вы хотите писать код, выполните следующие действия.

HTML

Откройте VS Code или Codepen.io и напишите этот код ​ внутри тега body:

<div class="box-1"> Box-1 </div>

CSS

Очистите стили нашего браузера по умолчанию ​

* {
  margin: 0px;
  padding: 0px;
  font-family: sans-serif;
}

Теперь давайте стилизуем наш блок ​

.box-1 {
  width: 300px;
  background-color: skyblue;
  font-size: 50px;
}Все готово, приступим к программированию! ​

Свойство Padding

Но сначала давайте обсудим практическое использование свойства padding. Затем мы увидим, как использовать это свойство.

Обычно я использую отступы, чтобы оставить пространство между содержимым. Посмотрите на эту навигационную панель ​

Вот вам еще один пример - посмотрите на содержимое ниже с двумя кнопками​

Как использовать свойство padding в CSS

Ниже представлены названия четырех свойств заполнения:

• padding-top
• padding-right
• padding-bottom
• padding-left

И помните, что отступы - это пространство, которое вы добавляете поверх основного контента:

Давайте добавим отступы к нашему контенту. Область красного цвета - это отступ ​

Чтобы воссоздать результаты, указанные выше, ​ напишите этот код в свой CSS: ​

// Padding added on top, right, left, bottom of .box-1

.box-1{
   padding : 100px;
}

Откроем консоль разработчика и перейдем в вычисляемый раздел:

В самом центре - контент, который 300px в ширину. Посмотрите, вокруг контента мы добавили отступы по 100 пикселей.

Давайте попробуем добавить отступ только к одной стороне нашего контента (только с правой стороны):

Чтобы воссоздать результаты, указанные выше, ​ напишите этот код в свой CSS: ​

.box-1{
   padding: 0 100px 0 0;
}

// Or you can use ​
.box-1{
   padding-right: 100px;
}

Теперь откройте вычисляемый раздел в консоли разработчика ​

Посмотрите - отступ в 100 пикселей был добавлен только с правой стороны нашего контента, как мы указали.

Свойство Border

Обычно вы будете использовать свойство border при создании кнопок. Вот демонстрация GIF ​

Обратите внимание, как появляется белая рамка вокруг кнопки, когда наводится указатель мыши на кнопку.

Как использовать свойство границы в CSS

И помните, граница - это пространство, добавленное поверх нашего контента + отступа: ​

Есть три важных параметра свойства границы:

• border size
• border style: solid (сплошная линия) / dotted ("точечная" линия) / dashed (пунктир)
• border color

Как я перечислил выше, существует три стиля свойства границы. В этом примере мы будем использовать пунктирный стиль:

Чтобы воссоздать приведенные выше результаты, напишите этот код в своем CSS: ​

.box-1 {
  width: 300px;
  font-size: 50px;
  padding: 50px;
  border: 10px dashed black;
}

Откроем консоль и посмотрим расчеты блочной модели:

Теперь посмотрите на изображение выше​ - вокруг нашего контента + отступа добавлена ​​граница 10 пикселей.

Свойство Margin

Обычно я использую свойство margin, чтобы добавить отступ между моим контентом и экраном на макете рабочего стола. Посмотрите на эту гифку:

Обратите внимание, что я добавил поля к левому и правому краям веб-сайта выше ​

Вот еще один пример использования свойства margin: ​

Как использовать свойство margin в CSS

Margin имеет всего четыре свойства поля:

• margin-top
• margin-right
• margin-bottom
• margin-left

И помните, margin - это пространство, добавленное поверх нашего контента + отступы (по padding) + границы:

Давайте добавим отступ к нашему контенту. Весь наш набор смещается из-за margin,как в этом GIF: ​

Чтобы воссоздать приведенные выше результаты, напишите этот код в своем CSS: ​

.box-1 {
  padding: 50px;
  border: 10px dashed black;
  
  margin: 50px;
}

Можем еще раз проверить расчеты: ​

Посмотрите, вокруг нашего контента + отступов + границы было добавлено поле 50 пикселей .

Давайте попробуем добавить поле только к одной стороне нашего контента (только левой стороне):

Чтобы воссоздать результаты выше, напишите этот код в своем CSS ​

.box-1 {
  padding: 50px;
  border: 10px dashed black;
  margin-left: 50px;
}

На консоли мы видим, что поле в 50 пикселей применено только к левой стороне ​

Свойство box-sizing

Это свойство определяет, как будут рассчитываться поля, отступы и границы. Есть три типа вычислений (можно называть их свойствами):

• border-box
• padding-box
• content-box

Примечание:

Мы не будем обсуждать padding-box, поскольку его поддерживает только Firefox, и он используется не очень часто.

В чем разница между content-box и border-box в CSS?

И border-box, и content-box работают одинаково. Посмотрите на эти изображения: ​

Итак, в чем здесь главное отличие? Разница заметна, когда мы добавляем поля, границу или отступы к нашим блокам.

Когда мы используем box-sizing: content-box, который является значением по умолчанию, он добавит поля, отступы и границы за пределами поля, например: ​

Вы также можете увидеть расчеты здесь: ​

Это означает, что все может выйти из-под контроля, и вы можете получить неожиданный результат. Это означает, что при таком подходе, будет сложно создавать адаптивные веб-сайты. Вместо этого всегда используйте свойство box-sizing: border-box.

Но когда мы используем свойство box-sizing: border-box, оно добавит поля, отступы и границы вовнутрь блока, например: ​

В box-sizing: border-box абсолютно точные расчеты HTML - элементов, а это значит, что такой способ является идеальным для создания адаптивных веб-сайтов.

Вы также можете поэкспериментировать со значениями - просто используйте этот код: ​

* {
  box-sizing: border-box;
}

/* Or, Write ​ */
* {
  box-sizing: content-box;
}

Заключение

Вот собственно и всё. Для желающих оставлю ссылку на видео-инструкцию к данному уроку от автора (Джоя Шахеба):