DM Guide 6
Это 6 глава перевода оригинального руководства по Dream Maker от разработчиков
Остальные главы руководства и статьи о программировании на коде BYOND от любителей на русском.
Оригинальная 6 глава руководства на английском языке
|
В разработке… |
 Вы можете помочь проекту |
Глава 6: Действия Proc
Только он потер лампу, перед ним возник джин и спросил: 'Чего ты хочешь?'. — Аладдин и волшебная лампа. Арабские ночи.
Язык ДМ поддерживает несколько видов процедур. Первый - Verb, видимые игроком команды. Второй, не видимый игрокам, называется proc. В остальном эти процедуры можно назвать идентичными.
Создание процедуры
Также процедуры можно использовать для того чтобы избежать копирования кода.
К примеру, в вашей игре может быть несколько ситуаций, в которых игрок может получить урон. Разумно в каждой такой ситуации проверять, не убил ли этот удар игрока. Для того чтобы не писать отдельную проверку в каждой такой ситуации (и случайно не забыть написать эту проверку), вы можете написать для этого специальную процедуру.
mob
var/life = 100
proc/HurtMe(D)
life = life - D
if(life < 0)
view() << "[src] dies!"
del src
Этот пример описывает процедуру с именем НанесиМнеУрон (HurtMe), которая принимает один аргумент - полученный урона. Полученный урон вычитается из текущего числа жизней персонажа и происходит проверка, остался ли он в живых. Если число жизней оказалось меньше нуля, персонаж удалится.
Оператор if, используемое в примере выше, это одна из множества процедур (инструкций), которые будут описанные в следующих частях руководства. Сейчас достаточно знать, идущий после if (с большим отступом), будет выполнен только в том случае, если условие, идущее в скобках после if - истинно.
Выполнение процедуры
Синтаксис выполнения процедуры схож с доступом к переменной, но, при выполнении, в скобках добавляются передаваемые в процедуру аргументы. В следующем примере, мы выполним процедуру HurtMe, когда персонаж выпьет отравленное зелье.
obj/poison
name = "can of soda"
verb/drink()
set src in view(0)
usr.HurtMe(25) //OUCH!
del src //one use only (please recycle)
Чаще всего вместо фразы 'Выполнить процедуру' используют фразу 'Вызвать процедуру'. Эти фразы означают одно и тоже.
Подобный синтаксис используется при вызове процедур обоих видов: Proc и Verb, но чаще verb вызывается игроками. Хорошим тоном считается наименование процедур Proc словами, начинающимися с заглавной буквы, а verb - с маленькой. Этот ход, кроме визуального разделения, позволяет избежать ситуации, когда имя процедуры proc совпадет с именем verb. Такие совпадения вызывают ошибку при компиляции, поскольку программа не сможет понять, вызываете вы процедуру вида proc или verb.
Когда вы вызываете процедуру, компьютер выполняет каждую команду по очереди (одну за раз), начиная с верху. Некоторые операторы, как if из примера выше, могут приказать компьютеру пропустить часть команд или же наоборот выполнить часть из них несколько раз подряд. Но, за исключением этих особых случаев, все команды выполняются последовательно. Когда все команды будут выполнены, процедура будет закончена. Программисты называют это возвратом, потому, что продолжится выполнение кода в той точке из которой была вызвана процедура (если таковая существует).
Наследование процедур
Так же, как в ситуации с verb, процедуры proc могут быть переопределены во время наследования. Синтаксис переопределения разных видов процедур совпадает. Исходная процедура отличается от переопределений наличием слова proc. После этого она может быть переопределена, для переопределения не требуется слова proc.
Это позволяет, на пример, создать несколько персонажей, которые по-разному будут реагировать на получаемый урон.
mob/DM
var/vulnerable
verb/set_vulnerability(v as num)
vulnerable = v
HurtMe(N)
if(vulnerable)
..()
Этот код позволяет DM быть уязвимым или не уязвимым по желанию. В переопределенном HurtMe, первым делом происходит проверка на неуязвимость. Если DM в данный момент является уязвимым (для теста или чего-то подобного), будет вызвана родительская процедура, в данном случае, исходная версия процедуры HurtMe.
Гибкость Аргументов
Когда вы вызываете процедуру, вы можете передать в нее столько аргументов, сколько вы хотите. Всем аргументам, не переданным в процедуру при вызове, будет установлено значение равное null. Гибкость позволяет вам, к примеру, добавить несколько аргументов в переопределении процедуры. Если при вызове процедуры, не будут переданы эти добавленные аргументы, их значение станет равным null.
Вы также можете убрать часть аргументов, в переопределенной процедуре. Это, обычно, не влияет на код и делается только для удобства, в случае, когда часть аргументов не используется процедурой. Например, HurtMe объекта DM может быть переписана следующим образом:
mob/DM/HurtMe()
if(vulnerable)
..()
Поскольку, мы не используем переменную N (полученный урон), мы можем вовсе не объявлять этот аргумент. Тем не менее, вызовы этой процедуры с аргументом так же будут работать. Что более важно, родительская процедура будет получать переданные аргументы, даже если они не были объявлены в дочерней процедуре. Это происходит по тому, что вызов ..() без аргументов, передает в родительскую процедуру, аргументы переданные дочерней процедуре.
Глобальные процедуры
Некоторые процедуры могут не иметь ничего общего с каким-либо объектом. Они могут быть объявлены в верхнем уровне, для повсеместного доступа к ним. Такие процедуры, обычно, выполняют различные автономные (не зависящие от объектов) расчеты.
Язык ДМ имеет множество предопределенных процедур (такие как view() или locate()), которые возвращают многократно используемые результаты. Для того, чтобы отличать их от определенных вами процедур, их часто называют инструкциями.
Объявление глобальных процедур
Игра, в которой, к примеру, знаки зодиака играют важную роль, может иметь процедуры подобные следующей:
proc/Constellation(day)
//day should be 1 to 365 if(day > 354) return "Capricorn" if(day > 325) return "Sagittarius" if(day > 295) return "Scorpio" if(day > 265) return "Libra" if(day > 234) return "Virgo" if(day > 203) return "Leo" if(day > 172) return "Cancer" if(day > 141) return "Gemini" if(day > 110) return "Taurus" if(day > 79) return "Aries" if(day > 50) return "Pisces" if(day > 20) return "Aquarius" return "Capricorn" //day 1 to 20
Может потребоваться другая процедура, которая может конвертировать дни определенного месяца, в дни года. Этот код, в зависимости от даты, будет возвращать знак зодиака. Чуть позже мы рассмотрим детали реализации этого кода.
Вызов глобальных процедур
Глобальные процедуры вызываются также как и любые другие. Если такая процедура возвращает значение, оно может использоваться в любом месте, где требуется выражение.
Термин выражение означает, любую часть кода, которая в результате своего выполнения возвращает некое значение. Простейшим примером выражения можно считать константу, такую как число или текст. Более сложными выражениями являются переменные, операторы, вызовы процедур и т.д.
Это пример того, как вызвать процедуру и использовать, то, что она вернет.
var/day_of_year = 1 mob/DM/verb/set_date(day as num) set desc = "Enter the day of the year (1-365)." day_of_year = day world << "The sign of [Constellation(day)] is in force."
Этот verb дает DM возможность изменять текущую дату, после чего, всем будет сообщено об изменении текущего знака зодиака. Вызов процедуры, в данном случае, просто встраивается в текст, как и любое другое выражение.
Язык процедур
В следующей части мы изучем предопределенные процедуры. Сейчас вы знаете, как переопределять процедуры и объявлять новые созданные вами, это позволит вам создавать объект более подходящие под ваши нужды. Но, перед тем, как заняться процедурами всерьез, вы должны выучить их язык (вы можете сделать это и в "боевых" условиях, но цена ошибки будет совсем другой). В зависимости от ваших предпочтений в языках программирования (особенно если это С или близкие к нему языки), вы можете сами выбрать то, насколько тщательно вам нужно вчитываться в следующий материал.
Операторы
Основной единицей процедуры является оператор - команда, которая говорит компьютеру, что нужно сделать. До этого момента вы уже видели операторы, которые присваивают переменные, выводят данные и вызывают процедуры.
Операторы обычно располагаются в линию. Хотя они могут быть сгруппированы в одну строку, если поставить ; (точка с запятой) между ними. Также можно разбить оператор на несколько строк, если в конце каждой, кроме последней из них ставить \ (обратный слеш).
Statement 1 Statement 2; Statement 3; ... Statement 4 (begin) \ Statement 4 (end)
Кроме таких простых операторов существуют составные, такие как if, которые могут комбинировать несколько простых выражение в один составной. Дальше вы увидите все возможные виды операторов используемых в языке DM.
Возврат
Все виды процедур возвращают что-либо. Даже действия verb, что-то возвращают, но это редко используется. Если процедура завершается без возврата какого-либо явного значения, то возвращается специальное значение null.
Оператор return
Вы уже видели пример возврата значения с использованием выражения return. Основной формат записи возврата следующий:
return [expression]
Оператор return приказывает процедуре прекратить выполнение. Если возвращаемое выражение определено, оно возвращается в точку вызова процедуры. Выражение означает любой блок кода, создающий число. Это может быть константа, математическое вычисление или результат вызова другой процедуры.
Переменная . (точка)
Если процедура завершается без оператора return, или return без следующего за ним выражения, возвращаемая величина берется из переменной . (точка). Этой переменной (как и любой другой) может быть присвоено значение. По умолчанию в . (точке) хранится null. Поэтому процедура завершившаяся без явного указания возвращаемой величины возвращает null.
Выбор между использованием return и точкой - вопрос удобства. Но иногда, возвращаемая величина бывает рассчитана до завершения процедуры (не все процессы завершены). Тогда удобнее будет использовать точку. Либо, если вы захотите определить другое возвращаемое по умолчанию значение.
Такое имя для переменной было выбрано для того, чтобы создать ассоциацию с текущей процедурой, по аналогии с использованием точки во множестве файловых систем для обозначения текущей директории. Это также хорошо сочетается, с двумя подряд идущими точками, для обозначения родительской процедуры (и родительской директории в файловых системах). Эта аналогия идет и дальше, вы сможете заметить это во время дискуссии о типах.
Оператор if
Для выполнения блока кода в зависимости от состояния некого выражения, используется оператор if. Основной его синтаксис:
if (expression) Statement1 Statement2 . . .
Или
if(expression) Statement
Первый формат, позволяет одновременно блокировать/разрешать выполнение для нескольких операторов, в блоке с отступом (относительно if). Второй - уплотненный формат, для одного. Все составные операторы поддерживают оба описанных выше формата. Для краткости, дальше все примеры будут приводиться в плотном (втором) формате, поэтому важно понять, что любой одиночный оператор в них может быть заменен блоком кода с отступом.
Существует еще один путь группировки нескольких операторов в один - установка фигурных скобок вокруг операторов. После их также можно расположить на одной строке.
if(expression) {Statement1; Statement2; ...}
Операторы внутри оператора if называются его телом. Они будут выполняться, только если выражение в круглых скобках будет соответствовать истине. DM не имеет специального типа данных для определения понятий ИСТИНА и ЛОЖЬ. Вместо этого, каждый тип имеет свое представление истины, связанное с его значением. Вы скоро увидите, как это работает.
Дополнение else
Перед тем, как начать рассматривать преобразования типов, мы должны разобраться с else. Если выражение в if будет ложным, альтернативное тело оператора будет выполнено. Объединив несколько операторов, мы сможем рассмотреть все состояния условий. Основной синтаксис для это представлен ниже:
if(expression1) Statement1 else if(expression2) Statement2 . . . else Statement3
Рассматривая эту конструкцию сверху-вниз, каждое выражение будет протестировано. До тех пор, пока не будет найдена истина, соответствующие тела операций будут выполняться. Обратите внимание, что если любое условие будет истинным, то остальные операторы else будут проигнорированы. Если ни одно из условий не будет истинным последнее тело else будет выполнено.
Логическое выражение
Любое выражение, стоящее в условии оператора if может быть интерпретировано как истина или ложь, программисты называют это булевым значением. В ДМ существует три случая, когда выражение интерпретируется как ложь: если выражение равно null, 0 или "" (пустая сторка). Во всех других случаях выражение интерпретируется, как истина.
Скорее всего, вам понадобятся логические константы, обычно для этого используют числа 1 и 0. Также часто, вместо константы используют флаговую переменную (как opacity) или значение возвращаемое процедурой. Также вы можете объявить константы TRUE (ИСТИНА) и FALSE (ЛОЖЬ), если не хотите использовать их числовые эквиваленты.
Логические операторы
Сущестует несколько операторов для работы с логическими выражениями, все они возвращают результат в виде логического значения (0 или 1) в зависимости от аргументов этих операторов. Логические опараторы, как и другие (не логические) по большей части совпадают с таковыми в языке С (и основовашихся на нем С++ и Java).
( Оператор это симовол, как = или !, означающий некоторое действие или вычисление. Операторы, которые ставятся перед аргументом принято называть prefix/префиксными, ставящиеся после аргумента - postfix/постфиксными. Те же операторы, с обеих сторон которых стоят аргументы, называются infix/инфиксными. )
Оператор логического отрицания ! (НЕ)
Оператор ! вычисляет логическое отрицание аргумента следующего за ним. Проще говоря, если вырожение стоящее после ! истино оператор вернел 0, если ложно оператор вернет 1.
!expression
Следующий пример показывает использование оператора ! для изменения логического значения. Под "изменение значения", в данном случае, понимается простая замена истины на ложь и наоборот.
mob/verb/intangible() density = !density if(density) usr << "Вы материализовались." else usr << "Вы дематериализовались."
Вот так это и работает.
Оператор логического умножения && (И)
Оператор && вычисляет логическое И от двух выражений. Если аргументы с обеих сторон от оператора будут истинны, оператор так же вернет 1, в любых других случаях оператор вернет 0. Для уменьшения числа рассчетов часто используется такая особенность этого оператора: второй аргумент не будет расчитываться, если первый аргумент ложь. Это часто применятеся, в случаях, когда второе вырожение это процедура с побочными эффектами (занимает много ресурсов, времени для выполнения), которая не должна вычисляться если определенное выражение ложно. Этот прием называется short-circuiting (укороченная оценка). Значение оператора И равно значению последнего вычисленного аргумента. Конструкция Short-circuiting была заимствована из C. Тем не менее, в отличии от С, операторы && и || возвращают именно последний вычисленный аргумент, а не 1 или 0. Эта фича была взята из Perl.
expression1 && expression2
Пример ниже демонстрирует использование оператора &&, для того чтобы убедиться, что игрок и предмет материальны и могут взаимодействовать.
mob/verb/touch(mob/M) if(density && M.density) view() << "[usr] коснулся [M]!" else view() << "Рука [usr] прошла сквозь [M]!"
Оператор логического сложения (ИЛИ)
Оператор || вычисляет логическое ИЛИ двух выражений. Если один из аргументов оператора истинен, оператор вернет 1, в любых других случаях, он вернет 0. Как и в случае с оператором &&, будет расчитанно только минимальное необходимое количество аргументов. Если первый аргумен - истина, второй аргумент не будет расчитан. Оператор вернет значение последнего расчитанного аргумента.
expression1 || expression2
Пример использования short-circuit для отображения стандартного текста, если описание предмета отсутствует.
mob/verb/look() set src in view() usr << (desc || "Ничего необычного.")
Оператор сравнения == (эквивалентно)
Оператор == сравнивает два значения. Если они идентичны, оператор вернет 1, иначе 0. Стоит иметь в виду, что оператор = - это оператор присваивания, который имеет совсем другое происхождение. В отличии от языка С, ДМ не позволяет вам использовать = в выражениях (вроде if), поэтому вы можете не волноваться о том, что случайно используете не тот оператор.
Когда оператор == применяется с числами, результат это строгое сравнение чисел. В случае, когда оператор используется со ссылками, сравниваются ссылки, а не объект на который они указывают. Так что, если два объекта созданы идентичными во всех отношениях, но, это всеже разные объекты, результатом сравнения будет ЛОЖЬ. Учитывая тот факт, что одинаковые строки будут сложены в один объект для сохранения памяти, сравнение строк будет происходить путем посимвольного сравнения.
expression1 == expression2
Это пример использования оператора == для проверки, смеется ли персонаж над собой или над кем-то другим.
mob/verb/laugh(M as mob|null)
if(!M)
view() << "[usr] смеется."
else if(M == usr)
view() << "[usr] смеется над собой."
else
view() << "[usr] смеется над [M]."
Математические операторы
Язык ДМ поддерживает операторы для всех основных математических операций. На их основе можно воссоздать любые более сложные операции. Все рассчеты в ДМ производятся над числами с плавующей точкой, если не указано другого. Любой не числовой аргумент приравнивается к нулю
Кроме описанных выше операторов, в ДМ встроены несколько полезных математических функций (например функция эмитирующая бросок игральных костей). Более подробно они будут рассмативаться в главе 16.
Арифметические операторы
Арифметические операторы - это +, -, * и /. Они выполняют сложение, вычитание, умножение и деление. Оператор "-" также может использоваться (в префиксной форме) для отрицания.
expression1 + expression2 20pt (addition) expression1 - expression2 (subtraction) expression1 * expression2 (multiplication) expression1 / expression2 (division) - expression (negation)
Программисты на языке С должны обратить внимание на то, что деление дает полный результат с плавающей точкой, а не только целочисленную часть. Например, 3/2 дает ожидаемый результат 1,5.
** оператор возведения
Оператор ** возводит левое значение в степень правой части. Не используйте по ошибке для этой цели оператор ^, так как он имеет совершенно другое значение (описано ниже).
expression1 ** expression2
% оператор остатка
Оператор % используется для нахождения остатка от деления. Выражение "A % B" читается как «A по модулю B» и равно остатку от деления A на B. Этот оператор работает только с целочисленными аргументами.
expression1 % expression2
Этот оператор часто используется в циклических событиях. Например, вы можете определить процедуру, которая заставляет солнце вставать, предупреждая людей об особенно неблагоприятных днях.
var day_count day_of_week //0 is Sunday
proc/NewDay() day_count = day_count + 1 day_of_week = day_count % 7 //0 through 6
if(day_of_week == 1) world << "It's Monday!" else world << "A new day dawns."
Увеличение и уменьшение
Сложение и вычитание 1 из переменной - настолько распространенные операции, что для них существуют специальные операторы. Увеличение(increment) ++ прибавляет 1 к переменной. Уменьшение(decrement) -- вычитает 1 из переменной.
Каждый из этих операторов имеет префиксную и постфиксную форму. От того, какая из них используется, зависит, будет ли значение выражения в целом взято из переменной до или после изменения ее значения. Префиксная форма изменяет переменную и возвращает результат. Постфиксная форма изменяет переменную, но при этом возвращает ее первоначальное значение.
++expression --expression expression++ expression--
В предыдущем примере с восходом солнца можно использовать оператор увеличения(increment).
day_count = day_count + 1 //long-hand day_count++ //short-hand ++day_count //or even this
В данном случае неважно, какую версию мы использовали - префиксную или постфиксную, потому что мы не использовали значение результирующего выражения. Важен только побочный эффект увеличения переменной day_count, а он одинаков в любом случае.
Мы даже можем объединить увеличение(increment) day_count со следующей строкой, использующей его, следующим образом:
day_count = day_count + 1 //increment day_of_week = day_count % 7 //use incremented value
day_of_week = ++day_count % 7 //increment and use it
Обратите внимание, что мы использовали префикс увелечения(increment). Это потому, что мы хотели сначала увеличить значение day_count, а затем использовать его для вычисления дня недели. Постфиксный вариант увелечения(increment) использовал бы существующее значение day_count для вычисления дня недели, а затем увеличил бы его. Таким образом, оба результата оказались бы рассинхронизированы на один день. Конечно, в данном примере это не имеет большого значения, но в некоторых ситуациях это может быть важно.
Порядок выполнения математических операций
Как и булевы операторы, математические символы обрабатываются в определенном порядке. Если порядок по умолчанию не подходит, можно использовать круглые скобки для формирования меньших выражений, которые оцениваются первыми.
На рисунке 6.10 представлен порядок операций с математическими символами от высшего к низшему. Операторы, расположенные в одной строке, имеют одинаковый приоритет и поэтому оцениваются по мере их появления в выражении слева направо.
Рисунок 6.10: Порядок выполнения математических операций
( ) ++ -- -(negation) ** * / % + -
Битовые операции
Иногда полезно упаковать несколько флагов в одну переменную. Примером этого является переменная mob.sight. Каждый флаг представлен одним битом включения/выключения в значении. Например, в случае с mob.sight возможны следующие значения:
(Не слишком привязывайтесь к специфике этой переменной. Тому это не нравится, и у меня есть ощущение, что он может устроить еще одно восстание, чтобы подавить его. Бессердечный демагог! Без него DM так и остался бы простым языком ассемблера.)
#define BLIND 1 //binary 00001 #define SEEINVIS 2 //binary 00010 #define SEEMOBS 4 //binary 00100 #define SEEOBJS 8 //binary 01000 #define SEETURFS 16 //binary 10000
Каждое значение является степенью двойки, что позволяет нам генерировать уникальные числа путем их комбинации.
Чтобы упростить работу с отдельными битами, существует ряд побитовых операторов (унаследованных от C). При использовании этих операторов аргументами должны быть 16-битные целые числа (в диапазоне от 0 до 65535). (65535 - это просто шестнадцать 1 в двоичном исчислении; это самое большое 16-битное число). Все, что выходит за пределы этого диапазона, будет обрезано.
~ побитовое NOT (НЕ)
Оператор ~ выполняет побитовое НЕ для своего аргумента. Для каждого из 16 битов аргумента, если этот бит равен 1, соответствующий бит в результате будет равен 0, и наоборот. Это очень похоже на оператор !, только в последнем случае неважно, какие биты включены - важно, чтобы хотя бы один бит был включен. Оператор ! также работает с другими значениями, кроме 16-битных целых чисел.
~ expression
& побитовое AND (И)
Оператор & выполняет побитовое AND своих аргументов. Для каждой пары битов в аргументах соответствующий бит в результате будет равен 1, если они оба равны 1, и 0 в противном случае. Обратите внимание, что это аналог логического оператора &&, за исключением того, что он обрабатывает каждый бит по отдельности, а не значение в целом.
expression1 & expression2
Оператор & чаще всего используется для проверки того, установлен ли определенный битовый флаг. Например, mob.sight & SEEINVIS будет ненулевым (т. е. истинным), если флаг SEEINVIS установлен, и 0 в противном случае.
| побитовое OR (ИЛИ)
Оператор | выполняет побитовое ИЛИ своих аргументов. Для каждой пары битов в аргументах соответствующий бит в результате будет равен 1, если один из них равен 1, и 0 в противном случае. Обратите внимание, что этот оператор аналогичен логическому оператору ||, за исключением того, что он обрабатывает каждый бит по отдельности, а не значение в целом.
expression1 | expression2
Оператор | чаще всего используется для объединения нескольких битовых флагов. Например, mob.sight может быть установлен в SEEMOBS | SEEOBJS, чтобы дать кому-то рентгеновское видение предметов сквозь стены. На самом деле, для этой цели можно использовать и +, если не включать один и тот же флаг более одного раза.
^ побитовый XOR (исключающее ИЛИ)
Оператор ^ выполняет побитовое исключающее ИЛИ своих аргументов. Для каждой пары битов в аргументах соответствующий бит в результате будет равен 1, если один из них равен 1, и 0 в противном случае.
expression1 ^ expression2
Оператор ^ чаще всего используется для переключения битового флага. Например, mob.sight = mob.sight ^ SEEINVIS включит флаг SEEINVIS, если он выключен, и наоборот.
Сдвиг битов
Операторы << и >> выполняют сдвиг битов влево и вправо. Они почти никогда не используются в программах DM, но включены, поскольку являются стандартными операторами языка C. При использовании вне выражения (в операторе) эти операторы имеют совсем другое значение (унаследованное от C++); в этом случае они служат операторами ввода/вывода. Вы почти всегда будете использовать их в этом виде.
Порядок побитовых операций
Порядок, в котором оцениваются побитовые операторы, приведен на рисунке 6.11 - от старшего к младшему. Операторы, расположенные в одной строке, имеют одинаковый приоритет и поэтому оцениваются слева направо по мере их появления в выражении.
Рисунок 6.11: Порядок побитовых операций
( ) ~ << >> & ^ |
Операторы присваивания
Оператор = приводит к тому, что левая переменная присваивается правому выражению. Как отмечалось ранее, это совершенно не похоже на символ ==, который выполняет сравнение.
(Операторы = и == имеют такое же значение в языке C. Однако, в отличие от языка C, присваивание в DM само по себе не является выражением. Это предотвращает легко совершаемую ошибку, когда в условном выражении используется =, а на самом деле нужно было ==.)
При присваивании числа и ссылки просто копируются в указанную переменную. Фактическое содержимое ссылки не дублируется - дублируется только сама ссылка. См. раздел 5.6 для обсуждения ссылок и данных переменных.
expression1 = expression2
Комбинирование других операций с присваиванием
Когда вы хотите добавить что-то в переменную, вы можете сделать это следующим образом:
variable = variable + 26
Однако DM предлагает удобное сокращение для этого, поскольку это очень распространенная операция. Вместо этого вы можете просто набрать:
variable += 26
Это не просто особый случай для оператора +. Он работает для всех них. В общем случае следующие два утверждения эквивалентны.
1.10pt expression1 = expression1 (operator) expression2 2.10pt expression1 (operator)= expression2
Условный оператор ?
Оператор ? проверяет булево выражение. При этом указываются два дополнительных выражения: одно из них вступает в силу, если булево выражение было истинным, а другое - если ложным. Для эффективности из двух выражений оценивается только требуемое.
boolean expression ? true expression : false expression
В следующем примере вместо оператора if используется оператор ?
mob/verb/intangible() density = !density usr << (density ? "You materialize." : "You dematerialize.")
Для любого человека, кроме программиста на языке С (или грека), это выглядит как греческий язык. Тем не менее, как только вы натренируете свой глаз читать это, вы сможете ходить с чувством превосходства над всеми остальными.
Оператор разыменования
Если ссылка на объект хранится в одной переменной, то доступ к собственным переменным и процедурам объекта можно получить с помощью операторов, описанных в следующих разделах. Такая операция называется разыменованием переменной, поскольку она требует от компьютера доступа к данным, на которые указывает ссылка.
«строгая» отсылка
Оператор "." (точка) используется для доступа к переменной или процедуре, принадлежащей объекту. Для этого необходимо, чтобы ссылка на объект хранилась в переменной соответствующего типа. Тип не обязательно должен быть полностью определен - достаточно, чтобы перейти к определению переменных и процедур, к которым будет осуществляться доступ.
object.variable 20pt Or 20pt object.procedure()
В отличие от большинства других операторов DM, пробел не допускается по обе стороны от оператора точки. Имена переменных и процедур должны располагаться по обе стороны от него без разделения.
Требование, чтобы объект принадлежал к известному типу, просто позволяет компилятору лучше проверять ошибки. Он не позволит вам попытаться получить доступ к переменной или процедуре, которая не принадлежит к указанному типу, и поэтому известен как «строгий» оператор разыменования.
Это во время компиляции. Во время выполнения вы можете присвоить переменную объекту, который даже не имеет того же типа (например, mob в переменной obj). Это не страшно. Фактически, оператор dot будет работать и в этом случае, если запрашиваемая переменная существует для данного объекта. В этом случае мы говорим, что объект имеет совместимый интерфейс.
Если во время выполнения выясняется, что у объекта нет запрошенной переменной, процедура немедленно прекращает выполнение. Это называется крахом процедуры. (Еще хуже - мировой крах, при котором погибает весь мир). Наиболее распространенный случай - нулевой объект. При этом будет выдан отладочный вывод, описывающий точную причину, чтобы помочь вам отследить проблему. Более подробно методы отладки будут рассмотрены в главе 19.
Следующие четыре verb иллюстрируют различные свойства оператора dot.
mob/verb
summon1(M as mob)
M.loc = loc //compile-time error!
summon2(mob/M)
M.loc = loc //this works
summon3(obj/M as mob)
M.loc = loc //this works
summon4(mob/M as mob|null)
M.loc = loc //could be run-time error!
Первая версия verb/summon не компилируется. Входной тип M был определен как mob, но тип переменной остался неопределенным, поэтому компилятор не знает, что в M есть переменная loc.
Вторая версия заботится о типе переменной и использует тот факт, что тип ввода по умолчанию вычисляется из типа переменной.
Третья версия странная, но она работает. Мы сказали компилятору, что это переменная obj, и сказали клиенту принимать мобов в качестве входных данных. Поскольку и obj, и mob имеют переменную loc, и компилятор, и сервер довольны. Вы, конечно, не захотите делать все именно так, но вы можете изменить тип ввода на obj|mob, и это будет более логично.
Четвертая версия рискует привести к аварийному завершению работы proc. Вместо этого следует проверять, не является ли M нулем, и не разыменовывать его в этом случае. Другой способ - присвоить M значение по умолчанию (например, usr).
«слабая» отсылка
Оператор ":" позволяет сделать еще один шаг вперед, сделав проверку валидности во время компиляции еще менее строгой. Он работает так же, как оператор dot, только полный тип объекта указывать не нужно. Пока хотя бы один объектный тип, производный от указанного, содержит запрашиваемую переменную, компилятор будет ее разрешать. Вам остается следить за тем, чтобы во время выполнения использовались только совместимые объекты (иначе произойдет сбой).
variable:variable 20pt Or 20pt variable:procedure()
Как и оператор dot, оператор ":" не может иметь пробелов между собой и своими аргументами.
Чаще всего этот оператор используется, когда тип объекта вообще не определен. В этом случае компилятор проверяет только то, что хотя бы один объектный тип во всем дереве имеет указанную переменную или процедуру. Эту технику следует использовать не из лени, а когда у вас есть законные причины оставить тип объекта неопределенным. Например, если переменная может содержать ссылки на объекты типов, не имеющих общего предка (например, obj и mob). Однако в большинстве случаев лучше использовать возможности компилятора по проверке типов.
Следующие verb демонстрируют два способа расширить вышеупомянутую команду summon, чтобы она могла принимать в качестве аргументов как мобов, так и объекты.
mob/verb
summon1(obj/M as obj|mob)
M.loc = loc
summon2(M as obj|mob)
M:loc = loc
Первый пример радует компилятор тем, что он лжет о типе переменной. M может быть obj, но может быть и mob. В любом случае у них обоих есть переменная loc, так что во время выполнения все будет работать.
Во втором случае компилятор остается доволен, используя оператор ":" для нестрогой проверки типов. Поскольку для M не объявлен тип, компилятор просто проверяет, есть ли у какого-то типа объекта переменная loc. Поскольку таких типов несколько (примеры - obj, mob и turf), проверка проходит успешно.
Суть в том, что ни строгий, ни нестрогий оператор не влияют на значение самой переменной. Они просто управляют тем, как компилятор выполняет проверку типов. Во время выполнения все, что имеет значение, - это наличие у объекта запрашиваемой переменной.