Constantine_RetroGamer 6 янв 2022 в 23:39

Основы языка microScript

10 мин

9.1K

Open source*Программирование*Разработка игр*Разработка под Android*Разработка под Windows*

Привет Хабр!

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

Напомню:
- microStudio это бесплатная интегрированная среда разработки видеоигр.
- microStudio - проект с открытым исходным кодом, распространяемый по лицензии MIT. Вот ссылка на GitHub.
- создателя microStudio и ЯП microScript зовут Жиль Померей (фр. Gilles Pommereuil)
- microScript задумывался автором, в первую очередь, как язык для обучения программированию для новичков. Порог вхождения низкий - этот язык можно изучать с нуля, не зная до него о программировании вообще. microScript имеет простой синтаксис и набор правил, но при этом он достаточно функционален. На этом языке можно писать игры и приложения в среде microStudio, которые затем можно экспортировать в отдельное приложение HTML5.

Язык программирования microScript

Итак, для начала, microScript - это локальный язык.
В настоящее время он используется только в пределах microStudio.
По синтаксису microScript схож с языком Lua. Программа написанная на языке microScript транспилируется в javascript.

Вот некоторые общие принципы языка microScript о которых поговорим подробнее в этой статье:

По умолчанию переменные являются глобальными. Чтобы определить локальную переменную, нужно использовать ключевое слово "local".
Разрывы строк не имеют особого значения, они рассматриваются как пробелы.
Нет значения nullnil или undefined. Любая неопределенная или нулевая переменная по умолчанию равна 0.
Нет логического типа. 0 - это ложь, а все что не 0 - истина.
Нет ошибки выполнения или исключения. Любая переменная, которая не определена, возвращает значение 0.
Вызов значения в качестве функции, которое не является функцией, возвращает само значение.

"Hello, world!" на языке microScript:

print("Hello, world!")

Написание однострочных комментариев с помощью //:

print("Hello, world!") //здесь можно написать комментарий

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

Переменные

Переменные в microScript объявлять не нужно. Любая переменная, которая еще не использовалась, может считаться существующей и иметь значение 0. Чтобы начать использовать переменную, ей нужно присвоить значение со знаком равенства:

x = 1 //теперь значение переменной x равно 1

Все переменные в microScript считаются глобальными, если они явно не объявлены как локальные.

Локальную переменную можно определить используя ключевое слово "local":

myFunction = function()
	local i = 0
end

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

Имя переменной должно начинаться либо с латинской буквы, либо с символа нижнего подчеркивания _, после которых могут следовать латинские буквы, цифры или символы подчеркивания:

_x1 = 2
var_a = 3

Прописные и строчные буквы различны, потому что microScript, как например Lua или JavaScript, чувствителен к регистру - X1 не то же самое что и x1.

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

n = 5 // переменная n имеет числовой тип
n = "name" //теперь переменная n имеет строковый тип

Есть небольшой список зарезервированных слов, которые нельзя использовать в качестве идентификатора переменной: and, break, by, class, continue, else, elsif, end, extends, for, function, if, in, local, new, not, object, or, return, then, to, while.

Типы значений

microScript распознает пять типов значений:

числа,
строки (массив символов),
списки,
объекты
функции.

Числа

Значения типа "число" в микроскрипте могут быть целыми или десятичными числами. Например:

pi = 3.1415
x = 1
half = 1/2

Строки

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

name = "Вася"
print('Привет ' + name) //конкатенация сток с помощью оператора сложения "+"

В консоли: Привет Вася

Списки

В список можно поместить сколько угодно необходимых значений любого из пяти типов:

empty_list = [] //пустой список
prime_numbers = [2,3,5,5,7,11,13,17,19] //список чисел
mixed_list = [1,"кот",[1,2,3],drawObject()] //смешанный список

Можно получить доступ к элементам списка по их индексу, т. е. их положению в списке, начиная с индекса 0:

list = ["кот", "собака", "мышь"]
list[0] //"кот"
list[1] //"собака"
list[2] //"мышь"

Еще варианты доступа к элементу списка, не описанные в документации:

list["0"]
list['0']
list."0"
list.'0'
list.0

Можно просмотреть список с помощью цикла for:

for element in list
	print(element) //на консоль выведутся все элементы списка начиная с первого
end

Доступ к полям объекта через списки

Рассмотрим на таком примере, допустим, у нас есть три списка и три объекта:

list1 = []
list2 = []
list3 = []

object1 = object
	x = 1
	y = 3
end

object2 = object
	x = 24
	y = 0
end

object3 = object
	x = 100
	y = 62
end

Поместим объекты в первый список: list1 = [object1,object2,object3].

Получаем доступ к x объекта object2:

list1[1].x //object2 доступен по индексу 1
print(list1[1].x)

В консоли: 24

А теперь поместим первый список во второй, а второй в третий:

  list1=[object1,object2,object3] //этот список содержит объекты
  list2=[list1] //теперь этот список содержит первый список
  list3=[list2] //теперь этот список содержит второй список,
								//который в свою очередь содержит первый список

Получить доступ к y объекта object3можно таким образом:

list3[0][0][2].y //object3 доступен по индексу 2

Это можно сделать также и при помощи оператора.:

list3.0.0.2.y
print(list3.0.0.2.y)

В консоли: 62

Объекты

Объект в микроскрипте это форма ассоциативного списка. Объект имеет одно или несколько "полей", которые имеют ключ и значение. Ключ представляет собой строку символов, значением может быть любое значение microScript. Определение объекта начинается с ключевого слова "object" и заканчивается ключевым словом "end". Между ними можно определить несколько полей. Пример:

my_object = object
  x = 10
  y = 20
  name = "object 1"
end

Можно получить доступ к полям объекта с помощью оператора .:

print(my_object.x)

В консоли: 10

Таким образом, приведенный выше пример можно записать и так:

my_object.x = 0
my_object.y = 0
my_object.name = "object 1"

Можно добавить новое поле для объекта my_object:

my_object.vx = 5

Также, к полям объекта можно получить доступ с помощью скобок []:

my_object["x"] = 0
my_object["y"] = 0
my_object["name"] = "object 1"

Еще варианты доступа к полям объекта, не описанные в документации:

my_object['x']
my_object."y"
my_object.'name'

Функции

Функция определяется ключевым словом "function" и заканчивается ключевым словом "end":

nextNumber = function(x)
	x+1
end

Вызов функции:

nextNumber(10)

print(nextNumber(10))

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

x = 1
print(x())

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

draw = function()
  drawSky()
  drawClouds()
  drawTrees()
  drawEnemies()
  drawHero()
end
//Эти функции можно реализовать позже, а пока они не вызовут ошибок в коде

Классы

Это краткое отступление, для тех, кто только собирается изучать программирование и не имеет представление о том, что такое класс:

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

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

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

Начнем с создания класса Enemy, который будет использоваться всеми нашими объектами-врагами. У каждого врага будет своя позиция. У них будут очки здоровья hp, они будут двигайться с определенной скоростью velocity.

Создание класса начинается с ключевого слова "class" и заканчивается ключевым словом "end":

Enemy = class
  constructor = function(position)
  	this.position = position
  end
  hp = 10
  velocity = 1
  move = function()
  	position += velocity
  end
  hit = function(damage)
  	hp -= damage
  end
end

Примечание: иногда необходимо использовать this, чтобы убедиться, что мы правильно ссылаемся на свойство нашего объекта. Вот почему в конструкторе класса Enemy мы используем this.position = position, потому что position также ссылается на аргумент функции и таким образом, "скрывает" свойство объекта.

Первое свойство, которое мы определили в приведенном выше классе - это функция "constructor". Эта функция вызывается при создании экземпляра объекта класса. Она установит свойство положения(position) объекта. this относится к экземпляру объекта, на котором будет вызвана функция, таким образом, установка this.position означает, что объект устанавливает свойство position для себя.

Создадим два объекта врагов, производных от нашего класса:

enemy_1 = new Enemy(50)
enemy_2 = new Enemy(100)

Оператор new используется для создания нового экземпляра объекта, производного от класса. Аргумент, который мы передаем здесь, будет направлен на функцию constructor класса Enemy. Таким образом, мы создали два экземпляра противника, один на позиции 50, другой на позиции 100.

Оба врага имеют одинаковую скорость velosityи очки здоровья hp. Однако, можно выбрать другую скорость для второго врага:

enemy_2.veloсity = 4

Теперь можно заставить врагов двигаться, вызвав функции:

enemy_1.move()
enemy_2.move()

Второй враг будет двигаться в четыре раза быстрее, потому как мы изменили значение его velosityперед вызовом функции move().

Примечание: когда функция вызывается для объекта (например enemy_1.move()), переменные, на которые ссылаются в теле вызываемых функций, являются свойствами объекта. Например, в теле функции move() position += 1 будет увеличивать свойство position самого объекта а не класса.

Переменные hp и velocity также доступны нам сразу из класса:

Enemy.hp
Enemy.velosity

Таким образом мы можем менять их значение по ходу выполнения программы. И все объекты созданные из этого класса будут наследовать новые значения hp и velocity (если мы до этого не меняли эти значения для конкретного объекта).

Наследование

Можно сделать класс наследуемым от другого класса. Например, если мы хотим создать вариацию нашего врага в игре, мы можем сделать следующее:

Boss = class extends Enemy
	constructor = function(position)
 		super(position)
 		hp = 50
 	end
 	move = function()
 		super()
 		hp += 1
 	end
end

Здесь ключевое слово extends, используется для обозначения наследования свойств класса.

Мы создали новый класс Boss, путем расширения класса Enemy. Наш новый класс разделяет все свойства класса Enemy, за исключением того, что он заменяет некоторые из этих свойств своими собственными значениями. Вызов функцииsuper(position) в теле функции constructor() нашего нового класса гарантирует, что constructor() нашего родительского класса Enemy также будет вызван.

Мы создали новую функцию move() для нашего босса, которая переопределяет поведение Enemy по умолчанию. В этой новой функции мы вызываем функцию super(), чтобы сохранить поведение по умолчанию, которое было определено в классе Enemy; затем мы увеличиваем значение hp, что означает, что наши боссы будут восстанавливать очки здоровья при перемещении.

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

Теперь мы можем создать экземпляр босса на позиции 120:

the_final_boss = new Boss(120)

Условный оператор

В микроскрипте условия записываются следующим образом:

if age<18 then
	print("ребенок")
else
	print("взрослый")
end

"if" означает "если"; "then" означает "тогда"; "else" означает "иначе"; "end" означает "конец".
Таким образом, в приведенном выше примере: if значение переменной age меньше 18, then инструкция print("ребенок") будет выполнена, else будет выполнена инструкция print("взрослый").

Можно проверить несколько гипотез, используя ключевое слово "elsif" (сокращение от "еще, если").

if age<10 then
	print("ребенок")
elsif age<18 then
	print("подросток")
elsif age<30 then
	print("молодой человек")
else
	print("очень взрослый")
end

Цикл for

Цикл for широко известен в программировании, также как и условный оператор if, тем не менее я опишу кратко его применение в microScript.

Этот цикл позволяет проводить одинаковую обработку всех элементов списка или ряда значений:

for i=1 to 10
	print(i)
end

В приведенном выше примере мы выведем на консоль каждое число от 1 до 10.

Мы можем сделать тоже самое, только с шагом равным 2:

for i=0 to 10 by 2
	print(i)
end

В приведенном примере мы выведем на консоль числа от 0 до 10 с шагом 2(by 2).

Цикл while

Этот цикл позволяет выполнять операции повторно, пока не будет получен удовлетворительный результат:

x = 1
while x*x<100
   print(x*x)
   x = x+1
end

В приведенном выше примере выводится квадрат x, затем увеличивается значение x (прибавляется единица к x), если квадрат x меньше 100.

Прервать или продолжить цикл

Мы можем прервать цикл досрочно, используя оператор break:

while true
   x = x+1
   if x>= 100 then break end //если x больше либо равен 100, цикл будет прерван
end

Можно пропустить оставшиеся операции цикла и перейти к следующей итерации цикла с помощью оператора continue. Пример:

for i=0 to 10000
	if i%10 == 0 then continue end //это позволит пропустить обработку чисел,
                                 //кратных 10
	doSomeProcessing(i)
end

Арифметические Операторы

Оператор	Описание
`+`	Сложение
`-`	Вычитание
`*`	Умножение
`/`	Деление
`%`	Деление по модулю (остаток от деления)
`^`	Возведение в степень

Бинарные операторы сравнения

Оператор	Описание
`==`	`a == b` верно только в том случае, если `a` равно `b`
`!=`	`a != b` верно только в том случае, если `a` отличается от `b`
`<`	`a < b` верно только в том случае, если `a` строго меньше `b`
`>`	`a > b` верно только в том случае, если `a` строго больше `b`
`<=`	`a <= b` верно только в том случае, если `a` меньше или равно `b`
`>=`	`a >= b` верно только в том случае, если `a` больше или равно `b`

Булевы операторы

Оператор	Описание
`and`	логическое И: `a and b` истинно только в том случае, если `a` и `b` истинны
`or`	логическое ИЛИ: `a or b` истинно только в том случае, если `a` истинно или `b` истинно
`not`	логическое НЕ: логический оператор `not` меняет результат на противоположный начальному значению. То есть, если операндом является `true`, то после применения логического `not`, результатом будет `false`. Если операнд до применения оператора `not` был `false`, то после его применения станет `true`. `not`- унарный оператор (применяется к одному операнду), он помещается перед операндом. Таким образом: `not a` истинно, если a ложно, и ложно, если a истинно.

Пример с оператором not:

num_1 = 0
num_2 = 5
if not num_1 then print("not num_1 истина") end //not num_1 возвпащает true
if not num_2 then print("not num_2 ложь") end //not num_2 возвращает false

В консоли: not num_1 истина

Логические значения

В microScript нет логического типа. 0 считается ложным, а любое другое значение является истинным. Операторы сравнения возвращают значение 1 (true) или 0 (false). Для удобства microScript также позволяет использовать следующие предопределенные переменные:

Переменная	Значение
`true`	1
`false`	0

Три основные функции в языке microScript

Открыв окно проекта microStudio (в разделе "код") вы увидите три основные предопределенные функции:

init()
update()
draw()

Функция init()

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

Функция update()

Функция обновления вызывается 60 раз в секунду. Тело этой функции - лучшее место для программирования логики и физики игры: изменения состояния, движения спрайтов, обнаружение столкновений, оценка входов с клавиатуры, оценка сенсорных или геймпадных входов и т.д.

Функция draw()

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

Послесловие

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

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

И как всегда, спасибо за внимание!

Теги:

Хабы: