Как создать игру на java для компьютера
Обновлено: 04.07.2024
Java — это не только язык, это целая экосистема, включающая в себя средства разработки, платформу для запуска готовых приложений, огромный свод документации и активное сообщество. Одним из преимуществ Java на начальном этапе была кросс-платформенность (принцип — «написано один раз — запускается везде»).
Дело в том, что программа на Java исполняется не на прямую процессором компьютера, а виртуальной машиной Java (JVM). Это позволяет абстрагироваться от многих нюансов конкретных платформ. Программу, написанную на Java, можно без изменений кода запускать на Windows, Linux, MacOS и других операционных системах (если, конечно, программа не использует специфичные для ОС функции).
Кто застал начало 2000х, наверное помнит огромное количество мобильных телефонов (тогда еще они не были смартфонами), на каждом телефоне была по сути своя маленькая ОС, но при этом почти на каждом можно было запустить Java игру или приложение.
На сегодняшний день Java по-прежнему входит в топ языков для изучения, а Java как платформа — в топ используемых технологий в мире IT и смежных областях.
Сегодня мы начнем изучать Java, причем сразу с примера игры «Крестики-нолики».
Итак, поехали. Надеюсь как установить java SDK ты уже разобрался. Мы будем писать код в IDE IntelliJ IDEA, но если у вас какая-то другая, например Eclipse, то разницы большой не будет.
Итак, создаем новый проект: нажимаем «create new project», выбираем java и щелкаем «next» до окна, где требуется ввести имя проекта, вводим TicTacToe (крестики-нолики). В некоторых случаях на этапе создания потребуется выбрать шаблон проекта, тогда смело выбирай что-либо похожее на JavaConsoleApplication.
После этого нажимаем «Finish». Idea немного подумает и сгенерирует нам проект с классом Main, в котором определена функция main().
Внутри нашего класса Main описана функция main(), в Java с этой функции начинается исполнение программы, это точка входа в наше приложение. Сейчас там написан только автоматический комментарий (комментарии в Java начинаются с двух символов //). Попробуем кое-что добавить в наш код и проверить работоспособность приложения. Внутри функции main() допишем две строки:
Встроенная функция println() просто выводит на экран текстовую информацию. Запустим наше приложение (нажимаем shift-F10 или зеленый треугольник). Внизу, во вкладке run появится вывод нашей программы:
Функция main() отработала и закончилась, вместе с ней закончилась наша программа.
В игре пользователю конечно захочется взаимодействовать с программой более продвинутым способом, поэтому нам понадобится окно. Набираем внутри функции main() следующие строки:
Смысл большинства строк понятен из комментариев к ним, отдельно отмечу строку window.setLayout() — здесь устанавливается менеджер расположения, который будет применяется к компонентам, добавляемым в наше окно. Менеджер BorderLayout может располагать новые компоненты относительно сторон света (North(верх), West(слева), East(справа), South(низ)), Center (центр)). По умолчанию он располагает компоненты по центру. Подробнее с менеджерами расположения можно познакомиться в документации.
Теперь, если запустить нашу программу, мы увидим окно:
Пока в этом окне ничего нет. Создадим свой компонент, который и будет отрисовывать графику игры.
И в появившемся меню выбираем пункт «New» → «Java Class». В окне создания класса набираем его имя «TicTacToe» и нажимаем «Enter».
У нас в проекте появился еще один класс. В главное окно можно добавлять только объекты класса JComponent, кроме того, нам нужна область для рисования. Поэтому наследуем наш класс TicTacToe от JComponent. Ой сколько непонятных слов! Сейчас постараюсь пояснить.
Наследование классов — это как создание уточненного шаблона на базе существующего. Например, есть класс Стол, описывающий идею стола вообще. Но нам очень часто приходится создавать столы на четырех ногах с деревянной столешницей, поэтому для удобства мы можем уточнить идею класса Стол и создать шаблон ДеревянныйСтол — он будет иметь все те же основные свойства, что и родительская идея, но зато часть свойств у него уже определены и понятны — это число ног, равное четырем и материал столешницы — дерево.
С JComponent то же самое — данный класс реализует идею некоторого графического компонента пользовательского интерфейса. Такой компонент можно добавить в окно и он умеет как-то себя отрисовывать. Например, класс JButton — наследник класса JComponent, это компонент, который выглядит, как кнопка и умеет показывать анимацию клика мышкой.
Здесь же, наследуя класс JComponent, мы создадим свой компонент, в котором сможем рисовать то, что нам нужно.
Привет хаброжители. Данный пост является «рерайтом» моего поста для песочницы. На этот раз я постараюсь охватить больше тем, чем тогда.
Почему Java?
Ничего объективного я тут не скажу, а скажу лишь то, что я люблю этот язык, и мне нравиться писать на нем. Да, на Java нет игр AAA-класса, но Java предоставляет огромные возможности, больше кол-во встроенных средств и быстроту написания кода.
Начнем с выбора IDE. Я являюсь фанатом Eclipse и посоветую вам его.
Если же почему-то вам он не понравился, вы можете использовать NetBeans, Intellij IDEA или командную строку и ваш любимый редактор.
И скачаем JDK последней версии: JDK 7u4
Скорее всего проблем с установкой IDE у вас не возникнет, а если у вас 64-битная система, все же посоветую устанавливать 32-битный Eclipse, так как иногда бывают ошибки и Eclipse у вас просто не запустится.
Под катом мы приступим к созданию игры.
Класс Game
Итак, создаем проект, в нем класс Game(попутно создав в нем точку входа). Данный класс должен наследовать класс Canvas и реализовать интерфейс Runnable:
Создадим переменную running типа Boolean, которая, как вы уже догадались будет показывать нам запущена ли игра, или нет.
Создадим функцию start() и в ней мы будем создавать новый поток и переводить running в true:
Создадим три функции — update(long delta), render() и init(). Я надеюсь что их значение вам понятно. В функции run() создадим главный игровой цикл, перед ним будем вызывать init(), а в нем самом render() и update(). Так же мы будем вычислять разницу между кадрами(delta time).
Пока поработаем над функцией render().
Вам наверное уже не терпится запустить и попробовать, но не спешите. Мы должны создать фрейм и добавить наш холст на него. Заодно и объявим три переменных.
Примерно вот так выглядит наш класс Game сейчас.
Класс Sprite
Создадим новый класс Sprite. Поскольку этот класс небольшой, я сразу приведу весь его код с комментариями:
Сразу же проверим работоспособность. Возьмем эту картинку и скопируем ее в папку с нашим классом Sprite. Добавим функцию getSprite() в класс Game(временно).
Добавим нашу картинку в папку assets(папку создать в корне проекта), саму папку надо добавить в build path.
Далее создаем переменную hero типа Sprite. В функции init() инициализируем ее. В Функции render() рисуем:
Input
Для обработки инпута мы создадим класс, наследующий KeyAdapter:
Тут же и объявим две переменных в шапке класса Game:
Внутри класса KeyInputHandler создадим две функции:
Теперь в функции init() добавим следующее:
Создадим переменные x и y для героя(так как пока что мы еще не написали класс Entity). Сделаем чтобы герой всегда рисовался на этих координатах.
А теперь в функции update() будем проверять нажаты ли клавиши и изменять x-координату.
Эта статья рассчитана на новичков в программировании. Её цель — объяснить азы языка Java (классы, методы, компиляция, байт-код, JVM, переменные, условия, циклы, импорт). Этот материал поможет:
- научиться писать код, компилировать и запускать байт-код;
- познакомиться с переменными;
- узнать об условных операторах и циклах;
- освоить использование классов из стандартных пакетов;
- написать простую консольную игру «Угадай число».
Java Development Kit (JDK)
Счастливым обладателям Windows потребуется также настройка системных переменных. Как их найти: Панель управления → Система → Дополнительные параметры системы → Вкладка «Дополнительно» → кнопка «Переменные среды», второе окошко сверху. В нем надо создать переменную JAVA_HOME и изменить (дополнить) Path (для этого используются кнопки «Создать» и «Изменить». Значение для переменной JAVA_HOME содержит путь к папке JDK. Переменную Path дополняем значением %JAVA_HOME%\bin. Обратите внимание, что список путей разделяется точкой с запятой (;). Инструкция есть также на сайте Oracle.
JDK содержит много утилит, но нам потребуется только компилятор (javac) и виртуальная машина Java — JVM (java).
Проверить правильность установки и настройки можно в командной строке (на Windows: Win + R → cmd) или в терминале (Linux, Mac), набрав следующие команды:
В качестве альтернативы можно использовать онлайн-JDK вместе с редактором, например на сайте Repl.it.
Написание кода
Писать исходный код можно в любом текстовом редакторе. А компиляцию и запуск проводить в командной строке (терминале). Но удобнее будет работать в редакторе с подсветкой синтаксиса и плагином, автоматизирующим компиляцию и запуск.
Для Windows хорошим выбором будет Notepad++ с плагином NppExec. Для Linux и Мас существуют другие текстовые редакторы, например Atom или Geany. Подробно об их настройке можно прочитать в статье «Пишем код на Java и Go в текстовом редакторе».
Hello, world!
При изучении нового языка писать программу, выводящую «Hello, world!», — это традиция. Она возникла в 1978 году, с выходом в свет книги «Язык программирования С» Брайана Кернигана и Денниса Ричи.
Код начинается с ключевого слова class. Java-программы состоят из классов — это «кирпичики» приложения. В реальных приложениях их могут быть десятки, сотни и тысячи. Затем пишется имя класса — HelloWorld. Имена классов принято писать в стиле CamelCase (все слова слитно, каждое с заглавной буквы). Классам, как и другим сущностям — методам, полям и переменным — рекомендуется давать мнемонические, «говорящие» имена.
После имени в фигурных скобках записывается тело класса. Оно может содержать поля, методы и другие классы. Поля хранят данные. Они подобны переменным, однако в Java это несколько иная сущность. Методы содержат набор команд или код. Имена методов (как и полей, переменных) принято писать в стиле camelCase, со строчной буквы.
Наш метод main() содержит лишь одну строку, которая выводит в консоль текст "Hello, world!".
Перед компиляцией сохраняем написанный код в файл. Имя файла должно соответствовать имени класса с точностью до регистра символов (Java — регистрозависимый язык). Затем открываем командную строку (или терминал) и вызываем сначала компилятор (javac), а потом виртуальную машину JVM (java).
После компиляции возникнет бинарный файл HelloWorld.class, содержащий байт-код. Имя этого файла (без расширения) передаётся как параметр при вызове виртуальной машины. В результате видим строку «Hello, world!» — это результат выполнения программы.
Переменные
Переменные хранят данные (числа, строки, логические значения и другие). Они похожи на коробочки: надписи на них — это имя и тип переменной, а внутри находится значение. При этом возможны две операции:
- запись значения в переменную (или присвоение значения);
- чтение значения из переменной.
В Java перед использованием переменную нужно обязательно объявить, указав тип и имя, поскольку Java — язык со строгой и статической типизацией. Попытка использовать переменную без объявления приведёт к ошибке компиляции. По типу переменные могут быть простыми (числа, символы, логические значения) или ссылочными (массивы, строки, любые другие объекты). В Java есть восемь простых типов (byte, int, short, long, float, double, boolean, char) и бесконечное количество ссылочных.
В примере ниже мы видим объявление двух переменных целого типа (int). Причём переменная second инициируется при объявлении. Затем переменной first присваивается результат выражения, в котором присутствует переменная second. В результате выполнения программы в консоль будут выведены значения обеих переменных: 35 и 10.
Имя переменной может содержать буквы и цифры, знак подчёркивания и $. Имя не должно начинаться с цифры. В профессиональной разработке в именах переменных используют только буквы. Имя должно явно указывать на назначение переменной. Например: countString — счётчик строк, errorSign — признак ошибки. Рекомендуется избегать однобуквенных имён — за исключением временных переменных (существующих в рамках цикла или небольшого кодового блока).
Проверка условий
Любой язык программирования высокого уровня позволяет изменять порядок выполнения программы в зависимости от заданного условия. В Java для этого используется конструкция if. После этого ключевого слова в скобках записывается логическое выражение, затем в фигурных скобках — группа команд. Если результат логического выражения — true (истина), то эта группа команд выполняется, если false (ложь) — нет.
Результат этого примера — строка “i = 10” в консоли, так как результат логического выражения (проверка на равенство) будет true.
В качестве знаков сравнения допустимы: <, <=, >, >=, ==, !=. Добавив ключевое слово else, получаем полную форму оператора сравнения.
Циклы
Циклы предназначены для повторения группы команд. Java позволяет использовать два вида циклов:
- с определённым количеством итераций: for;
- без определенного количества итераций: while и do-while.
Запустив этот пример, мы увидим в консоли колонку чисел от 0 до 4. Это результат работы классического цикла for со счётчиком. В круглых скобках три параметра цикла, разделённые точкой с запятой: объявление и инициализация счётчика, проверка условия продолжения цикла, действие после каждой итерации. В фигурных скобках — тело цикла. В нашем случае это команда, выводящая значение счётчика i в консоль.
Когда будем писать игру, используем циклы while и do-while — там и увидим их работу на практике. Пока достаточно сказать, что их синтаксис проще for, а тело цикла повторяется до тех пор, пока логическое выражение в круглых скобках после while возвращает true.
Пример ниже иллюстрирует вторую форму цикла for — без счётчика. Такой вариант удобен при переборе элементов массива или списка.
Импорт и использование классов
Один из важных принципов программирования — DRY: Don’t Repeat Youself (не повторяйся). Разработчик должен уметь использовать то, уже создано, отлажено и работает.
В игре нам потребуется случайное число от 0 до 9. Писать генератор случайных чисел незачем, так как в пакете java.util есть готовый класс Random. Чтобы использовать класс из пакета, его нужно импортировать. Строки с директивами импорта располагаются в самом начале файла класса.
Создадим объект на основании класса, чтобы можно было вызвать нужный метод. Слева от знака присваивания (=) объявляем ссылочную переменную (объект) random типа Random. Справа создаём объект с помощью директивы new.
Вызываем метод через точку после имени объекта: random.nextInt(10). Цифра 10 ограничивает диапазон генерируемых чисел (от 0 до 9). В результате получим строку из 30 случайных чисел. Запустите программу несколько раз и обратите внимание, что последовательность чисел не повторяется.
Игра «Угадай число»
Мы узнали достаточно, чтобы написать игру «Угадай число». В ней компьютер «загадывает» целое число от 0 до 9, а человек должен угадать его — есть три попытки.
Создадим класс GuessTheNumber с методом main(), импортируем нужные нам классы и добавим соответствующие объекты. Класс Scanner обеспечит чтение чисел с консоли (System.in — консоль).
Объявим и инициируем три переменные: счётчик попыток count, для чтения числа с консоли — guess, для хранения загаданного числа — number.
Опишем основной игровой цикл, используя while. В цикле запрашиваем число с консоли, сравниваем с загаданным. В случае несовпадения выводим подсказку и увеличиваем счётчик попыток на 1.
Тело цикла while повторяется, пока логическое значение в скобках возвращает true. Таким образом наш цикл будет повторяться, пока значение счётчика попыток меньше 3 и число не отгадано. Обратите внимание на конструкцию, которая позволяет выбрать одно из двух значений согласно условию в скобках. Это тернарный оператор. Если условие в скобках true, то возвращается значение слева от двоеточия, если false — справа.
Остаётся добавить строку с выводом результата игры (победа или проигрыш) после цикла — тут снова используется тернарный оператор. Текст работающей программы выглядит так:
Сохраняем программу в файл GuessTheNumber.java, компилируем (javac), вызываем JVM (java) — и пробуем выиграть у компьютера.
Добавим заключительный штрих: используя цикл do-while, позволим пользователю повторять сеанс игры без перезапуска программы. В приведённом ниже коде комментарий нужно заменить на соответствующий фрагмент из предыдущей программы. Попробуйте сделать это самостоятельно.
Обратите внимание, что тело цикла do-while повторяется на тех же условиях, что и тело цикла while: логическое выражение в скобках должно быть true.
Заключение
На всякий случай прилагаю мой telegram — @biblelamp. Если вас заинтересовала тема, рекомендую почитать «Java-программирование для начинающих» Майка МакГрата и «Изучаем Java» Кэти Сьерра и Берт Бейтс. В следующих статьях мы продолжим начальное изучение Java на примере создания других игр. Следите за блогом!
Другие статьи из серии «Быстрый старт с Java»:
Если язык Java вас заинтересовал — приглашаем на факультет Java-разработки. Если ещё не совсем уверены — посмотрите истории успеха наших Java-выпускников:
Чтобы понять как работают игровые движки и сами игры, давайте попробуем сами написать простой 2D движок.
Во всех играх есть основной игровой цикл, который непрерывно повторяется:
1. Чтение устройств ввода (клава, мышь, джойсткик, таймер)
2. Обновление игровых объектов
3. Отрисовка
И этот цикл повторяется пока игра запущена. FPS (frames per second) - сколько кадров в секунду отрисовал игровой движок или сколько циклов сделал данный цикл.
Для начала создадим класс Game, который будет основным. В нем же будет точка входа (метод main) в программу.
Здесь мы создали один объект класса Game и вызвали метод start(). В этом методе мы должны запустить игровой цикл.
Нам нужно окно для игры и панель, где мы будем рисовать саму игру. Создайте новый класс GameCanvas, который наслуедует от JPanel в новом файле:
Класс GameCanvas хранит при себе ссылку на объект Game, который ему передается при создании. Теперь, в классе Game создаем метод createWindow(), который создаст окно и панель GameCanvas.
Сначала объявляем свойства window и gameCanvas:
Затем создаем метод createWindow() и вызываем его в методе start():
Если сейчас вы запустите класс Game, то у вас будет пустое окно. Идем дальше.
Игровой цикл
Игровой цикл будет у нас движим таймером, который мы запустим в методе startTimer():
Убедитесь что класс Timer импортирован с пакета javax.swing, а не с пакета java.util:
Как вы видите в коде, таймер выполняется через каждые 50 миллисекунд и каждый раз запускает метод tick(). Метод tick() пока пустой, но в нем мы будем обновлять состояние игровых объектов и перерисовавыть экран. Теперь нужно вызвать метод startTimer() в методе start():
Игровые объекты
Любая игра состоит из объектов, с которыми так или иначе взаимодействует игрок и которые как-то отображается на экране. Конечно, есть объекты которые не отображаются, но отвечают за что-то. Эти объекты называются игровыми объектами.
У нас в движке будет основной класс GameObject, который будет иметь основные свойства игрового объекта и от которого будут наследоваться все другие игровые объекты.
Каждый игровой объект должен иметь ссылку на Игру, в которой он сейчас находится. И у каждого объекта есть позиция на экране. Так как у нас движок 2D, то у нас позиция это две координаты x и y. Как принято во всех игровых движках будем использовать класс Vector2, для хранения двух координат.
Создаем новый класс Vector2:
И создаем класс GameObject:
По умолчанию позиция у всех объектов 0,0.
Давайте сразу в класс GameObject добавим два метода, которые потом нам будут нужны:
* Метод draw() - метод будет вызываться, когда нужно отрисовать игровой объект на экран. Каждый тип игрового объекта по своему будет отрисовывать себя.
* Метод update() - метод будет вызываться, когда объекту следует проверить состояние игры, ввод, таймер и обновить свое состояние.
B итоге класс у нас такой:
Теперь переходим в класс Game. В любой игре игровых объектов может быть сколько угодно. Поэтому, нам нужно где-то держать все эти объекты. Будем держать их всех в классе Game, в свойства gameObjects типа Set, так как порядок объектов нам не важен:
Вначале множество объектов пустое. Но при запуске игры и во время игры объекты будут добавляться и удаляться.
Допустим что у нас уже есть много игровых объектов. Нам нужно их при каждом игровом цикле(tick) обновлять и перерисовывать. Давайте так и сделаем. Откроем метод tick() в классе Game:
Здесь мы обходим в цикле все игровые объекты и вызываем у них метод update(), чтобы они обновили свое состояние. Затем мы перерисовываем gameCanvas. Но пока класс GameCanvas у нас ничего не умеет рисовать. Нам нужно сделать так, чтобы GameCanvas умел отрисовывать все игровые объекты.
Откройте класс GameCanvas и в методе paint() для каждого игрового объекта нужно вызовите метод draw():
Корабль
Давайте добавим первый номральный игровой объект. Это будет примитивный корабль, которые будет выглядеть как красный треугольник высотой в 70 пикселей и шириной в 50.
Создайте класс Ship, который наследуется от GameObject:
Так, как он наследуется от GameObject у него есть свойства game и position, которые мы можем использовать для отрисовки корабля. Как видно из кода, мы нарисовали три линии, относительно текущей координаты игрового объекта. Основной точкой корабля мы взяли нижнюю среднюю точку.
Теперь в классе Game нам нужно создать корабль и добавить его в игровые объекты текущей игры. Создаем метод createInitialGameObjects() и вызываем его в методе start():
Если вы сейчас запустите класс Game, то увидите красный треугольник внизу экрана. Это наш корабль.
Давайте добавим возможность двигать кораблем.
Ввод и управление
Стрелками вправо/влево на клаве мы будем двигать наш корабль. Для этого мы добавим обработчик нажатия на кливиши в классе Game. В игровых движках обычно используются следующий метод: Все нажатые клавиши в данный момент хранятся в переменной, куда имеют доступ все игровые объекты. И если какая-либо клавишу зажата, то объект соответственно меняет свое состояние.
Мы тоже будем хранить множество всех нажатых клавиш в классе Game в свойстве pressedKeys. Множество - потому что одновременно нажатых клавиш может быть несколько. Объвляем:
У каждой клавиши на компе есть свой код типа Integer, мы будем их использовать.
Теперь нам нужно добавить обработчик клавиатуры. Создадим метод initKeyListeners() и возовем его методе start():
Метод keyPressed вызывается когда клавиша зажимается, а метод keyReleased когда клавиша отпускается. Поэтому при зажатии мы добавляем код клавиши в множество, а при отпуске удаляем из множества. Таким образом всегда во множество pressedKeys у нас будут только зажатые в текущий момент клавиши.
Теперь нам нужно двигать кораблем на клавиши влево и вправо. У клавиши "<-" код 37, а у клавиши "->" код 39, будем эти коды использовать, чтобы проверять зажаты ли стрелки.
Откройте класс Ship и переопределите метод update() так:
Как вы видите, если в нажатых клавишах есть код 37, мы меняем позицию корабля по X на -10, а если код 39, то на +10. Т.е. мы перемещаем корабль влево и вправо. Запустите класс Game и попробуйте нажать на стрелки вправо и влево, корабль должен двигаться. Разве не круто?!
Стрельба
Щас будем палить из всех оружий корабля. Давайте сделаем так, чтобы при нажатии на клавишу "Пробел", корабль выпускал пулю? Пуля тоже отдельный игровой объект, так как у него свои логика работы и внешний вид. Поэтому создаем еще один класс наследующий GameObject - класс Shot:
Класс Shot будет представлять пулю корабля. Он унаследовал свойство position от GameObject. В методе draw() мы рисуем небольшой прямоугольник. Так у нас будет выглядеть пуля. А в методе update() мы будем уменьшать позицию объекта по на -10, чтобы пуля поднималась вверх постоянно. Помните когда вызывается метод update() ? При каждом тике, т.е. постоянно через каждые 50 миллисекунд каждая пуля будет подниматься вверх на 10 пикселей.
Теперь нам нужно при нажатии на пробел, создавать новый объект пули и добавлять его и игровые объекты нашей игры. Откройте класс Ship и добавьте в методе update следующий код:
32 - код пробела. Создаем пулю, указываем его позиция выше текущей позиции кораблю. И добавляем в newGameObjects. Это еще одна переменная, которую нужно создать в классе Game:
newGameObjects - это новые объекты, которые нужно добавить в gameObjects при следующем цикле. Обновляем метод tick():
Теперь при нажатии на клавишу "Пробел" корабль создает игровой объект пули. Затем пуля уже сама по себе обновляется и отрисовывается как отдельный игровой объект. Запустите программу и постреляйте.
Текстуры
Текстура - это уже нарисованное изображение, которое накладывается на игровые объекты.
Давайте в конце попробуем вместе треугольника, показывать изображение корабля. Например:
Скачайте эту картинку и скопируйте в корень проекта. Затем откройте класс Ship. Картинку будем хранить в переменной texture типа BufferedImage и в конструкторе класса Ship считаем картинку из файла ship.jpg:
Теперь в методе draw() класса Ship,вместо треугольника будем рисовать эту текстуру:
Запустите игру и посмотрите на ваш красивый корабль!
Задание
Надеюсь после этого урока, вы поняли как примерно работают игровые движки.
Каждому из вас нужно ровно 100 раз повторить этот урок, каждый раз измеряя время выполнения. Вы должны уметь его написать закрытыми глазами в самом конце. Записывайте время каждого выполнения по порядку. Потом покажете мне и на следующей паре каждый из вас при мне должен написать эту игру.
Любите ли вы играть? А создавать игры? Даже если раньше не пробовали, никогда не поздно начать! Тем более, написать свою собственную игру теперь можно всего за час. А если понравится быть не игроком, а творцом, новое умение можно превратить в полноценную профессию. Как? Сейчас расскажем!
Змейка или Тетрис - какая вам ближе?
IT-портал GeekBrains запустил новый проект - серию вебинаров по созданию несложных игр на языке Java.
Что нужно для участия? Ничего, кроме собственно компьютера. Даже если вы никогда в жизни не видели исходный код программы и при слове Java вспоминаете чашку с дымком, которая иногда просит обновлений - ничто не помешает написать игру.
На вебинарах подробно рассказывается о создании таких игр, как Conway'sGameofLife, Snake, Тетрис, SpaceInvaders, и полностью раскрывается процесс написания кода. Если же что-то не получилось или вам интересно увидеть “официальный” вариант кода, - все файлы для игры можно скачать со страницы с описанием вебинара.
Сейчас для просмотра доступны четыре вебинара, посвященных теплым ламповым играм 80-х годов. То, во что вы самозабвенно рубились когда-то на приставке или Nokia 3310, теперь можете создать сами!
А дальше что?
Люди, которые занимаются созданием игр, называются разработчиками игр или гейм-девелоперами. Этой профессии пока не учат в российских вузах, но ей за совсем небольшую плату учит GeekBrains!
Гейм-девелоперы сейчас востребованы как никогда: люди любят играть, и аудитория онлайн- и оффлайн-игр постоянно увеличивается. Соответственно, всегда нужны новые разработчики, свежие идеи и предложения. В перспективе разработчик может возглавить, например, отдел, занимающийся конкретной игрой, или войти в руководство компании-девелопера игр. Нижний зарплатный порог в индустрии выше, чем у обычного менеджера среднего звена, а потолок ограничен только вашей фантазией - в прямом и переносном смысле. Так что подумайте, вдруг именно это и есть ваша будущая любимая работа?!
Читайте также: