Данный файл является частью Руководства по TADS для авторов игр.
Copyright © 1987, 1996 Майкл Дж. Робертс
(Michael J. Roberts). Все права защищены.
Руководство было преобразовано в формат HTML Н. К. Гайем (N. K. Guy), компания tela design.
Перевод руководства на русский язык - Валентин Коптельцев
Приложение B
Программа-интерпретатор TADS содержит достаточное количество вспомогательных средств для организации диалогового режима в приключенческих играх, однако не предоставляет никаких определений для игр. Чтобы облегчить задачу авторам, в дистрибутив системы включены файлы стандартных библиотек, содержащие определения для значительного числа базовых объектов и классов, характерных для большинства приключенческих игр. Эти классы носят весьма общий характер и требуют "доводки", однако они позволяют значительно сократить объем рутинной работы со стороны автора. В оригинальном англоязычном варианте эти файлы носят название adv.t и std.t. Библиотеки же русификации системы включают в себя шесть файлов, которые здесь рассматриваются. Все определения каждого из файлов стандартных библиотек автоматически становятся частью игры при включении соответствующего файла в состав исходного текста игры инструкцией include.
В состав библиотек русификации входят следующие файлы:
Первые четыре из этих файлов являются "обязательными" (т. е. будут включены автором в состав исходного игры в подавляющем большинстве случаев, если только автор не пытается добиться каких-то хитрых специальных эффектов). Оставшиеся два представляют собой сравнительно узкоспециализированные расширения стандартных библиотек и понадобятся далеко не каждому.
Данная документация соответствует версии 27 RTADS.
Данный файл является аналогом англоязычной библиотеки adv.t и содержит базовые определения функций, классов и глаголов. Эти определения, скорее всего, будут использоваться в игре без изменений или с минимальными корректировками (это особенно справедливо для начинающих авторов). Поэтому и сам файл advr.t обычно не требует модификации. Если же такая необходимость все же возникла, рекомендуется использовать для изменения функции replace и modify.
Обратите внимание, что наряду со всеми рассмотренными здесь объектами, в англоязычном файле adv.t также определены артикли "a", "an" и "the" (из русского варианта эти определения по понятным причинам исключены и здесь не рассматриваются).
В данном разделе в алфавитном порядке перечислены объекты и функции, определенные в файле advr.t.
При описании объектов указывается родительский класс или классы для данного объекта; чтобы получить полное представление об объекте, вам понадобится обратиться также и к описаниям его родительских классов. Кроме того, в описаниях указываются основные свойства объектов; для использования объекта в вашей игре вам, скорее всего, понадобится переопределить часть или все эти свойства по-своему. Например, для большинства объектов-наследников класса thing потребуется определить свойство sdesc, чтобы обеспечить соответствующий предмет именем.
Описания функций содержат информацию о формате вызова функций, их назначении и возвращаемых значениях.
_rand: function(x): модифицированная версия встроенного генератора случайных чисел (функции rand), обеспечивающая более равномерное распределение формируемых значений. Как и прототип, возвращает случайное число в диапазоне от 1 до x (x должен быть положительным целым числом).
addbulk: function(list): функция возвращает сумму объемов объектов списка list (объем объекта определяется его свойством bulk). При этом учитываются объемы только самих объектов в списке, а не их содержимого, поскольку подразумевается, что объект не изменяется в объеме, если в него что-нибудь положить. Вы можете легко обойти это соглашение для специальных объектов (например, сумки-авоськи, растягивающейся, когда в нее что-либо кладут), определив для них свойство bulk в виде метода, учитывающего изменение объема контейнера при помещении в него других объектов.
addweight: function(list): функция складывает веса объектов, содержащихся в списке list, и возвращает полученную сумму. Вес объекта определяется его свойством weight. Данная функия учитывает веса содержимого объектов из списка, а также веса содержимого этого содержимого и т. д.
checkDoor: function(d, r): используется для проверки состояния двери d. Если эта дверь открыта, функция возвращает комнату r, не выводя никаких сообщений. Если же дверь закрыта, то выводится сообщение о том, что дверь закрыта, и функция возвращает nil.
checkReach: function(loc, actor, v, obj): проверяет, может ли актер (персонаж) actor манипулировать объектом obj при помощи глагола v, находясь в комнате loc. Функция используется на этапе валидации (проверки корректности) команды. Эта функция разрешает дальнейшую обработку команды, если obj - это объект специального типа (numObj или strObj), если этот объект находится в инвентаре актера actor, а также в том случае, если он внесен в список reachable комнаты loc. Во всех прочих случаях возвращается выводится сообщение об ошибке, что на этапе валидации автоматически означает отказ от дальнейшей обработки.
contentsListable: function(obj): проверяет, выводится ли список содержимого объекта obj при проверке инвентаря или в описании локации. Возвращает true, если содержимое объекта obj является видимым, а сам этот объект не является "молчаливым" контейнером или поверхностью.
incscore: function(amount): добавляет значение amount к общему числу набранных игроком очков, которое хранится в свойстве global.score. Всегда используйте эту процедуру вместо прямого изменения значения свойства score объекта global, поскольку incscore также обеспечивает обновление строки статуса при изменении счета.
initRestart: function(parm): устанавливает флаг, указывающий на то, что произошел перезапуск игры (игрок дал команду RESTART). Это позволяет при желании обрабатывать такую ситуацию особым образом; например, если в игре имеется длинный вводной текст, то при ее перезапуске его можно будет опустить, чтобы не утомлять игрока.
initSearch: function: инициализирует контейнеры объектов, для которых определены свойства searchLoc, underLoc или behindLoc путем занесения этих объектов соответственно в списки searchCont, underCont и behindCont контейнеров. Для правильной инициализации контейнеров эту процедуру следует вызывать один раз в начале игры (из функции preinit или init - на усмотрение автора).
inputline: function: данная функция является "оболочкой" для встроенной функции input, служащей, в свою очередь, для ввода текста пользователем. В режиме HTML функция inputline обеспечивает переключение шрифта на тот, который используется при вводе команд игроком. Вследствие этого все вводимые игроком символы, считываемые при помощи этой функции, печатаются на экране стандартным шрифтом для ввода команд. Функция возвращает строку, введенную пользователем (игроком).
isIndistinguishable: function(obj1, obj2): возвращает true, если объекты obj1 и obj2 считаются неотличимыми друг от друга при анализе списков объектов. Если два объекта признаны неотличимыми, то функции, выполняющие анализ и вызов списков (например, такие, как itemcnt, listcontgen и т. д.) считают их, как один объект, и выводят их в списке (или учитывают при вычислении количества элементов списка) только один раз. Объекты признаются эквивалентными (функция возвращает true), если у них обоих свойство isEquivalent определено равным true, для них совпадают прямые родительские классы (т. е. классы, непосредственными наследниками которых являются эти объекты; проще говоря, это те классы, которые присутствуют в заголовке определения объекта (типа object: class)), а также значения основных свойств (в стандартном варианте функция анализирует свойство isworn, а также комбинацию свойств (islamp and islit), однако при необходимости можно добавить и другие свойства).
itemcnt: function(list ): возвращает количество "отображаемых" объектов в списке list. Объект является отображаемым, если для него определено свойство isListed, равное true. При этом неразличимые объекты считаются как один объект. Эту функцию удобно использовать, чтобы определить, сколько всего объектов будет перечислено в описании комнаты.
listcont: function(obj): данная процедура выводит содержимое объекта obj в виде списка, разделенного запятыми. Задача отображения вводной конструкции перед списком (например, фразы типа "в коробке лежат"), а также завершения списка (обычно точкой) возлагается на функцию, вызывающую listcont. Объект выводится в списке только в том случае, если его свойство isListed имеет значение true. Если в списке имеется несколько неразличимых объектов (см. функцию isIndistinguishable), они выводятся только один раз (с указанием их количества). См. также listcontcont, listfixedcontcont, nestlistcont и showcontcont.
listcontcont: function(obj): процедура выводит содержимое объектов, содержащихся в объекте obj. Список выводится в форме законченных фраз, поэтому открывающего и завершающего текста не требуется. Выводится список содержимого любого объекта, перечисленного в списке contents объекта obj, у которого свойство contentsVisible имеет значение true. Содержимое объектов, для которых определено свойство isqcontainer или isqsurface, имеющее значение true, на экран не выводится. См. также listcont, listfixedcontcont, nestlistcont и showcontcont.
listcontgen: function(obj, flags, indent): это - процедура вывода списков общего назначения. Параметр obj может быть списком - в этом случае процедура просто выводит полученный список - или объектом; в последнем случае выводится список его содержимого. Аргумент flags определяет, каким именно образом должен выводиться список - в столбик или в строчку через запятую, количество отступов при выводе списка нижнего уровня (например, если у нас есть коробка, в которой лежит множество предметов, среди которых - сумка, в которой тоже что-то лежит), а также указывает, до какого уровня следует выводить содержимое объектов, которые находятся в объекте obj. Для этих целей используются предопределенные символы компилятора LCG_TALL, LCG_CHECKVIS и LCG_RECURSE. Параметр indent задает величину отступа. Данная процедура является процедурой "низкого" уровня, поэтому напрямую ее использовать вам, скорее всего, не понадобится. Вместо нее рекомендуется пользоваться следующими процедурами, обращающимися к listcontgen в процессе своей работы: listcont, listcontcont, listfixedcontcont, nestlistcont и showcontcont.
listfixedcontcont: function(obj): выводит содержимое всех объектов класса fixeditem, которые содежатся в объекте obj. Благодаря этой процедуре все объекты, которые игрок может взять, отображаются где-либо в описании комнаты. Эта процедура рекурсивно проходит по "дереву объектов", содержащихся в объекте obj, выводя содержимое каждого из них, перебирая каждую ветвь до тех пор, пока не будет выведен список объектов или ветвь не окажется " "пустой", т. е. не содержащей отображаемых объектов. Список выводится в форме законченной фразы, поэтому никакого открывающего или завершаюего текста не требуется. См. также listcontcont, listcont, nestlistcont и showcontcont.
mainRestore: function(fname): восстанавливает игру из файла с именем fname. При успешном восстановлении возвращает true, при ошибке - nil. При успешном восстановлении игры функция обновляет строку статуса и выводит подробное ("длинное") описание текущей локации. Эта функция используется командой restore. Если вас устраивает стандартная процедура восстановления игры, модифицировать данную функцию в процессе написания игры вам вряд ли понадобится.
nestlistcont: function(obj, depth): процедура выводит содержимое объекта obj в виде списка в столбик, при этом также отображается содержимое объектов, входящих в этот список. Содержимое объектов из списка будет отображаться только в том случае, если они видимы (грубо говоря, содержащий их объект прозрачен или открыт). Параметр depth определяет наличие отступа при выводе содержимого элементов списка. Если этот параметр равен 1, то список будет выводиться с отступами согласно иерархии; как правило, используется именно такой вывод, однако в некоторых случаях может потребоваться вывод списка без отступов - тогда параметр depth должен быть равен 0. См. также listcontcont, listfixedcontcont и showcontcont.
numbered_cleanup: function(obj): эта процедура используется в качестве запала для удаления объектов, создаваемых классом numberedObject при вызове его метода newNumbered. При создании нового объекта этот метод устанавливает запал, вызывающий настоящую функцию в конце хода для удаления только что созданного объекта. Функция является служебной и вряд ли понадобится при написании игры.
reachableList: function(obj): функция возвращает список всех содержащихся в объекте obj объектов, которыми игрок может манипулировать. Это означает, что, если объект-контейнер открыт или является контейнером "без крышки", то функция возвращает содержимое объекта, плюс результат выполнения функции reachableList над каждым из содержащихся в obj объектов; если объект является закрытым контейнером, возвращается пустой список. См. также visibleList.
sayPrefixCount: function(cnt): выводит количество cnt (используется при выводе списков, например, во фразах типа "на столе лежит восемь яблок." Если cnt меньше или равно двадцати, выводит число прописью (например, "восемь яблок"), в противном случае выводит его в цифровой форме ("80 яблок").
scoreFormat: function(points, turns): данная функция возвращает отформатированную строку, составленную из количества набранных очков (параметр points) и числа затраченных ходов (параметр turns), разделенных наклонной чертой. Эта информация отображается обычно в правой части строки статуса. Если вам потребуется отобразить другую информацию, вы можете соответствующим образом модифицировать эту фунцию, чтобы она возвращала строку нужного вам вида. См. также scoreStatus.
scoreStatus: function(points, turns): эта процедура обеспечивает обновление строки статуса игры. В стандартном варианте отображается число набранных игроком очков (параметр points) и количество затраченных им ходов (параметр turns). Вывод осуществляется средствами встроенной функции setscore(); собственно, по умолчанию scoreStatus содержит только вызов этой функции. Вызов локализован в данной процедуре для того, чтобы автору было легче заменить стандартный формат строки статуса на свой, оригинальный (для этого достаточно будет отредактировать scoreStatus). См. также scoreFormat.
showcontcont: function(obj): процедура выводит содержимое объекта obj, а также содержимое контейнеров и поверхностей (объектов класса surface и container), содержащихся в объекте obj. Список выводится в виде законченной фразы. Это - внутренняя процедура, используемая процедурами listcontcont и listfixedcontcont. См. также процедуру nestlistcont.
switchPlayer: function(newPlayer): назначает в качестве главного персонажа (за которого играет игрок) нового актера. В данной процедуре используется встроенная функция parserSetMe() для изменения регистрационной записи главного персонажа (далее ГП) в синтаксическом анализаторе, а также производятся необходимые изменения объектов, соответствущих текущему и будущему ГП. Во-первых, поскольку по принятым в TADS соглашениям ГП никогда не входит в список содержимого комнаты, где он находится, текущий ГП заносится в этот список, а будущий ГП из него исключается. Во-вторых, слова "я", "меня" и т. д. удаляются из лексических свойств "старого" ГП и добавляются в лексические свойства нового.
turncount: function(parm): данная функция используется обычно в качестве демона (как правило, инциируемого функцией init), обновляющего счетчик ходов (свойство turnsofar объекта global) после каждого хода. После обновления счетчика (увеличения его на 1) функция осуществляет вызов scoreStatus, чтобы обновить строку статуса.
visibleList: function(obj, actor): функция возвращает список всех содержащихся в объекте obj объектов, видимых актером actor. Работает аналогично функции reachableList.
Это в основном функции, отвечающие за отображение слов в различных формах и с различными окончаниями. Они необходимы в связи со значительно более сложным словообразованием в русском языке по сравнению с английским.
additionalPreparsing: function(str): функция-"заглушка", которая используется для подключения модуля проверки орфографии spellchecker.t от Михаила Гранкина. В настоящее время этот модуль не входит в стандартный дистрибутив библиотек RTADS.
dezyo: function(str): заменяет в строке str все буквы "ё" на "е". Используется при предварительной обработке введенной игроком строки до передачи этой строки синтаксическому анализатору.
dToS: function(obj, prop): преобразует свойство prop объекта obj, которое должно быть заключенной в двойные кавычки строкой, в строку, заключенную в одинарные кавычки. Возвращаемое значение - полученная строка (в одинарных кавычках). Функция предоставлена Майком Робертсом.
ella: function(obj): формирует и выводит окончания невозвратных глаголов в прошедшем времени аналогично функции glsok, однако для анализа вместо передаваемых аргументов используются свойство gender объекта obj. См. также функции iao, saas.
glok: function(obj,...): функция выводит глагол с окончанием в настоящем времени в соответствии с правилами русского языка.
Работает в двух основных режимах.
В первом случае получает три аргумента: obj - объект-глагол, sprag - спряжение глагола (1 или 2),
type - флаг, указывающий на смягчение окончания глагола (наличие "й" в гласной; при наличии в окончании букв "я",
"ё", "ю" этот аргумент должен быть равен 2, в противном случае - 1). Четвертым опциональным аргументом в этом случае может быть
строка. При наличии такого аргумента функция будет менять лицо глагола (например, "можешь" вместо "могу").
Во втором режиме - передается два аргумента: объект-глагол и строковый аргумент, содержащий глагол в неопределенной форме (ударность окончания глагола
при этом обозначается заглавной гласной буквой).
Функция может также использовать комбинацию этих режимов. В этом случае ей передается три аргумента, последний из которых должен быть строкой.
В этом случае осуществляется автоматическая генерация формы глагола с окончанием, при этом спряжение глагола определяется на основании второго
переданного аргумента, а третий аргумент считается глаголом в неопределенной форме.
glsok: function(ca, grod, mrod, chislo): формирует и выводит окончания глаголов в прошедшем времени в
соответствии с правилами русского языка. Аргументы: ca - признак типа глагола, может принимать значения 0,
1 или 2; если этот аргумент равен 0, выводятся окончания типа "и", "а", "о"; когда он
равен 1, это означает, что глагол является возвратным (с окончанием "ся"), и формируются окончания
"ись", "ась", "ось", "ся"; при значении 2 этого аргумента формируются окончания
типа "ли", "ел", "ла" "ло". Аргументы grod, mrod - признаки
женского и мужского рода, соответственно (например, для фраз типа "она пошла", "он пошел"), могут
принимать значения nil или true; если оба этих признака имеют одинаковое значение (неважно, какое), то
это интерпретируется как средний род, и выводится соответствующее окончание; chislo - определяет число, в котором
употреблен глагол; если в единственном, принимает значение nil, а если во множественном - true.
В настоящее время функция считается устаревшей и не используется.
iao: function(obj): формирует и выводит окончания глаголов в прошедшем времени аналогично функции glsok, однако для анализа вместо передаваемых аргументов используются свойство gender объекта obj. См. также функции ella, saas, yao.
kpstok: function(mrod, grod, chislo): функция используется для добавления окончаний кратким страдательным причастиям (типа ОТКРЫТ(А, О, Ы)). Если слово имеет множественное число (аргумент chislo равен true), функция выводит окончание "ы". Если слово имеет единственное число (аргумент chislo равен nil) и мужской род (mrod равен true), то окончания не выводится; для единственного числа и женского рода (grod = true) выводится окончание "а". Наконец, если оба аргумента mrod и grod имеют одинаковое значение (true или nil - неважно), то выводится окончание для среднего рода ("о"). Данная функция является устаревшей, и вместо нее рекомендуется использовать yao. (Собственно, из последних версий русскоязычных библиотек она исключена).
loweru: function(oldstr): переводит строку oldstr в нижний регистр. Необходимость в данной функции возникает вследствие того, что встроенные средства TADS не понимают кириллицу, в связи с чем, если данную функцию не использовать, то введенное игроком слово с разными комбинациями прописных и строчных букв (например, "кот", "коТ" и "КОт") будет восприниматься синтаксическим анализатором как разные слова. Поскольку задать ВСЕ возможные комбинации букв для каждого лексического свойства объекта совершенно нереально, остается либо ограничить список допустимых символов, понимаемых игрой, прописными или строчными буквами, либо (что удобнее с точки зроения игрока) использовать такую функцию преобразования. Более подробно о работе синтаксического анализатора см. соответствующий раздел документации.
lowerru: function(oldstr): функция-"обертка" для loweru, позволяющая обращаться к ней с помощью обоих имен (loweru и lowerru).
numok (num, s1, s4, s5): выбирает и выводит одно из окончаний s1, s4 или s5 (которые должны быть строками, заключенными в одинарные кавычки) в зависимости от числа num. Окончание s1 выводится для num = 1, s2 - для num = 2..4, s5 - для num = 5..9, а также 0.
ok (obj, textIfIsThem, textIfIsHim, textIfIsNeuter, textIfIsHer) : универсальная функция вывода окончаний на основании свойства gender объекта obj. Выводимые окончания определяются остальными четырьмя параметрами (которые должны быть строками, заключенными в двойные кавычки): textIfIsThem выводится, если объект имеет множественное число (его свойство gender имеет значение 3), textIfIsHim - если gender=1 (признак мужского рода), textIfIsHer - если gender=2 (признак женского рода), textIfIsNeuter - при всех остальных значения свойства gender.
opro: function(word): пытается распознать, в каком падеже - винительном или предложном - стоит слово word и возвращает 'о' для предложного падежа и 'про' для винительного (а также в тех случаях, если не удалось определить падеж).
oyay: function(obj): формирует и выводит окончания прилагательных в первом лице в соответствии с правилами русского языка (типа "ие", "ая", "ой", "ое"). Для выбора нужного окончания используются свойства объекта obj: isThem - определяет число (если оно равно true, то число множественное, если nil - единственное); isHer и isHim, также принимающие значения true или nil - определяют соответственно женский и мужской род. Если оба последних свойства имеют одинаковое значение (неважно, какое), то функция считает, что объект obj - среднего рода. Функция устарела, из последних версий библиотек русификации она исключена.
Данная функция является так называемой точкой входа и служит для модификации работы синтаксического анализатора. Подробно ее работа рассмотрена в разделе документации, посвященном синтаксическому анализатору.
Данная функция является так называемой точкой входа и служит для модификации работы синтаксического анализатора. Подробно ее работа рассмотрена в разделе документации, посвященном синтаксическому анализатору.
Данная функция является так называемой точкой входа и служит для модификации работы синтаксического анализатора. Подробно ее работа рассмотрена в разделе документации, посвященном синтаксическому анализатору.
Данная функция является так называемой точкой входа и служит для модификации работы синтаксического анализатора. Подробно ее работа рассмотрена в разделе документации, посвященном синтаксическому анализатору.
replaceStr: function(str, pattern, replacement): осуществляет замену шаблона pattern в строке str на значение replacement.
replaceSelf: function(str): служебная функция, заменяющая в строке str слово "себя" на подходящее обращение к персонажу, выполняющему текущую команду (упрощенно говоря, "Вася, осмотри себя" заменяется на "Вася, осмотри Васю").
saas: function(obj): формирует и выводит окончания возвратных глаголов в прошедшем времени аналогично функции glsok, однако для анализа вместо передаваемых аргументов используются свойство gender объекта obj. См. также функции ella, iao.
TrimLeft: function(str): убирает начальные пробелы в строке str.
yao: function(obj): добавляет русские окончания кратким причастиям страдательного типа (например, "открыт(а, о, ы)") в зависимости от значения свойства gender переданного в качестве аргумента объекта obj.
ZA: function(str): преобразует первую букву строкового аргумента str (который представляет собой строку, заключенную в одинарные кавычки) в заглавную (это происходит только в том случае, если первый символ str - это строчная буква русского алфавита; для всех остальных символов, в т. ч. для букв латинского алфавита, ничего не происходит), а затем выводит получившуюся строку на экран. Необходимость в данной функции возникает в связи с тем, что встроенная функция caps() не работает с кириллицей. См. также функцию ZAG.
ZAG: function(obj, prop): аналог встроенной функции TADS caps() для кириллицы. Меняет первую букву свойства prop объекта obj, которое должно быть строкой, заключенной в двойные кавычки, на заглавную (работает только для строчных букв кириллицы; если первый символ prop иной, то он не меняется), после чего результирующая строка выводится на экран. См. также функцию ZA.
Здесь описаны основные классы и объекты, соответствующие предметам в игровом мире, с пояснениями по основным свойствам и методам, которые может потребоваться переопределить при разработке игры.
Actor: fixeditem, movableActor. Персонаж в игре. Свойство maxweight определяет максимальный вес (сумму свойств weight всех объектов в инвентаре), а свойство maxbulk - максимальный объем (соответственно, сумму свойств bulk), который этот персонаж (иначе называемый актером) может носить с собой. Метод actorAction(verb, directObject, preposition, indirectObject) определяет реакцию персонажа на команду игрока (по умолчанию персонаж игнорирует команду, при этом выводится соответствующее сообщение). При этом следует учесть, что если при обработке этого метода программа-интерпретатор не встретит инструкцию exit, то, выполнив все указанные в методе действия, команда далее будет обрабатываться как ни в чем не бывало (что, как правило, нежелательно) (см. также описание данного метода для класса thing). Метод isCarrying(object) возвращает true, если предмет object находится в инвентаре персонажа (даже в случае, если персонаж несет контейнер, в котором (с любым уровнем вложений) находится предмет). Метод actorDesc служит для отображения сообщения, что персонаж находится в комнате; это сообщение выводится при отображении описания комнаты. Метод verGrab(object) вызывается при попытке взять какой-либо предмет из инвентаря персонажа; по умолчанию персонажи не отдают то, что у них в руках. См. также определение данного метода для класса thing).
Если требуется, чтобы игрок мог следовать за персонажем (команда "следовать за..."), следует создать объект-"тень" класса follower и установить свойство myfollower персонажа равным данному объекту. При этом объект-"тень" автоматически будет перемещаться за персонажем, отставая от него на один ход, чтобы игрок мог следовать за ним.
basicMe: Actor, floatingItem. Реализация по умолчанию для объекта, соответствующего игроку (этот объект, как правило, носит название Me). В файле advr.t определен класс basicMe, а не объект Me, чтобы автор игры мог заменить часть определений по умолчанию, сохранив большую их часть, и не модифицироваь при этом файл advr.t непосредственно. Чтобы использовать класс basicMe в качестве главного персонажа вашей игры без изменений, включите в код вашей игры следующую инструкцию: "Me: basicMe;".
В классе basicMe определяются все те же методы и атрибуты, что и для прочих персонажей, с указанием соответствующих значений для главного персонажа. Для него определено лексическое свойство noun c указанием различных форм местоимения "я". Свойство sdesc выводит "ты"; соответствующим образом определены также свойства, отвечающие за отображение краткого описания в различных падежах, а также форматные строки. Кроме того, переопределены методы actorAction (чтобы главному персонажу можно было давать команды), travelTo, moveInto и ряд других.
basicNumObj: object. Данный класс является реализацией по умолчанию для так называемого нумерованного объекта (или объекта-числа) numObj (такой объект используется, например, в качестве значений для объектов класса dialItem в командах вида "установить переключатель на 8"). Атрибут value соответствует текущему числу (в рассмотренной выше команде он будет равен восьми). Чтобы использовать данный класс без изменений, включите в Вашу игру следующее определение: "numObj: basicNumObj;".
basicStrObj: object. Данный класс является реализацией по умолчанию для так называемого строкового объекта (или объекта-строки) strObj (такой объект используется для представления в вводимых игроком командах строк в двойных кавычках, например, "напечатать "привет" на клавиатуре"). Атрибут value соответствует текущей строке (в рассмотренной выше команде он будет равен "привет"). Чтобы использовать данный класс без изменений, включите в Вашу игру следующее определение: "strObj: basicStrObj;".
beditem: chairitem. Объект-кровать. В целом аналогичен объекту-стулу (chairitem); единственное отличие состоит в том, что игрок описывается лежащим на объекте, а не сидящим.
behindHider: hider. Этот класс аналогичен классу underHider, только предметы скрываются не под, а за "объектом-укрытием". Для спрятанных за объектом данного класса предметов свойство behindLoc должно ссылаться на "объект-укрытие". См. также searchHider.
Объекты, скрываемые посредством объекта класса behindHider, должны принадлежать классу hiddenItem.
buttonitem: fixeditem. Объект-кнопка (нажимаемая). Для объектов этого класса автор игры должен определить собственный метод doPush(actor), обрабатывающий команду "нажать на..." и выполняющий все требуемые действия. Обратите внимание, что для всех кнопок определено лексическое свойство-существительное "кнопка" (его тоже можно переопределить).
chairitem: fixeditem, nestedroom, surface. Объект-стул, на котором игрок и другие персонажи могут сидеть. Сидя на стуле, персонаж не может никуда переместиться, пока не встанет, и может манипулировать только объектами, включенными в список, определяемый свойством reachable стула. Обратите внимание, что между стульями и кроватями в стандартном варианте нет сколь-либо значительных различий, и как на стульях, так и на кроватях можно и сидеть, и лежать; единственная разница состоит в выводимом при этом сообщении. Свойство ischair является флагом, определяющим принадлежность к данному классу (для стульев оно имеет значение true, для других родственных объектов - nil). См. также beditem.
clothingItem: item. Предмет одежды. По умолчанию, когда игрок надевает на себя одежду, не происходит ничего, кроме того, что атрибут isworn устанавливается равным true. Для реализации каких-либо других эффектов требуется переопределить метод doWear(actor) для данного класса. Кроме того, обратите внимание, что, когда предмет этого класса надет на игрока (или - в общем случае - на другого персонажа), выполнение определенных действий автоматически приведет к тому, что данный персонаж снимет этот предмет одежды (например, если дать команду "бросить предмет"). Чтобы добиться иного порядка обработки таких команд, переопределите метод checkDrop; если вы хотите запретить такие действия над предметом, когда предмет надет на персонажа, включите в метод checkDrop инструкцию exit.
container: item. Объект-контейнер, в который можно класть другие предметы. Атрибут-флаг iscontainer установлен равным true. Свойство ldesc для данного класса по умолчанию выводит список предметов, находящихся в нем (если таковые имеются). Атрибут maxbulk определяет максимальный объем предметов (определеяемый как сумма атрибутов bulk всех предметов - см. также класс thing), который можно поместить в контейнер (по умолчанию этот атрибут равен 10). Свойство isopen, определяющее, открыт ли контейнер, здесь установлено равным true (на самом деле контейнер, определенный как потомок данного класса без модификации, вообще не закрывается). См. также класс surface.
darkroom: room. Темная комната. Чтобы перемещаться по ней, а также выполнять большую часть других действий, игроку необходимо принести в нее источник света (объект класса lightsource). Обратите внимание, что освещение в комнате можно также включить, установив его свойство lightsOn равным true. Лучше включать освещение именно таким образом, а не установкой свойства islit, поскольку последнее является методом, проверяющим наличие источника света в комнате.
darkVerb: deepverb. Глагол, который "работает" в темном помещении (класса darkroom). К таковым относятся все глаголы перемещения (класс travelVerb), а также системные глаголы (типа "сохранить", "восстановить", "отчет"). Кроме того, к этому классу относится еще ряд глаголов: например, в темноте игрок может бросить что-либо из своего инвентаря, или включить фонарь, который он держит в руках. Атрибут-флаг isDarkVerb, равный для данного класса true, служит дополнительным признаком, что тот или иной объект-глагол принадлежит данному классу.
decoration: fixeditem. Объект-декорация, не имеющий никакой функции в игре. Соответствующие предметы нельзя взять, подвинуть либо взаимодействовать с ними каким-либо другим образом; их можно только осмотреть. Использование таких объектов способно повысить "играбельность", поскольку позволяет без значительных трудозатрат обеспечить распознавание синтаксическим анализатором всех слов, которые используются в описании комнаты.
deepverb: object. "Объект-глагол", к которому обращается синтаксический анализатор, когда игрок введет глагол, соответствующий лексическим свойствам этого объекта, в своей команде. Каждый объект данного класса содержит как список глаголов, ему соответствующих, так и описание допустимого синтаксиса команды. Лексическое свойство verb содержит перечисление всех глаголов, при употреблении которых в команде произойдет обращение к данному объекту. Можно использовать как одиночные слова (как, например, 'пройти'), так и пару слов (например, 'пройти сквозь'). В последнем случае второе слово может быть перемещено в конец команды (примечание переводчика: это очень актуально для английского языка и менее актуально для русского. Однако и в русском можно придумать команды, для которых это свойство будет проявляться; например, если определить глагол "поднять" и указать в его свойстве verb словосочетание 'поднять наверх', то игра будет понимать как команду "поднять наверх корзину", так и "поднять корзину наверх"). Метод action(actor) определяет реакцию игры, если глагол употреблен самостоятельно (например, игрок ввел команду "осмотреться" или "север"); если данный метод не определен, то глагол не может быть употреблен таким образом. (Аргумент actor - это персонаж, который должен выполнить команду (по умолчанию это главный персонаж, но, например, в команде вида "Бобик, прыгай" в качестве аргумента actor будет передан объект, соответствующий персонажу (Бобику)). Атрибут doAction определяет общий корень названия методов (должен быть заключен в одинарные кавычки), которые будут обрабатывать команду, состоящую из глагола и "прямого" объекта (команды вида "взять камень" или "прыгнуть через забор"). Например, если для некоторого глагола указано определение doAction='Jump', то обработку команды, состоящей из глагола и "прямого" объекта, будут выполнять методы verDoJump и doJump этого "прямого" объекта. Аналогично, атрибут ioAction(preposition) определяет семейство методов-обработчиков для команды вида "глагол-прямой объект-предлог-косвенный объект" (например, "положи тетрадь на стол"). Аргумент preposition - это предлог, употребляемый с данным глаголом. Для одного глагола можно определять несколько атрибутов ioAction, по одному для каждого предлога. Подробнее о роли и порядке работы методов-обработчиков команд см. в разделе Создание собственных глаголов главы седьмой.
Метод validDo(actor, object, seqno) возвращает true, если указанный объект object допустим в качестве "прямого" объекта для персонажа actor. Аналогичным образом метод validIo(actor, object, seqno) возвращает true, если указанный объект можно использовать в качестве "косвенного". Аргумент seqno в обоих случаях - это номер объекта по порядку (начиная с 1-го) (в командах, где требуется обработка сразу нескольких объектов (например, "взять все"). Как правило, этот параметр игнорируется, но теоретически могут возникнуть случаи, когда может потребоваться его анализ. Например, объект askVerb (соответствующий глаголу "спросить") не делает различий между объектами, соответствующими одному и тому же набору лексических свойств, и поэтому обрабатывает только первый объект из общего списка "подходящих" объектов. Как правило, автору игры эти методы (validDo и validIo) менять не требуется; в общем случае они возвращают true, если объект доступен персонажу для манипуляций.
Методы doDefault(actor, prep, indirectObject) и ioDefault(actor, prep) возвращают список, соответственно, "прямых" и "косвенных" объектов по умолчанию. Эти списки используются для определения того, какие объекты имеются в виду, если в команде используется слово "все", а также подбирают подходящие объекты, если игрок вообще не упомянул в своей команде объектов (например, дал команду "отпереть" вместо "отпереть дверь"). Как правило, эти методы возвращают список всех объектов, для которых применима данная команда (т. е. тех, чьи обработчики-верификаторы, соответствующие данной команде, не выдают сообщений; подробнее об этом см. главу 4).
Методы validDoList(actor, prep, indirectObject) и validIoList(actor, prep, directObject) возвращают список список всех объектов, для которых имеет смысл выполнять, соответственно, validDo или validIo. В принципе без этих методов можно обойтись; их единственная цель - произвести грубую предварительную проверку объектов, чтобы сократить число вызовов validDo и validIo и таким образом повысить производительность (скорость работы) игры - каждое выполнение validDo или validIo требует довольно значительных затрат времени.
Метод padezh_type служит для определения режима работы глагола с родительным, дательным и творительным падежами. Используется при синтаксическом разборе русскоязычных команд, автору игры менять его не требуется. Свойство vopr определяет, какой вопрос будет задавать игра, если игрок пропустил в своей команде объект. Например, если будет дана команда "отпереть", игра задаст вопрос "Что вы хотите отпереть?" (для этого глагола vopr = "Что "), а если ввести "сойти", игра спросит "Откуда вы хотите сойти?" (vopr = "Откуда ").
dialItem: fixeditem. Данный класс используется для создания "циферблатов", т. е. переключателей, которые можно установить на определенное значение (например, таких, как регулятор интенсивности нагрева конфорок бытовой плиты). При реализации объекта этого класса автору необходимо указать значения свойств minsetting и maxsetting, определяющих, соответственно, минимальное и максимальное число, на которое можно установить данный объект (например, для вышеупомянутого регулятора плиты эти значения могут составлять: minsetting = 0 (конфорка выключена), maxsetting = 3 (максимальная степень нагрева - считаем, что регулятор у нас трехступенчатый). По умолчанию эти значения составляют 1 и 10. Свойство setting определяет текущую установку переключателя - она может изменяться игроком посредством команд вида "повернуть переключатель на 3". Метод ldesc для данного класса по умолчанию выводит текущую установку объекта.
distantItem: fixeditem. Определяет предметы, которые находятся слишком далеко, чтобы ими можно было манипулировать, но при этом видны. Реакцией на любые команды, кроме "осмотреть", будет "Предмет слишком далеко." Для объектов-наследников данного класса должны быть определены все обычные свойства предметов: sdesc, ldesc, location, а также лексические свойства.
doorway: fixeditem, obstacle. Объект-дверь, который представляет собой препятствие (obstacle), не дающее перемещаться в заданном направлении до тех пор, пока его не откроют (этому состоянию двери соответствует значение true, возвращаемое свойством isopen). Если дверь открыта, то игрок (или другой персонаж) при движении в соответствующем направлении попадает в комнату, определяемую свойством doordest. Поскольку дверь является препятствием, то для правильной ее реализации следует присвоить соответствующему свойству-направлению комнаты, где дверь находится, значение, равное объекту-двери. Если атрибут noAutoOpen не равен true, дверь будет автоматически открываться при попытке игрока перемещаться в соответствующем направлении, если только эта дверь не заперта (свойство islocked не возвращает true). Если дверь заперта, ее можно открыть вводом команды "отпереть дверь", если свойство mykey не установлено равным какому-либо объекту, который в этом случае выполняет роль ключа (в этом случае дверь можно отпереть, только введя команду "отпереть дверь ключом", при этом для объекта-ключа должны быть определены соответствующие методы (verIoUnlockWith, ioUnlockWith), и, кроме того, он должен иметься в распоряжении игрока). Обратите внимание, что дверь может быть вновь заперта игроком только при соблюдении условий, при которых обеспечивается отпирание двери, а также при выполнении дополнительного условия: свойство islockable должно быть равным true. По умолчанию объект-дверь закрыт; если требуется, чтобы в начале игры дверь была открыта, установите свойство isopen равным true (при этом необходимо, чтобы и другая сторона двери была открыта - см. далее).
Свойство otherside определяет другую сторону двери (если она есть), расположенную в комнате, куда ведет данная дверь (определяемой свойством doordest). Необходимость данного свойства обуславливается тем, что в реальности дверь существует как бы в двух комнатах сразу. Свойство otherside для двери должно ссылаться на объект того же класса doorway (исключение составляют случаи, когда необходимо добиться некоторых спецэффектов, однако при этом автор игры должен весьма четко представлять, чего именно он хочет достичь - рекомендации здесь давать практически невозможно); при взаимной ссылке свойств otherside двух объектов-дверей друг на друга их состояния (двери закрыты-открыты и заперты-отперты - определяются свойствами isopen и islocked соответственно) будут автоматически синхронизироваться.
Прочие свойства: isdoor - атрибут-флаг, маркирующий данный объект как объект-дверь (равен true); setIsopen и setIslocked - служебные методы, которые "отвечают" соответственно за открытие-закрытие и отпирание-запирание двери и, в частности, обеспечивают синхронизацию состояния двери с другой ее стороной, определяемой свойством otherside.
fixeditem: thing. Объект, который невозможно взять или сдвинуть с места каким-либо другим образом. Обратите внимание, что объекты этого класса могут оказаться частью перемещаемого объекта; это делается, в частности, для того, чтобы не допустить разделения объектов, когда один объект является неотъемлемой частью другого (например, чайник и носик чайника). По умолчанию, функции, отвечающие за отображение списка объектов в помещении, не включают в этот список объекты класса fixeditem (поскольку свойство isListed установлено для него равным nil); это сделано потому, что такие объекты обычно включаются автором игры в подробное описание (свойство ldesc) комнаты. В качестве дополнительной индикации того, что объект является неподвижным, для данного класса определено свойство isfixed, равное true.
floatingItem: object. Этот класс служит исключительно для того, чтобы пометить объект-наследник как присутствующий во всех помещениях игры (это полезно, например, при реализации пола или стен - вместо того, чтобы создавать соответствующие объекты для каждой комнаты, достаточно определить их один раз как наследников данного класса). Необходимость определять такие объекты как принадлежащие данному классу связана с тем, что при инициализации игры объекты этого класса заносятся в список global.floatingList, который анализируется на этапе валидации команды игрока методами validDoList и validIoList (описание этих методов см. в классе deepverb).
follower: Actor. Объект-"тень", повторяющий перемещения персонажа из помещения в помещение. Назначение этого класса - позволить игроку следовать за персонажем, который покинул комнату, введя команду "следовать за". Для каждого персонажа, за которым игрок может следовать, должен быть определен отдельный объект класса follower. Объект-"тень" должен иметь идентичные с соответствующим ему персонажем лексические свойства (noun и adjective). Для этого объекта также необходимо определить свойство myactor так, чтобы оно ссылалось на персонажа, за которым будет следовать игрок при помощи данного объекта-"тени". Атрибут isfollower, равный true, дополнительно помечает объект как объект-"тень". "Тень" всегда отстает от персонажа на одну комнату; к ней не применимы никакие команды, кроме "следовать за".
fooditem: item. Объект, который можно съесть. При съедании объект удаляется из игры, а значение свойства global.lastMealTime (время последнего приема пищи) уменьшается на величину свойства foodvalue объекта. По умолчанию значение foodvalue равно global.eatTime (этот параметр определяет максимальное количество ходов, которое игрок (точнее, главный персонаж в игре) может обходиться без еды). Таким образом, стандартного съедобного предмета хватит, чтобы поддержать силы игрока в течение стандартного интервала времени. См. также eatDaemon.
hiddenItem: object. Принадлежность предмета к данному классу указывает на то, что он спрятан при помощи объекта, принадлежащего одному из дочерних классов класса hider. Класс hiddenItem не определяет никаких собственных свойств, а используется исключительно для того, чтобы функция инициализации initSearch могла определить и зарегистрировать такие объекты.
hider: item. Это базовый класс для реализации предметов, служащих для скрытия других предметов различными способами. Напрямую он не используется, вместо него используются его дочерние классы - underHider, behindHider и searchHider. Класс определяет метод searchObj(actor, list), которому передается через аргумент list список предметов, скрытых посредством данного объекта (для объекта класса underHider, к примеру, для этого используется свойство underCont); этот метод позволяет игроку "найти" скрытые предметы при подаче соответствующей команды. Некоторые особенности работы этого метода определяются парой дополнительных свойств, определенных для класса hider. Свойство serialSearch определяет, будут ли найдены сразу все скрытые предметы (в случае, если данный объект используется для скрытия более одного предмета); если оно имеет значение nil (значение по умолчанию), то игрок найдет сразу все предметы, если же оно равно true, игроку придется подать команду поиска несколько раз - по числу скрытых предметов, чтобы найти их все. Свойство autoTake определяет, перемещаются ли найденные предметы в инвентарь игрока автоматически: если оно равно true, то игрок автоматически берет найденные предметы, если же nil, то потребуется в явном виде дать команду, чтобы взять предмет. Метод searchObj удаляет из переданного ему списка list найденные предметы. Вызвавшая этот метод процедура (или метод) должна записать его значение в соответствующую переменную (например, для объекта класса underHider это будет свойство underCont), иначе игрок будет получать сообщение о найденном предмете всякий раз, когда будет обыскивать скрывающий объект.
Обратите внимание, что, поскольку объекты класса hider используются для скрытия других объектов, то в нем переопределен метод verDoSearch, "отвечающий" за верификацию команды "обыскать": здесь он выдает сообщение типа "Тебе нужно более детально описать как ты хочешь обыскать данный предмет". Это сделано потому, что сообщение стандартного метода verDoSearch ("Ты не нашел ничего интересного") вводит игрока в заблуждение, создавая у него впечатление, что предмет уже достаточно тщательно обыскан. С другой стороны, для большинства объектов класса hider ситуация, когда общая команда "обыскать" сразу дает нужный результат, также нежелательна (например, требуется "заглянуть под" некий предмет). Поэтому мы просто выдаем сообщение, что простого обыскивания оказалось недостаточно, но не говорим игроку, что конкретно ему надо сделать.
Объекты, скрываемые посредством объекта класса hider, должны принадлежать классу hiddenItem.
item: thing. Обычный предмет, который игрок может взять и носить с собой. Он ничего не весит (свойство weight имеет значение 0) и занимает минимальный объем (свойство bulk равно 1). Свойству bulk можно присвоить большее, чем единица, значение для громоздких предметов, а для мелких предметов, которые не сказываются на способности игрока нести другие предметы (не занимают руки игрока), типа листа бумаги, это свойство можно установить равным нулю.
keyedLockable: lockable. Данный класс-наследник класса lockable позволяет создать объект-контейнер, который можно отпереть или запереть только при помощи ключа. Ключом будет объект, на который будет ссылаться свойство mykey (при этом сам объект-ключ должен быть наследником класса keyItem).
keyItem: item. Объект, который можно использовать в качестве ключа для объектов класса keyedLockable и lockableDoorway (т. е. отпирать и запирать их). Во всем остальном его поведение соответствует классу item.
lightsource: item. Переносной фонарь, свеча, спичка или другой источник света. Включать и выключать источник света можно при помощи свойства islit. Если это свойство возвращает true, то источник включен (освещает помещение), если же нет, то этот источник совершенно идентичен обычному объекту. Обратите внимание, что стандартное определение класса lightsource определяет метод doTurnon для обработки глагола "включить", обеспечивающий загорание объекта, однако НЕ определяет верификационного метода для этого глагола verDoTurnon. Вследствие этого, если вы определите в вашей игре источник света просто как наследник класса lightsource, его нельзя будет включать и выключать. Чтобы корректно реализовать включение и выключение источника света, сделайте его наследником сразу двух классов - lightsource и switchItem (при этом перечислите классы в определении объекта именно в том порядке, какой здесь указан - в противном случае метод doTurnon класса switchItem "затрет" соответствующий метод класса lightsource). Свойство islamp используется при инициализации игры, в процессе которой, в частности, функцией initSearch регистрируются и заносятся в специальный список все объекты, которые могут служить источниками света (признаком для занесения в список является то, что их свойство islamp равно true). Этот список затем используется в игре для определения, освещена ли та или иная комната (грубо говоря, если в ней присутствует объект из этого списка и он включен, то она освещена, в противном случае выводится описание для темной комнаты). Из сказанного очевидно, что модифицировать это свойство не следует.
lockable: openable. Объект-контейнер, который можно отпирать и запирать; запертое состояние определяется атрибутом islocked (если он равен true, контейнер заперт, и его вначале надо отпереть, чтобы открыть). При этом для отпирания и запирания контейнеров данного класса не требуется ключ; если вы хотите сделать так, чтобы контейнер отпирался и запирался ключом, используйте класс keyedLockable.
lockableDoorway: doorway. Запираемая дверь. Данный класс ничем не отличается от обычной двери (см. doorway), за исключением того, что его атрибуты islockable и islocked установлены равными true. Остальные свойства (в первую очередь otherside и doordest) определяются, как обычно. Если дверь отпирается/запирается при помощи ключа, то свойство mykey следует определить так, чтобы оно ссылалось на объект, который соответствует этому ключу.
movableActor: qcontainer. Этот класс подобен классу Actor, но, в отличие от последнего, игрок может взять персонажа класса movableActor в руки и носить с собой. Данный класс удобно использовать при реализации, например, мелких животных.
Многие атрибуты и методы, определенные в movableActor, описаны при рассмотрении класса Actor. Ниже перечислены прочие свойства класса movableActor.
askWord(word, lst) - функция, используемая при реализации команды "спросить персонажа о чем-либо". Здесь word - это то самое "что-либо", о котором спрашивают, а lst - полный список слов в команде (скорее всего, вам не потребуется его анализировать). В настоящее время команды такого вида реализуются не так, как это описано в главе седьмой настоящего Руководства (при выборе ответа анализируется не объект, о котором спрашивается, а слово, которое этому объекту соответствует). Если у вас в игре имеется, скажем, штук 8 объектов, к каждому из которых будет применимо слово "колесо", вы наверняка оцените преимущество такого способа реализации диалога. Если метод askWord возвращает true, дальнейшая обработка слова прекращается, поскольку считается, что персонаж уже ответил. В противном случае вызывается метод disavow. По умолчанию askWord просто возвращает nil, и для реализации осмысленного диалога с персонажем вам обязательно потребуется ее переопределить.
disavow - метод, выводящий ответ персонажа на команду вида "спросить клоуна о цирке" в случае, если персонаж не смог дать осмысленного ответа на поставленный вопрос (см. метод askWord). По умолчанию выводится ответ "Не могу сказать об этом ничего конкретного."
fmtMe, fmtYou, fmtYour, fmtYoum, fmtYouve - определяют "форматные" строки, позволяющие отображать универсальную реакцию предметов на применяемые к ним команды (этот вопрос рассматривается в другом разделе Руководства по TADS; если коротко, то за счет использования "форматных" строк можно добиться, чтобы при попытке манипулировать предметом (например, командой "взять мяч") выдавалось бы сообщение типа "Ты не можешь взять мяч", если действие пытается выполнить сам игрок, либо, например, "Он не может взять мяч", если игрок дал команду на выполнение действия какому-либо другому персонажу (скажем, "мальчик, возьми мяч").
isactor - специальный флаг, который для персонажей установлен равным true. Служит в качестве дополнительной проверки, является ли тот или иной объект персонажем или просто предметом.
preferredActor - служит для маркировки предпочтительного персонажа при неоднозначной команде (т. е. команде, которая может относиться сразу к двум или более персонажам); персонажам, для которых этот атрибут равен true, будет оказываться предпочтение перед теми, для которых он равен nil.
sayLeaving, sayArriving - методы, выводящие сообщение о том, что персонаж, соответственно, вышел из помещения или вошел в него.
talkdesc - выдает строку, которая выводится на экран, когда игрок пытается поговорить с персонажем, дав команду "поговорить с". По умолчанию выводится "Обычно рассказывают о чём-то или спрашивают о чём-то"; тем самым игроку дают понять, что для организации диалога лучше воспользоваться командами "спросить" или "рассказать".
travelTo(room) - перемещает персонажа в комнату room, в случае необходимости уведомляя игрока, что персонаж вышел из той комнаты, где находится игрок, или, наоборот, вошел в нее.
Блок свойств-указателей на свойства-направления комнаты (см. также объект room): northProp, southProp, eastProp, westProp, neProp, nwProp, seProp, swProp, inProp, outProp, upProp, downProp. Эти свойства определяют, какое свойство-направление комнаты, в которой находится персонаж, будет вызываться при попытке персонажа двигаться в том или ином направлении (перечисленные свойства соответствуют (в порядке перечисления) северу, югу, востоку, западу, северо-востоку, северо-западу, юго-востоку, юго-западу, входу, выходу, верху и низу). Этот механизм позволяет определять разные выходы из помещения для игрока и других персонажей (например, закрывать для игрока некоторые из направлений, доступных персонажам).
nestedroom: room. "Вложенная" комната - особый тип комнаты, которая
расположена внутри другой комнаты; в эту категорию попадают, например, стулья, а также некоторые виды
транспортных средств (надувные лодки, велосипеды...). Обратите внимание, что одну комнату можно поместить в
другую, даже если она не относится к классу nestedroom; для этого достаточно просто приравнять
"внешней" комнате ее свойство location. Коренное отличие nestedroom от обычной
локации состоит в том, что эта комната "открыта"; когда игрок находится внутри нее, то игра при
выводе описаний указывает, что он находится во "внешней" (или основной) локации (например,
выводится описание типа "Лаборатория, на стуле"). Кроме того, объекту nestedroom
соответствует предмет в мире игры, который игрок видит и с которым он может взаимодействовать; например, стул,
помимо того, что является локацией, также представляет собой предмет в основной комнате. Свойство
statusPrep указывает предлог, который используется в описании, когда игрок находится внутри
"вложенной" комнаты ("Гостиная, на диване") По умолчанию используется
предлог "в", но некоторые дочерние классы (и объекты) его переопределяют. Свойство outOfPrep
определяет предлог, который используется при выводе сообщения, когда игрок покидает "вложенную"
комнату; это могут быть предлоги "из" или "с(о)" - в зависимости от объекта.
Свойство canReachContents - это флаг, указывающий, каким образом игрок может манипулировать предметами из списка reachable
данного объекта. Если оно равно true, то игрок может манипулировать не только самими этими объектами, но и их содержимым. Если же оно
равно nil, то игрок не имеет доступа к содержимому объектов в списке reachable (самими этими объектами он манипулировать
по-прежнему может). Однако установка такого значения для canReachContents, скорее всего, будет нежелательна. Само это свойство
используется в основном для обеспечения обратной совместимости с предыдущими версиями системных библиотек, в которых все потомки
класса nestedroom вели себя так, как если бы canReachContents было равно true, за исключением класса
chairitem. Для обеспечения единообразного поведения всех подобных объектов в игре просто установите свойство
canReachContents для класса chairitem равным true.
Метод cantReachRoom(otherRoom) вызывается в том случае, если персонаж находится в данной "вложенной" комнате и при этом
пытается манипулировать предметом, который видим, но не достижим. Это обычно означает, что объект расположен
во "внешней" по отношению к текущей локации (или внутри объекта во "внешней" локации), но не входит в список reachable
для текущей комнаты.
См. также beditem, chairitem,
vehicle.
numberedObject: object. Этот класс можно использовать для того, чтобы принадлежащий этому классу объект мог использоваться в качестве нумерованного предмета, к которому игрок может в процессе игры обращаться по его номеру. Например, можно создать объект-"кнопку", к которому игрок сможет обращаться при помощи совосочетаний, например, "кнопка 100", "кнопка 1000". Если вы хотите ограничить интервал допустимых номеров, измените метод num_is_valid таким образом, чтобы он отображал соответствующее сообщение об ошибке и возвращал nil при вводе неправильного номера. Если вам необходим отдельный объект для обработки обращений к кнопкам во множественном числе ("посмотреть на кнопки"), измените метод newNumberedPlural так, чтобы он возвращал тот объект, который должен обрабатывать такие обращения; по умолчанию они обрабатываются тем же нумерованным объектом.
obstacle: object. Объект-препятствие, который указывается в свойствах-направлениях комнаты (класс room) вместо ссылки на другую комнату. При этом свойство destination должно возвращать ссылку на комнату, куда должен попасть игрок (или другой персонаж), когда успешно преодолеет препятствие (например, отопрет дверь). Если преодолеть препятствие не удастся, свойство destination должно выводить соответствующее сообщение и возвращать nil. Атрибут isobstacle - флаг, помечающий объект-препятствие как принадлежащий классу obstacle (по умолчанию определен равным true для данного класса).
openable: container. Объект-контейнер, который можно открывать и закрывать. Атрибут isopenable, определяющий принадлежность объекта данному классу, установлен равным true. Свойство ldesc по умолчанию выводит список предметов, содержащихся в контейнере, если он открыт, или сообщение о том, что контейнер закрыт, в противном случае. Атрибут isopen, определяющий, открыт контейнер или нет, по умолчанию установлен равным true (т. е. контейнер открыт); его значение изменяется соответствующим образом при обработке команд вида "открыть контейнер" и "закрыть контейнер". Если вначале игры требуется, чтобы контейнер был закрыт, следует при описании объекта присвоить данному атрибуту свойство nil.
Prep: object. Объект-предлог. Лексическое свойство.
qcontainer: container. "Молчаливый" контейнер, т. е. контейнер, для которого не выводится список предметов, находящихся в нем, пока игрок специально не осмотрит его. Данный класс отличается от своего родительского класса только тем, что для него определен равным true атрибут-флаг isqcontainer, который анализируется методами класса container при принятии решения, выводить ли список предметов, находящихся в данном контейнере, или нет.
qsurface: surface. "Молчаливая" поверхность, т. е. поверхность, для которой не выводится список предметов, лежащих на ней, пока игрок специально ее не осмотрит. Данный класс отличается от своего родительского класса только тем, что для него определен равным true атрибут-флаг isqsurface, который анализируется методами класса surface при принятии решения, выводить ли список предметов, лежащих на данной поверхности, или нет.
readable: item. Предмет, который можно читать. При чтении объекта этого класса (например, команда "прочитать книгу") будет выполнено свойство readdesc. По умолчанию readdesc совпадает с ldesc, но автор игры может переопределить свойство так, чтобы, например, отображался другой текст.
room: thing. Комната (локация) в игре. По умолчанию свойство islit равно true, что означает, что комната освещена (для того, чтобы осмотреться в ней, не требуется дополнительный источник света). Чтобы создать неосвещенную комнату, лучше воспользоваться классом darkroom, а не присваивать свойству islit объекта класса room значение nil, поскольку потребуется изменить и ряд других методов/свойств. Свойство isseen определяет, был ли уже игрок в этой комнате раньше или попал в нее первый раз; изначально оно имеет значение nil и устанавливается равным true при первом посещении комнаты игроком. Метод roomAction(actor, verb, directObject, preposition, indirectObject) (передаваемые параметры - актер, глагол, "прямой" объект, предлог, "косвенный" объект) выполняется всякий раз, когда игрок пытается выполнить какое-либо действие, находясь в комнате; по умолчанию этот метод вызывает аналогичный метод объекта, в котором находится данная комната (при условии, что эта комната где-то находится, т. е. ее свойство location не равно nil). Если в процессе выполнения этого метода будет выполнена инструкция exit, то дальнейшая обработка команды игрока будет прервана. Этим можно воспользоваться, например, для ограничения некоторых действий игрока, специфичных именно для конкретной комнаты; скажем, можно создать комнату с гнилым полом, по которому игрок сможет ходить, однако если он попытается прыгнуть, пол провалится, и игрок окажется в подвале. Такое поведение комнаты удобнее всего реализовывать именно с помощью метода roomAction. Обратите внимание, что если данный метод выполнит какие-либо действия (например, выдаст сообщение), однако инструкции exit в нем не окажется, то после завершения работы метода команда игрока будет обрабатываться дальше, как ни в чем не бывало (для вышерассмотренного примера с комнатой с гнилым полом это будет означать, что после того, как игрок окажется в подвале, будет отображено стандартное сообщение, выдаваемое при команде "прыгнуть", что в данном случае, конечно, нежелательно). Метод lookAround(verbosity) выводит на экран описание комнаты - краткое или подробное, в зависимости от указанного режима (определяется параметром verbosity: если он равен true, будет выведено подробное описание, а если nil - то только краткое, т. е. название комнаты и список находящихся в ней "движимых" объектов). Метод roomDrop(object) вызывается, когда игрок бросает (в смысле выпускает из рук) объект object, находясь внутри комнаты. По умолчанию этот метод просто перемещает соответствующий предмет в комнату и выдает сообщение вида "Брошено." Метод firstseen вызывается, когда игрок впервые попадает в данную локацию (когда свойству isseen присваивается значение true); по умолчанию этот метод ничего не делает, однако он представляет собой удобное место для определения действий, выполняемых только при первом посещении комнаты игроком. Обратите внимание, что вызов firstseen осуществляется после отображения описания комнаты. Свойства для направлений (north, south, east, west, up, down, ne, nw, se, sw, in, out - соответствуют северу, югу, востоку, западу, верху, низу, северо-востоку, северо-западу, юго-востоку, юго-западу, входу и выходу) определяют помещение, куда попадает игрок или персонаж, пытаясь идти в данной локации в определенном направлении. Если то или иное из этих свойств возвращает другую комнату, то игрок именно в нее и попадет. Если же свойство возвращает nil, игрок остается в текущей комнате. По умолчанию все свойства-направления выводят сообщение (при помощи метода noexit) "Этим путем не пройти" и возвращают nil. Чтобы разрешить игроку двигаться в том или ином направлении, достаточно присвоить соответствующему свойству значение, равное объекту, представляющему локацию, куда игрок должен попасть.
Другие свойства, определенные для данного класса:
actorNorth, actorSouth, actorEast, actorWest, actorUp, actorDown, actorNE, actorNW, actorSE, actorSW, actorIn, actorOut - свойства-направления для персонажа в игре (не игрока); соответствуют северу, югу,востоку, западу, верху, низу, северо-востоку, северо-западу, юго-востоку, юго-западу, входу и выходу. По умолчанию перемещение из комнаты персонажа происходит так же, как и для игрока, но автор игры может изменять порядок перемещения для персонажей (например, разрешить им перемещаться в направлениях, закрытых для игрока), используя данные свойства. Работа с этими свойствами аналогична работе с описанными выше свойствами-направлениями для игрока.
addLeaveList(obj) - см. leaveRoom(actor)
cantReachRoom(otherRoom) - этот метод вызывается из свойства cantReach в случае, когда игрок находится не непосредственно в комнате, а внутри некоторого объекта, расположенного в этой комнате. См. также свойство cantReach объекта thing.
dispBeginLdesc, dispEndLdesc - служебные методы низкого уровня, вызываемые методом lookAround соответственно до и после отображения подробного описания комнаты (ldesc). По умолчанию dispBeginLdesc осуществляет переход на новый абзац, а dispBeginLdesc не делает ничего; эти методы имеет смысл модифицировать при необходимости, например, специального оформления подробного описания комнаты.
dispBeginSdesc, dispEndSdesc - служебные методы низкого уровня, вызываемые методом lookAround соответственно до и после отображения краткого описания комнаты (sdesc). По умолчанию не делают ничего, однако при необходимости, например, специального оформления краткого описания комнаты их можно модифицировать.
dispEndLdesc - см. dispBeginLdesc.
dispEndSdesc - см. dispBeginSdesc.
dispParagraph - служебный низкоуровневый метод, выводящий начало нового абзаца (по умолчанию осуществляет перевод строки и отступ на 4 пробела). Данный метод используется методом lookAround при выводе описания комнаты; его следует модифицировать, если требуется иное оформление абзаца.
enterRoom(actor) - вызывается всякий раз, когда персонаж actor заходит в данную комнату. С его помощью удобно реализовывать эффекты, которые должны повторяться всякий раз при входе в комнату (например, активация "демона" персонажа, постоянно находящегося в данной комнате). По умолчанию этот метод обеспечивает вывод на экран описания комнаты при входе в нее. Модифицируя этот метод для конкретного объекта, не забудьте вызвать метод enterRoom родительского класса при помощи инструкции pass.
leaveList - см. leaveRoom(actor)
leaveRoom(actor) - метод вызывается всякий раз, когда персонаж actor покидает данную локацию. С помощью этого метода удобно реализовывать эффекты, которые должны повторяться всякий раз при выходе из комнаты (например, отключение "демона" персонажа, постоянно находящегося в данной комнате). По умолчанию метод выполняет следующие действия: просматривает список объектов, содержащийся в свойстве leaveList (чтобы занести объект в этот список, необходимо "зарегистрировать" объект, вызвав метод addLeaveList). Для каждого объекта из этого списка выполняется свойство leaving и, если оно возвращает true, объект исключается из списка leaveList. Такой механизм может быть удобен для реализации некоторых спецэффектов (например, вывод сообщения, когда игрок пытается вынести определенный объект из комнаты). Свойства leaveList и addLeaveList лучше не модифицировать. При изменении же leaveRoom не забудьте вызвать соответствующий метод родительского класса при помощи инструкции pass.
meIsMovingInto(meActor) - вызывается в случае, если игрок (главный персонаж) явным образом перемещается в данную комнату при помощи своего метода moveInto (а не travelTo). По умолчанию meIsMovingInto ничего не делает. Обратите внимание, что этот метод выполнется до того, как игрок попадет в комнату назначения, поэтому в процессе исполнения meIsMovingInto доступны все свойства и методы для комнаты, откуда перемещается игрок (при этом следует отметить, что свойства и методы комнаты, куда он перемещается, также доступны через объект self).
nrmLkAround(verbosity) - служебный "подметод" для lookAround(verbosity); в нем выполняются практически все необходимые действия для вывода описания комнаты, за исключением отображения строки статуса.
roomCheck(v) - этот метод возвращает true, если глагол v в принципе "работает" в данной комнате. Если метод возвращает nil, то дальнейшая обработка команды игрока прерывается. Этот метод используется в качестве грубой предварительной проверки допустимости команды для данного помещения; основное его предназначение - "отсечь" недопустимые команды для темных помещений (см. также объект darkroom). По умолчанию в комнате разрешены все команды (метод всегда возвращает true).
statusLine - используется методом lookAround(verbosity) для отображения строки статуса. Напрямую изменять этот метод не рекомендуется; если требуется отличный от принятого по умолчанию формат строки статуса (краткое описание текущей локации и указание (через дробь) числа сделанных ходов и набранных очков), следует модифицировать метод statusRoot класса room, а также функцию scoreFormat.
statusRoot - используется методом statusLine для отображения левой части строки статуса; по умолчанию выводит краткое описание текущей локации.
searchHider: hider. Этот класс аналогичен классу underHider, только предметы скрываются не под "объектом-укрытием", а внутри него, и чтобы их найти, игроку необходимо обыскать "объект-укрытие" или заглянуть в него. Для спрятанных внутри объекта данного класса предметов свойство searchLoc должно ссылаться на "объект-укрытие". См. также behindHider. Обратите внимание, что поведение объектов данного класса отличается от обычных контейнеров, поскольку, в отличие от последних, спрятанного предмета изначально в игре нет - он появляется в ней только после того, как игрок даст соответствующую команду, чтобы обыскать "объект-укрытие".
Объекты, скрываемые посредством объекта класса searchHider, должны принадлежать классу hiddenItem.
seethruItem: item. Предмет, сквозь который игрок может посмотреть (например, окно). При этом отображение соответствующей реакции на команду "посмотреть сквозь..." обеспечивается методом thrudesc. Обратите внимание, что данный класс отличается от класса transparentItem, служащего для определения объекта-контейнера, у которого видно его содержимое.
surface: item. Поверхность, на которую можно класть другие объекты. За исключением атрибута-флага issurface, равного true и помечающего объект-наследник как принадлежащий данному классу, а также использования предлога "на" вместо предлога "в" при перечислении предметов, находящихся на объекте-наследнике данного класса (например, фразы вроде "На пьедестале лежит золотой череп"), класс surface практически не отличается от класса container. Обратите внимание, что объект не может одновременно принадлежать и классу surface, и классу container, поскольку между ними нет внутренних различий (иначе говоря, синтаксический анализатор не увидит разницы между предметом, который положили на данную поверхность-контейнер и в нее, и при описании поверхности-контейнера всегда будет выводить или "На пьедестале лежит золотой череп", или "В пьедестале лежит золотой череп" - в зависимости от того, какой из классов, surface или container, указан в заголовке определения объекта-пьедестала первым, не обращая внимания на то, как именно золотой череп оказался в/на пьедестале - по команде "положить в" или "положить на").
switchItem: fixeditem. Данный класс определяет объекты, которые игрок может включать и выключать. Единственным специфичным для данного класса свойством является isActive, которое равно nil, когда выключатель выключен, или true, когда он включен. Объект воспринимает команды вида "включить его" и "выключить это" и тому подобные инструкции, при этом соответствующим образом изменяется значение свойства isActive.
sysverb: deepverb, darkVerb. Системные объекты-глаголы, используемые для реализации служебных команд, например, таких, как "сохранить", "восстановить", "завершить" и др. В первую очередь данный класс служит для того, чтобы при выполнении команд, соответствующих принадлежащим ему объектам-глаголам, обходились проверки, предпринимаемые в обычных случаях (например, эти глаголы можно выполнять и в темной комнате). Атрибут-флаг issysverb для глаголов этого класса всегда равен true.
theFloor: beditem, floatingItem. Специальный объект (соответствующий полу), присутствующий во всех помещениях (достигается за счет специального определения свойства location). Он добавлен в основном в целях полноты реализации, чтобы игрок мог обращаться к полу в процессе игры. За исключением этого, объект не выполняет каких-либо специальных действий; например, если игрок бросит некий предмет на пол, этот предмет просто будет перемещен в текущую комнату.
thing: object. Базовый класс для всех предметов в игре. Свойство contents представляет собой список, определяющий, что находится в объекте. Это свойство автоматически устанавливается системой после компиляции игры таким образом, чтобы в свойстве содержался список всех предметов, свойство location которых указывает на данный объект. Синхронизация обоих свойств производится посредством метода moveInto, поэтому при перемещении объектов настоятельно рекомендуется использовать этот метод вместо прямого изменения свойства location. Методы adesc и thedesc отображают название предмета с неопределенным и определенным артиклем; для русскоязычных игр они неактуальны. Метод sdesc (сокращенное от short description - краткое описание) предназначен для вывода названия объекта в именительном падеже. В русской версии TADS дополнительно определяются свойства rdesc, ddesc, vdesc, tdesc и pdesc для отображения краткого описания предмета соответственно в родительном, дательном, винительном, творительном и предложном падежах, а также mdesc - для отображения так называемого местного падежа, который для некоторых слов (например, "лес") может отличаться от предложного. По умолчанию первые шесть свойств совпадают с sdesc, а mdesc - с pdesc. Впрочем, при использовании генератора падежных форм вместо них обычно достаточно указать одно свойство desc, на основании которого все остальные свойства будут автоматически создаваться при компиляции игры. Свойство isThem указывает число объекта (единственное или множественное), а свойства isHim и isHer - мужской и женский род соответственно (если ни одно из этих свойств не определено или они определены оба, предмет считается имеющим средний род). В последних версиях библиотеки определено свойство-оболочка gender, определяющее число и род объекта на основании проверки значений свойств isThem, isHim и isHer, однако сами эти свойства определять все равно придется (поскольку синтаксический анализатор обращается именно к ним для поиска предмета, когда в команде игрока используется местоимение). Метод ldesc - это подробное или "длинное" описание объекта, которое обычно отображается, когда игрок смотрит на предмет. По умолчанию выводится нечто типа "Это кажется обычным предметом". Метод isIn(object) возвращает true, если местоположением предмета является переданный в качестве аргумента объект object, или если свойство location объекта указывает на объект, чей метод contentsVisible возвращает true и метод isIn этого объекта также возвращает true для аргумента object. Обратите внимание, что, если метод isIn возвращает true, это не обязательно означает, что объектом можно манипулировать, поскольку данный метод возвращает true и в том случае, если объект просто виден. Метод thrudesc по умолчанию выводит сообщение, когда игрок пытается посмотреть сквозь предмет; он может оказаться полезным, например, при реализации окон. Метод moveInto(object) перемещает предмет в указанный в качестве аргумента объект object, как было описано выше. Чтобы удалить какой-либо предмет из игры, можно осуществить вызов этого метода с nil в качестве аргумента.
Прочие свойства и методы, определяемые для класса thing:
actorAction(v, d, p, i) - метод используется, когда игрок дает команду данному предмету (например, "робот, открой дверь"); аргументами метода являются глагол, использующийся в команде, "прямой" объект, предлог и "косвенный" объект; если каких-либо составляющих в команде нет, соответствующий аргумент будет заменен на nil. Например, для вышеупомянутой команды "робот, открой дверь" метод actorAction объекта, соответствующего роботу, будет вызван со следующими аргументами: v будет равно объекту, соответствующему глаголу "открыть", d будет ссылаться на объект, соответствующий двери, а p и i будут равны nil. Если будет отдана команда "робот, открой дверь посредством ключа", то аргументом p будет объект, соответствующий предлогу "посредством", а i - объект, соответствующий ключу (остальные аргументы не изменятся). Если внутри метода выполняется инструкция exit, то на этом обработка команды завершается, в противном случае она обрабатывается нормальным образом. В объекте thing метод возвращает сообщение о невозможности отдать предмету команду и завершает работу инструкцией exit.
bulk - в буквальном переводе "громоздкость", т. е. объем, занимаемый предметом. См. функцию addbulk.
cantReach(actor) - этот метод вызывается, если персонаж пытается манипулировать предметом, который виден персонажу, но недоступен для него. Если предмет находится внутри другого объекта-контейнера, не ограничивающего доступ к своему содержимому (типа открытой коробки), мы передаем управление соответствующему методу этого контейнера. Если предмет находится внутри закрытого контейнера, выдается сообщение о том, что контейнер надо открыть. Как правило, это означает, что контейнер прозрачный, т. е. его содержимое видно, но недоступно. Метод является служебным и в общем случае не должен модифицироваться.
cantReachRoom(actor) - этот метод вызывается, если персонаж, находясь (непосредственно) внутри данного предмета, пытается манипулировать другим предметом в заданной комнате, который ему недоступен. При этом должно выдаваться сообщение, объясняющее игроку, почему предмет в заданной комнате виден, но недоступен. По умолчанию игроку просто сообщается, что объект недоступен; для некоторых локаций может потребоваться более развернутое сообщение.
circularMessage(io) - выводит соответствующее сообщение, если игрок пытается положить в контейнер предмет, который уже в этом контейнере находится (включая случаи вложенных друг в друга контейнеров). Метод является служебным и в общем случае не должен модифицироваться.
construct - метод, автоматически вызываемый при динамическом создании объекта данного класса. По умолчанию, перемещает объект в его текущую локацию (свойство location). Не требует модификации автором игры.
contents - список содержимого предмета, т. е. всех предметов, свойство location которых ссылается на данный объект. Свойство устанавливается системой автоматически, модифицировать его непосредственно не рекомендуется.
contentsReachable - указывает, доступно ли игроку содержимое данного предмета, т. е. может ли он манипулировать предметами, находящимися внутри данного предмета (если метод возвращает true, то содержимое доступно, а если nil, то нет). По умолчанию возвращает true.
contentsVisible - указывает, видно ли игроку содержимое данного предмета (если возвращает true, то видно, а если nil, то нет). По умолчанию возвращает true.
destruct - метод, автоматически вызываемый при уничтожении динамически созданного объекта данного класса. По умолчанию, перемещает объект в его "пустую" локацию (nil). Не требует модификации автором игры.
ditobjdesc - в зависимости от числа и рода предмета выводит "ним", "ей" или "ему".
genMoveDir - текст, выводимый на попытку переместить объект в каком-либо направлении (например, "сдвинуть рычаг на север").
Grab(obj) - см. verGrab(obj).
isListed: если это свойство равно true, то объект явным образом отображается в описании комнаты, где он находится (после основого текста описания комнаты выводится фраза типа "Ты видишь здесь..." и название предмета). Если это свойство равно nil, предмет в описании комнаты не отображается.
isReachable(actor) - возвращает true, если предмет доступен для персонажа actor, или nil, если недоступен. При определении доступности предмета используются следующие правила: предмет доступен, если он принадлежит списку reachable помещения, либо если он находится внутри контейнера (или ряда контейнеров), содержимое которого (или всей цепочки контейнеров) доступно, и сам контейнер также доступен. Метод является служебным и в общем случае не должен модифицироваться.
isVisible(vantage) - возвращает true, если предмет видим из объекта (точки наблюдения) vantage, или nil в противном случае. При определении видимости предмета используются следующие правила: предмет виден, если точка наблюдения находится внутри него, и содержимое предмета видно; если предмет находится внутри точки наблюдения; если видны объект-местоположение предмета и содержимое этого объекта; если у точки наблюдения имеется местоположение, отличное от nil, при этом содержимое местоположения этой точки видно (принцип "если ты видишь меня, то я вижу тебя"), и сам предмет виден из местоположения точки наблюдения; во всех остальных случаях предмет невидим. Метод является служебным и в общем случае не должен модифицироваться.
itnomdesc - выводит местоимение в именительном падеже для данного объекта в зависимости от его числа (значения свойства isThem) - "они" для множественного числа и "это" для единственного.
itobjdesc - в зависимости от числа и рода предмета выводит "их", "её" или "его".
itselfdesc - в зависимости от числа и рода предмета выводит "них самих же", "него же" или "неё саму же".
lico - специфическое для русской версии TADS свойство, возвращает лицо (число 1, 2 или 3), соответствующее данному предмету. Данное свойство необходимо для правильного отображения окончаний глаголов во фразах, содержащих ссылки на данный предмет.
listendesc - описание, выдаваемое по умолчанию в качестве ответа на команду "слушать".
multisdesc - используется синтаксическим анализатором для вывода списков объектов (подробнее описано здесь). По умолчанию возвращает краткое описание (sdesc) объекта. Если вы не собираетесь "дорабатывать напильником" синтаксический анализатор, это свойство вам не понадобится.
pluraldesc - возвращает краткое описание (название) предмета во множественном числе (используется при отображении в списке неразличимых объектов - например, "пять монет"). По умолчанию совпадает с sdesc. В RTADS вместо него используется свойство rpluraldesc.
pitobjdesc - в зависимости от числа и рода предмета выводит "них", "ней" или "нём".
readdesc - описание, выдаваемое по умолчанию в качестве ответа на команду "прочитать". Это свойство необходимо переопределять для предметов, которые можно читать (например, книги, газеты, таблички и т. п.).
ritobjdesc - в зависимости от числа и рода предмета выводит "их", "неё" или "него".
rpluraldesc - русскоязычный аналог свойства pluraldesc.
smelldesc - описание, выдаваемое по умолчанию в качестве ответа на команду "понюхать".
statusPrep - предлог по умолчанию, указывающий, как должно выводиться описание, если персонаж или другой предмет находится внутри данного предмета (используется, например, для описаний типа "Столовая, на стуле" или "Гараж, в машине"; для объекта, соответствующего стулу в первом примере, данное свойство возвращает предлог "на", а для машины во втором примере - предлог "в".
thrudesc - описание, выдаваемое по умолчанию в качестве ответа на команду "посмотреть через". Это свойство необходимо переопределять для предметов, через которые можно куда-то смотреть (например, бинокли, лупы и т. п.).
titobjdesc - в зависимости от числа и рода предмета выводит "ими", "ею" или "им".
touchdesc - описание, выдаваемое по умолчанию в качестве ответа на команду "потрогать".
validActor - Возвращает true, если игрок может дать предмету команду. По умолчанию, дать команду можно только в случае, если предмет доступен (см. также метод isReachable). Метод является служебным и в общем случае не должен модифицироваться.
verGrab(obj), Grab(obj) - определяют реакцию предмета при попытке взять из него содержащийся в нем объект obj. Метод verGrab действует аналогично методам обработки глаголов с префиксом "ver" - если он выводит что-либо на экран, попытка взять предмет obj признается неудачной и дальнейшая обработка прекращается. Методы являются служебными и в общем случае не должны модифицироваться.
verifyRemove(actor) - проверяет, может ли персонаж actor взять данный предмет, или существуют ограничения со стороны объекта-контейнера, в котором этот предмет находится. Метод является служебным и в общем случае не должен модифицироваться.
weight - вес предмета (см. функцию addweight).
Кроме того, для данного класса определены методы-верификаторы и методы-действия стандартных глаголов.
transparentItem: item. Объект-контейнер, содержимое которого видно, даже когда сам контейнер закрыт. При этом это содержимое будет недоступно, пока объект не откроют. Данный класс удобен для реализации, например, таких предметов, как стеклянные бутылки, содержимое которых (при закрытой бутылке) видно, но недоступно.
travelVerb: deepverb, darkVerb. Объекты-глаголы, которые обеспечивают перемещение игрока по комнатам игры. Для всех объектов-глаголов этого класса атрибут-флаг isTravelVerb равен true.
underHider: hider. Это объект, под которым можно прятать другие объекты. Спрятанные объекты можно обнаружить, только заглянув под данный объект; см. также описание класса hider для более подробной информации. Свойство underLoc каждого из спрятанных объектов должно ссылаться на скрывающий объект класса underHider.
Обратите внимание, что объект класса underHider не дает возможности игроку спрятать что-нибудь под ним в процессе игры. Этот класс предназначен скорее для того, чтобы автору игры было проще реализовать спрятанные предметы в процессе написания игры. Все, что вам требуется сделать, чтобы спрятать один предмет под другим - это объявить "объект-укрытие" как принадлежащий классу underHider, а затем определить объект для спрятанного предмета обычным образом, за исключением того, что для указания местоположения спрятанного предмета будет использоваться не свойство location, а свойство underLoc. Классы behindHider и searchHider работают аналогичным образом.
Объекты, скрываемые посредством объекта класса underHider, должны принадлежать классу hiddenItem.
vehicle: item, nestedroom. Объект - транспортное средство, которое игрок, с одной стороны, может носить с собой, а с другой стороны, может забраться в/на него и использовать для перемещения по игровому миру. Находясь внутри транспортного средства, игрок может перемещаться только вместе с ним; чтобы перемещаться куда-либо еще, ему придется сначала вылезти из транспортного средства. Кроме того, разумеется, игрок не сможет забраться в транспортное средство, пока он держит его в руках. Для данного класса определен (равным true) атрибут-флаг isvehicle, помечающий объект-наследник как принадлежащий данному классу.
Стандартные определения объектов-глаголов
В нижеприведенном списке альтернативные лексические свойства (иначе говоря, слова-синонимы) для объектов-глаголов указаны через слэш (/) (при этом указаны лишь основные синонимы); разные синтаксические конструкции с участием объекта-глагола отделены друг от друга запятыми. В случае, если глагол используется в сочетании с объектами, в скобках за примером конструкции приводятся методы-верификаторы и обработчики, вызываемые для объекта (при этом их префиксы - do, verDo, io и verIo - опускаются); подробнее об обработчиках и верификаторах см. в разделе Создание собственных глаголов главы седьмой, а также главу 4.
(Примечание переводчика: в приведенных образцах синтаксических конструкций вместо использующихся в оригинале "прямых" и "косвенных" объектов (например, "расскажи 'прямому' объекту о 'косвенном' объекте") используются примеры с конкретными предметами. Хотя строгость изложения при этом несколько страдает, такой способ подачи материала показался мне более изящным (не говоря уже о том, что в некоторых случаях он позволил мне потешить мое извращенное чувство юмора;). Кроме того, для русского языка, в отличие от английского, предлог между "прямым" и "косвенным" объектами в некоторых случаях может отсутствовать. Если предлог необязателен, он приводится в квадратных скобках. Наконец, для некоторых (в основном системных) глаголов приводятся комментарии в фигурных скобках, описывающие назначение этих глаголов).againVerb: повтор/п {повторение последней введенной игроком команды}
askVerb: спросить/расспросить продавца о водке (AskAbout)
askforVerb: попросить персонажа сделать что-то (AskFor), попросить у персонажа сделать что-то (AskOneFor) {глагол преобразует введенную пользователем команду вида "попросить у персонажа взять мяч" к виду "персонаж, возьми мяч"}
attachVerb: присоединить/прикрепить ксерокс к шреддеру (AttachTo)
attackVerb: убить/атаковать/напасть на училку [посредством] кирпича (AttackWith)
boardVerb: сесть в/залезть в танк (Board)
breakVerb: разбить/сломать телевизор (Break)
centerVerb: центр/центрировать прицел (Center)
cleanVerb: чистить/очистить кастрюлю (Clean), чистить/очистить зубы [посредством] щетки (CleanWith)
climbVerb: лезть по/карабкаться по шесту (Climb)
closeVerb: закрыть/прикрыть лавочку (Close), закрыть/прикрыть дверь [посредством] ключа (LockWith)
debugVerb: debug {системный глагол, который переводит игру в режим отладки. Для того чтобы команда работала, игра должна быть соответствующим образом скомпилирована. Подробнее см. в документации по компилятору TADS}
detachVerb: отсоединить/расцепить кабель (Detach), отсоединить/расцепить карабин от ведра (DetachFrom)
digVerb: копать/рыть котлован [посредством] экскаватора (DigWith)
drinkVerb: выпить/хлебнуть политурки (Drink)
dropVerb: выбросить/выложить деньги (Drop), выбросить/выложить воблу на газету (PutOn)
eatVerb: съесть/проглотить ежа (Eat)
fastenVerb: застегнуть/пристегнуть ремень (Fasten)
flipVerb: щелкнуть монету (Flip) {глагол "flip", который буквально переводится на русский как "щелкнуть", в английском обычно употребляется применительно к монете при игре "орел-решка"}
followVerb: следовать за соперником (Follow)
getOutVerb: слезть с/вылезти из/выйти из шкафа (Unboard)
giveVerb: дать/подарить цветы подруге (GiveTo)
gothroughVerb: пройти сквозь/вылезть через отверстие (Gothrough)
HelpVerb: помощь {системный глагол, выводит краткую справку по IF-играм.}
inspectVerb: осмотреть/исследовать/осм статуэтку (Inspect)
insertVerb: вставить картридж в принтер (PutIn)
inVerb: войти/зайти/внутрь, войти в/зайти в автобус (Enter)
itallVerb: и_высокий {"надстройка" над глаголом iVerb, используемая для вывода инвентаря игрока в "высоком" формате (т. е. каждый элемент списка выводится с новой строки). См. также iwideVerb.}
iVerb: инвентарь/и {выводит список предметов, которые несет игрок}
iwideVerb: и_широкий {"надстройка" над глаголом iVerb, используемая для вывода инвентаря игрока в "широком" формате (т. е. в строчку через запятую). См. также itallVerb.}
jumpVerb: прыгнуть/подпрыгнуть, перепрыгнуть канаву (Jump)
knockVerb: постучать в ворота (Knock)
lieVerb: лечь на/улечься на ежа (Lieon)
linksVerb: ссылки {системный глагол, включает/отключает отображение гиперссылок (имеет смысл только для игр, написанных с использованием средств HTML-TADS)}
listenVerb: слушать/прислушаться к/вслушаться в голоса (ListenTo)
lockVerb: замкнуть/запереть камеру (Lock), замкнуть/запереть сундук [посредством] ключа (LockWith)
lookBehindVerb: посмотреть за/заглянуть за шкаф (LookBehind)
lookInVerb: посмотреть в/заглянуть в кастрюлю (Lookin)
lookThruVerb: посмотреть сквозь/посмотреть через бинокль (Lookthru)
lookUnderVerb: посмотреть под/заглянуть под танк (LookUnder)
lookVerb: смотреть/осмотреться/оглядеться/см
moveNVerb: двигать на север/двигать на с/толкать на с автомобиль
(MoveN)
Примечание: глаголы moveSVerb, moveEVerb, moveWVerb, moveNEVerb, moveNWVerb,
moveSEVerb и moveSWVerb, соответствующие югу, востоку, западу, северо-востоку,
северо-западу, юго-востоку и юго-западу, определяются аналогично.
moveVerb: двинуть/переместить/шевелить диван (Move), двинуть/переместить алкоголика [к] подъезду (MoveTo), двинуть/переместить/шевелить труп [посредством] палки (MoveWith)
openVerb: открыть бутылку (Open), открыть банку [посредством] ножа (UnlockWith)
osmVerb: глагол служит для выбора между "осмотреть" и "осмотреться", когда игрок вводит сокращенный вариант команды ("осм")
outVerb: выйти/покинуть/прочь/наружу
plugVerb: воткнуть/подсоединить/подключить штепсель в розетку (PlugIn)
pokeVerb: пихнуть соседа (Poke)
pullVerb: тянуть/потянуть/дернуть дверь (Pull)
pushVerb: нажать/толкать/надавить крышку (Push)
putVerb: поместить/положить/класть котлету в тарелку (PutIn), поместить/положить/класть голову на блюдо (PutOn)
quitVerb: выход {завершение игровой сессии - системный глагол}
readVerb: читать/прочесть пасквиль (Read)
removeVerb: снять/снять с себя вошь (Unwear)
restartVerb: заново {системный глагол - перезапускает игру заново}
restoreVerb: восстановить/загрузить сохраненную игру (Restore) {системный глагол, восстанавливает сохраненную ранее игру}
saveVerb: сохранить/записать текущее состояние игры (Save) {системный глагол, сохраняет текущее состояние игры}
sayVerb: сказать/произнести "фразу, обязательно заключенную в двойные кавычки" (Say)
scoreVerb: счет/статус {системный глагол, выводит количество очков, набранных игроком}
scriptVerb: отчет имя файла отчета (Script) {системный глагол, начинает запись всех команд, вводимых игроком, и ответов игры, в специальный файл отчета (команда незаменима при отладке)}
screwVerb: привинтить/прикрутить крышку (Screw), привинтить/прикрутить гайку [посредством] ключа (ScrewWith)
searchVerb: искать в/обыскать карманы (Search)
showVerb: показать кость собаке (ShowTo)
sitVerb: сесть на пень (Siton)
sleepVerb: спать/уснуть/отдыхать
standOnVerb: встать на/залезть на/забраться на стул (Standon)
switchVerb: переключить телевизор (Switch)
takeVerb: взять/подобрать булыжник (Take), взять/подобрать деньги из кошелька (TakeOut), взять/подобрать книгу с полки (TakeOff)
talkVerb: поговорить с/поболтать с/побеседовать с палачом (Talk)
tellVerb: рассказать начальнику о неудаче (TellAbout)
terseVerb: кратко {системный глагол, переводит игру в "краткий" режим, при котором полные описания комнат отображаются только в тех случаях, когда игрок попадает в комнату впервые; см. также verboseVerb}
throwVerb: кинуть/швырнуть/метнуть дротик в мишень (ThrowAt), кинуть/швырнуть/метнуть мяч вратарю (ThrowTo), кинуть/швырнуть/метнуть кирпич сквозь окно (ThrowThru), кинуть/швырнуть/метнуть подушку на кровать (PutOn)
touchVerb: трогать/коснуться/пощупать нож (Touch)
turnOffVerb: выключить/деактивировать компьютер (Turnoff)
turnOnVerb: включить/активировать/запустить пылесос (Turnon)
turnVerb: повернуть/покрутить антенну (Turn), повернуть/покрутить коленвал [посредством] заводной рукоятки (TurnWith), повернуть/покрутить регулятор на максимум (TurnOn)
typeVerb: печатать текст на клавиатуре (TypeOn)
undoVerb: отмена/откат {системный глагол, отменяющий последнюю команду игрока}
unfastenVerb: расстегнуть/отстегнуть шлем (Unfasten)
unlockVerb: отомкнуть/отпереть сундук (Unlock), отомкнуть/отпереть сейф [посредством] отмычки (UnlockWith)
unplugVerb: отсоединить/отключить кабель (Unplug), отсоединить/отключить компьютер от сети (UnplugFrom)
unscrewVerb: отвинтить/открутить/вывинтить лампочку (Unscrew), отвинтить/открутить/вывинтить винт [посредством] отвертки (UnscrewWith)
unscriptVerb: стопотчет/остотчет {системный глагол, прекращает запись отчета; см. также scriptVerb.}
verboseVerb: длинно/полно {системный глагол, который переводит игру в "подробный" режим, при котором полные описания комнат отображаются во всех случаях, даже когда игрок заходит в комнату, где он уже был; см. также terseVerb}
versionVerb: версия {системный глагол - выводит данные о версии игры; эти данные задаются автором игры при помощи специального объекта version, определенного в файле std.t}
wearVerb: надеть/одеть кольчугу (Wear)
yellVerb: кричать/орать/вопить
yesVerb: да/нет {этот глагол реализует один из приколов ряда "классических" IF-игр: например, при попытке игрока, скажем, пересечь бурную реку отображался текст типа "Неужели ты думаешь, что не утонешь?" Если игрок в этом случае пытался ответить на это "да" или "нет", игра выводила текст "Это был риторический вопрос."}
Для каждого предлога указывается соответствующий ему объект и список лексических свойств для этого объекта, при этом синонимы разделяются слэшем (/). Обратите внимание, что для предлогов, состоящих из двух слов, составляющие их слова объединяются в одно, поскольку именно так поступает синтаксический анализатор.
dirPrep: север/юг/восток/запад/вверх/вниз/северовосток/св/северозапад/сз/юговосток/юв/югозапад/юз/с/ю/в/з/вв/вн
withPrep: спомощью/припомощи/посредством/используя/применяя/задействовав
Данный файл является аналогом англоязычной библиотеки std.t. По замыслу создателя TADS Майкла Робертса, здесь размещаются определения функций и объектов, которые, скорее всего, будут изменяться для каждой конкретной игры. В эти функции сведены, например, следующие действия: вывод сообщений вначале игры; реализация смерти игрока (вернее, главного персонажа); отображение информации о набранных игроком очках и т. д.
Ниже в алфавитном порядке приведен список функций и объектов, определенных в stdr.t.
commandAfterRead: function(code). Данная функция вызывается каждый раз сразу после ввода игроком очередной команды. По умолчанию, если интерпретатор поддерживает HTML-TADS, она просто возвращается к первоначальному шрифту, который использовался до того, как функция commandPrompt временно переключилась на шрифт, используемый для ввода команд ("TADS-Input"). Аргумент code позволяет организовать обмен данными между функцией commandAfterRead и вызывающим ее кодом. По умолчанию эта возможность не используется.
commandPrompt: function(code). Данная функция выводит приглашение командной строки. В случае, если игра запущена при помощи интерпретатора, поддерживающего HTML-TADS, игрок сможет выбрать шрифт этого приглашения (это достигается тем, что функция переключает используемый шрифт на "TADS-Input", а этот шрифт может настраиваться игроком средствами интерпретатора). Аргумент code позволяет организовать обмен данными между функцией commandPrompt и вызывающим ее кодом. По умолчанию эта возможность не используется.
commonInit: function. Данная функция является вспомогательной и служит для того, чтобы избежать дублирования кода. При запуске игры вся инициализация осуществляется либо функцией init, либо initRestore в зависимости от способа запуска игры. Поскольку возможна ситуация, когда при инициализации игры необходимо выполнить определенную последовательность действий независимо от условий запуска, в stdr.t предусмотрена "заглушка" commonInit, в которой можно разместить общий инициализирующий код вместо того, чтобы отдельно размещать его и в init, и в initRestore. В обеих этих функциях уже предусмотрен вызов commonInit. По умолчанию данная функция включает режим HTML.
darkTravel: function. Функция вызывается, если игрок, находясь в темной комнате, пытается перейти в другую комнату, которая также не освещена (либо если он пытается в темной комнате двигаться в направлении, путь по которому закрыт). По умолчанию в этом случае просто выводится текст "Пошарив во тьме, ты так и не нашел дороги."
die: function. Данная функция вызывается, когда игрок умирает. По умолчанию, она сообщает игроку, насколько он преуспел в игре (путем отображения набранных им очков), и предлагает ему перезапустить игру, восстановить ранее сохраненную игру или выйти из программы.
displayImage: function(imageName, objectToCheck, centre). Функция выводит на экран изображение (графический файл с именем imageName). Параметр centre определяет, будет ли изображение центрироваться при выводе. В параметре objectToCheck можно передать функции объект, которому соответствует выводимое изображение; при этом для этого объекта поле imageSeen будет установлено равным true; при соответствующих настройках игры (см. объект global) это позволит выводить картинку для объекта только один раз - когда игрок впервые осматривает объект. Функция работает только в том случае, если игра запущена в HTML-TADS.
displayLink: function(command, text). Функция выводит на экран HTML-ссылку, при этом text - это отображаемый на экране текст ссылки, а command - адрес ссылки. Функция работает только в том случае, если игра запущена в HTML-TADS; в противном случае она просто отображает текст text.
eatDaemon: function(parm). Функция-демон, в основном аналогичная sleepDaemon, только отслеживающая, сколько времени (ходов) прошло с тех пор, как главный персонаж последний раз ел. Если он не ел слишком долго, то (после ряда предупреждений о необходимости принять пищу) главный персонаж умрет. См. также fooditem.
global: object. Объект, в который сведена большая часть настроек и параметров, относящихся ко всей игре в целом, как то: максимальное количество очков; текущее количество очков; текущее количество ходов; режим вывода описаний комнат (краткий или подробный) и др. Ниже приведен обзор свойств объекта (они перечислены в алфавитном порядке).
awakeTime - время (точнее, число ходов), прошедшее с момента последнего сна главного персонажа. По умолчанию оно установлено равным 0; если требуется, чтобы главный персонаж начинал игру уставшим, установите его большим. См. также sleepDaemon.
eatTime - максимальное число ходов, которое главный персонаж может обходиться без еды. Этот параметр используется в работе демона eatDaemon.
glpad - используется при обработке команды игрока для определения типа глагола (см. также метод padezh_type объекта deepverb). Значение свойства устанавливается в ходе обработки команды синтаксическим анализатором. Менять его значение не рекомендуется.
lamplist - список всех источников света в игре. Этот список заполняется функцией preinit и служит для ускорения работы игры.
lastMealTime - время (число ходов), прошедшее с момента, когда главный персонаж последний раз ел. По умолчанию оно установлено равным 0; если требуется, чтобы главный персонаж начинал игру голодным, установите его большим. См. также eatDaemon.
maxscore - максимальное число очков, которое игрок может набрать в процессе игры. По умолчанию игрок может набрать 100 очков. Это число по умолчанию отображается в строке статуса игры, а также, как правило, выводится функцией scoreRank.
score - число очков, заработанных игроком в ходе игры; на начало игры это значение для подавляющего большинства игр равно нулю, увеличение числа очков выполняется функцией incscore.
schanged - флаг, используемый при обработке команды игрока синтаксическим анализатором. Менять его значение не рекомендуется.
sleepTime - максимальное время бодрствования (число ходов, в течение которого главный персонаж может обходиться без сна). Этот параметр используется в работе демона sleepDaemon.
turnsofar - число ходов, сделанных игроком за время игры (на начало игры это поле по умолчанию равно нулю, а после каждого хода увеличивается на единицу функцией turncount).
verbose - Указывает способ вывода описаний комнат, в которые заходит игрок. Если это поле равно true, то подробное описание комнаты будет отображаться всякий раз, когда игрок в нее заходит; если поле имеет значение nil, то подробное описание будет выводиться только тогда, когда игрок попадает в комнату впервые. Значение этого свойства игрок может "переключать" при помощи команд ПОЛНО и КРАТКО.
vinpadcont - флаг, указывающий, в каком падеже выводить названия предметов при перечислении (винительном или именительном). Изменять его значение не рекомендуется, т. к. в процессе игры его значение изменяется самой программой и во многом определяется логикой работы синтаксического анализатора.
goToSleep: function. Функция вызывается, когда игра принудительно отправляет главного персонажа спать. Подробнее см. функцию sleepDaemon.
init: function. Данная функция выполняет инициализацию игры при запуске последней. По умолчанию, она выводит вступительный текст к игре, данные о версии игры, запускает все необходимые демоны и запалы (по умолчанию запускаются три демона: turncount, sleepDaemon и eatDaemon), перемещает "стандартного" главного персонажа (объект Me) в комнату, которой по умолчанию соответствует объект startroom, выводит описание этой комнаты, инициализирует строку статуса, вызывает функцию initSearch, а также инициализирует генератор псевдослучайных чисел. См. также commonInit, initRestore.
initRestore: function(fname). Вызывается системой для инициализации игры вместо функции init, если игрок указал при запуске игры имя файла (параметр fname), из которого требуется восстановить сохраненную игру. Способ указания этого параметра зависит от конкретного интерпретатора (например, для DOS-версии можно задавать имя файла в качестве параметра командной строки). По умолчанию данная функция просто восстанавливает сохраненную позицию игры из указанного в качестве параметра файла. См. также commonInit.
introduction: function. Вызывается при запуске игры функцией init, служит для размещения вступительного текста. По умолчанию выводит фразу "Сюда можно вставить вступление".
Me: basicMe. Объект, соответствующий главному персонажу. По умолчанию этот объект просто наследует все свойства класса basicMe, но автор игры может как доопределить дополнительные свойства, так и использовать другой объект для главного персонажа (при помощи функции switchPlayer). В стандартной библиотеке stdr.t определен также набор "форматных" строк, если к главному персонажу необходимо обращаться на "Вы" (подробнее о форматных строках см. класс movableActor).
numObj: basicNumObj. См. класс basicNumObj.
pardon: function. Эта функция вызывается всякий раз, когда игрок в ответ на приглашение игры вводит пустую строку. Как правило, ее используют для вывода соответствующего сообщения; по умолчанию выводится фраза "Вы что-то сказали?".
preinit: function. Данная функция вызывается компилятором TADS после компиляции игры, но до того, как игра записывается в окончательный бинарный файл игры (с расширением .gam). preinit осуществляет все действия по инициализации, которые могут быть выполнены "статически" до записи файла игры. За счет этого сокращается время загрузки игры, т. к. часть действий оказывается выполненной заблаговременно. В англоязычной версии здесь составляется список всех объектов-источников света, а также выполняется функция initSearch. В русскоязычной версии на этом же этапе отрабатывает генератор падежных форм.
scoreRank: function. Функция служит для отображения количества очков, которые игрок набрал в процессе игры. По умолчанию выводит сообщение "В сумме за X ходов, вы достигли счета в Y единиц из возможных Z", где X - число ходов, сделанных игроком, Y - число набранных им очков, а Z - максимально возможное число очков (определяется полем maxscore объекта global).
sleepDaemon: function(parm). Функция-демон, отслеживающая, сколько времени (ходов) главный персонаж провел без сна. По умолчанию, при превышении некоего количества ходов, определяемого свойством sleepTime объекта global, будет выдано сообщение о том, что главный персонаж настолько устал, что уснул на месте (при этом все предметы, которые он нес с собой, окажутся рассыпанными по комнате, в которой он уснул). До того, как данный предел будет достигнут, будет выдано несколько предупреждений (по умолчанию, за 35, 25, 15, 10 и 5 ходов до "принудительного" засыпания игрока). По умолчанию данный демон запускается из функции init. Аргумент parm позволяет организовать обмен данными между программой и демоном путем передачи и/или возврата какого-либо значения/переменной. В версии демона по умолчанию этот параметр никак не используется.
strObj: basicStrObj. См. класс basicStrObj.
terminate: function. Данная функция вызывается непосредственно перед окончанием игры. Как правило, в ней выводится прощальное сообщение; по умолчанию в ней не выполняется никаких действий. Обратите внимание, что вызов этой функции осуществляется непосредственно перед тем, как программа-интерпретатор заканчивает свою работу; ее вызов никак не связан со смертью главного персонажа, перезапуском игры или другими действиями игрока.
version: object. В данном объекте обычно определяют краткую информацию об игре (наименование, версия, автор...), которая будет выводиться в самом начале игры, а также по команде версия. Всю необходимую информацию заносят в свойство sdesc данного объекта.
В этом файле сконцентрированы функции, имеющие отношение к системным сообщениям синтаксического анализатора (в том числе сообщениям об ошибках распознавания команд игрока). Особой нужды модифицировать здесь что-то у автора, как правило, нет, разве что захочется "облагородить" то или иное сообщение об ошибке. Нижеследующий список определений в данном файле приведен исключительно для справки.
parseAskobjActor: function(a, v, ...). Функция-точка входа, выводит запрос игроку в том случае, если в команде не указан "прямой" или "косвенный" объект, а синтаксический анализатор не смог подобрать его самостоятельно. Подробнее см. здесь и здесь.
parseDefault: function(obj, prp). Функция, являющаяся точкой входа, заменяет системное сообщение в случае, если синтаксический анализатор сумел самостоятельно подобрать нужный объект при неоднозначной команде игрока. Подробнее см. здесь.
parseDefaultExt: function(actor, verb, obj, prp). Функция заменяет parseDefault, начиная с версии TADS 2.5.8. Подробнее см. здесь.
parseDisambig: function(str, lst, ...). Функция, являющаяся точкой входа, выводит запрос игроку в том случае, если синтаксическому анализатору не удалось устранить неопределенность команды игрока. Подробнее см. здесь.
parseError: function(errnum, str). Функция-точка входа, служащая для вывода сообщения об ошибке обработки команды игрока. Подробнее см. здесь.
parseError2: function(v, d, p, i). Функция, являющаяся точкой входа, выводит сообщение об ошибке в случае, когда для фигурирующего в команде игрока объекта не определены обработчики, соответствующие глаголу этой команды. Подробнее см. здесь.
thing - модификация базового объекта для всех предметов в игре, изначально определенного в файле advr.t. Здесь для него доопределяется специальное свойство disamvdesc, представляющее собой название предмета в винительном падеже, использующееся исключительно для уточняющих запросов синтаксического анализатора ("Который объект Вы имеете в виду:..."). Наглядный пример, иллюстрирующий, зачем эта модификация понадобилась и как использовать disamvdesc, приведен непосредственно в тексте файла.
Данный файл содержит библиотеку генератора падежей - мощного средства, позволяющее на порядок сократить объем рутинной работы при написании игры на RTADS (за счет ликвидации необходимости прописывать все возможные формы существительных и прилагательных вручную). О том, как пользоваться генератором, рассказано в другой части Руководства. Модифицировать здесь что-либо не только не требуется, но и настоятельно не рекомендуется (учитывая сложность алгоритмов работы).
addwordru: function(obj, type, word). По задумке, должна быть русскоязычным аналогом встроенной функции addword, служащей для добавления лексических свойств объекта в процессе игры. obj - объект, для которого добавляется лексическое свойство, type - соответствует типу лексического свойства (&noun - существительное, &adjective - прилагательное), word - добавляемое слово. В отличие от исходой версии функции, должна добавлять все необходимые словоформы, если аргумент word имеет понятный генератору формат (если соответствующее форматирование отсутствует, функция становится полным аналогом оригинального addword). На практике функция не работает, поскольку обращается к несуществующему методу генератора addLexemes.
delwordru: function(obj, type, word). Русскоязычный аналог встроенной функции delword, служащей для удаления лексических свойств объекта в процессе игры. obj - объект, для которого удаляется лексическое свойство, type - соответствует типу лексического свойства (&noun - существительное, &adjective - прилагательное), word - удаляемое слово. В отличие от исходной версии функции, должна удалять все словоформы выбранного слова, если аргумент word имеет понятный генератору формат (если соответствующее форматирование отсутствует, функция работает как полный аналог оригинального delword). На текущем этапе функция работоспособна, но имеет особенности. В частности, не учитывается тот факт, что генератор сохраняет среди лексических свойств исходную строку для формирования словоформ. Скажем, если для объекта указано noun='ведро/1с', то после отработки генератора сама строка 'ведро/1с' не будет удалена из лексических свойств. Функция delwordru с аргументом word, равным 'ведро/1с', удалит все словоформы ('ведра', 'ведру', 'ведром'...), но саму исходную строку 'ведро/1с' также не заметит. Чтобы избавиться от нее, потребуется дополнительно осуществить вызов вида delword('ведро/1с').
generate: function(obj, str, sklonenie, ...). Функция генерации падежных форм для одного слова. Возвращает список строковых значений - падежных форм. obj - объект (используется для проверки рода, числа и т. п., если соответствующая информация не содержится в передаваемой строке); str - слово, для которого необходимо сгенерировать падежные формы; sklonenie - флаг, указывающий, какие падежные формы надо генерировать (может принимать следующие значения: 1 - именительный падеж, 2 - родительный, 3 - дательный, 4 - винительный, 5 - творительный, 6 - предложный, 7 - второй творительный, 8 - местный. 0 означает, что будет возвращен список всех словоформ. Значение, большее восьми, приравнивается к 1). Дополнительные (опциональные) аргументы - флаг части речи (прилагательное или (по умолчанию) существительное); флаг возврата информации о грамматических свойствах слова (по умолчанию не возвращается); флаг, указывающий, является ли переданное слово описанием или лексемой.
generation: function. Запускает генератор словоформ и, если игра компилируется в режиме отладки, выводит эти словоформы. По умолчанию вызывается из функции preinit.
generator: object. Основной объект, хранящий правила склонения существительных и содержащий необходимые методы для генерации словоформ. Для автора игры, пожалуй, наибольший интерес представляет метод start, служащий для запуска генератора. Если этому методу передать в качестве аргумента значение nil, генератор будет подготовлен к работе, но не будет создавать словоформы.
genobj: object. Объект с набором падежных свойств, "завязанных" на генератор. Судя по всему, использовался исключительно в целях тестирования на этапе разработки.
initRestart: function(parm) - замена функции, изначально определенной в файле advr.t. Дополнительно к установке флага перезапуска запускает генератор падежных форм. Необходима для обхода бага, существовавшего в TADS вплоть до версии 2.5.14 (вследствие которого сбрасывались все лексемы, создававшиеся в функции preinit).
lower2x: function(str). Осуществляет перевод в нижний регистр двух последних символов строки str. Работает только для символов кириллицы.
thing - модификация базового объекта для всех предметов в игре, изначально определенного в файле advr.t. Свойства для вывода падежных форм объекта (sdesc, rdesc, ddesc, vdesc, tdesc, pdesc и mdesc) переопределяются так, чтобы удобнее взаимодействовать с генератором.
В исходном варианте этот файл представлял собой перевод на русский язык библиотеки от Нила деМосса (Neil deMause), реализующей ряд дополнительных возможностей. В дальнейшем сюда помещались разные полезные доработки системных библиотек. В отличие от других файлов, при описании extendr.t использован принцип разбивки по функциональным группам, поскольку для реализации одной возможности зачастую определяется/модифицируется сразу несколько функций/объектов.
Уведомление об изменении счета: в стандартном варианте игрок при изменении количества набранных очков никак не извещается (игра только меняет значение счета в строке статуса). Данная библиотека дополнительно реализует специальный служебный глагол - команду, включающую или отключающую извещение об изменении счета (новый объект-глагол notifyVerb: sysverb). (Для него, правда, по умолчанию определена только английская команда - "notify", для русскоязычной игры придется подобрать и внести соответствующий русский синоним). Эта команда поочередно устанавливает/сбрасывает новый флаг incscorenotified объекта global. Кроме того, в extendr.t модифицируется функция incscore таким образом, чтобы при включенном оповещении об изменении счета (global.incscorenotified=true) выдавалось соответствующее сообщение. С этой целью incscore активирует новый метод-запал tellscore объекта global с расчетом, чтобы он "сработал" в конце текущего хода. (Такие сложности нужны, судя по всему, для того, чтобы сообщение об изменении счета было выведено в самом конце описания текущей локации). Метод tellscore выводит фразу "Вы получили n очков" (с формированием грамматически правильной конструкции в зависимости от числа очков).
Проверка нахождения одного объекта в другом: определена функция isinside: function(item,loc), которая возвращает true, если объект item находится внутри объекта loc (вне зависимости от количества "вложенных" объектов), и nil в противном случае. Вероятно, была актуальна на момент написания оригинальной англоязычной версии библиотеки; сейчас она эквивалентна инструкции item.isIn(loc) (метод isIn определен для класса thing в advr.t).
Перемещение содержимого одного объекта в другой: функция moveFromTo: function (from, to) перемещает все объекты, содержащиеся в объекте from, в объект to.
Запрет на использование слова "все": объект deepverb переопределяется таким образом, чтобы команды с использованием слова "все" (например, "осмотреть все") блокировались с сообщением "Вы не можете использовать слово "все" с этим глаголом". При этом сохраняется возможность перечисления в команде нескольких предметов через запятую - "осмотреть дерево, траву". В библиотеке модифицируются определения глаголов takeVerb, dropVerb и putVerb с тем, чтобы они не блокировали использование слова "все". Если необходимо разрешить употребление этого слова с другими командами, надо определить для соответствующих глаголов свойство allowall=true. Альтернативный способ добиться схожего эффекта описан здесь.
Команда "опустошить": определен объект глагол emptyVerb, соответствующий команде "опустошить контейнер" (при этом объекты, содержащиеся в контейнере, будут перемещены в текущую локацию). Соответствующим образом модифицировано также определение объекта container (правда, есть небольшая недоработка: контейнер удастся опустошить даже в том случае, если он и так пустой).
Класс для не отображаемых в описании комнаты объектов: специальный класс unlisteditem, потомки которого не будут отображаться в описании комнаты до тех пор, пока игрок не подберет их в первый раз.
Неосязаемые объекты: специальный класс intangible для объектов, которые невозможно взять/пощупать (звуки, запахи, абстрактные понятия).
Обработчики взятия/бросания предмета: доопределены специальные свойства класса thing - takedesc и dropdesc, обращение к которым осуществляется всякий раз, когда игрок, соответственно, берет или бросает предмет. Упрощает реализацию спецэффектов (в простейшем случае это может быть просто выдаваемое дополнительное описание). В рамках реализации этих функций модифицируется также класс room.
Выделение названия комнаты жирным: класс room модифицирован таким образом, чтобы при включенном режиме HTML название текущей локации выводилось жирным шрифтом.
Глагол "помочь": определен глагол extHelpVerb. Служит для обеспечения реакции персонажей в игре на команды вида "персонаж, помоги". В настоящее время просто выводит содержание краткую справочную информацию общего характера (в комментариях в самой библиотеке реализация определена как шуточная).
Данная библиотека позволяет организовать функциональное меню. Основной класс носит название menu. Для реализации меню автору игры потребуется
определить следующие его свойства:
sdesc - краткое описание меню;
btn [объект-меню1, подпись к объекту-меню1, ...] - попарно определяемые пункты меню с подписями (их список будет разворачиваться
при клике на меню). "Вложенные" объекты-меню должны быть определены в программе (они отвечают за реакцию при выборе соответствующего пункта меню);
bgcolor - цвет фона меню;
fgcolor - цвет текста меню;
txt - собственно действие, реализуемое при выборе пункта меню. Если данный пункт меню ничего не должен делать (по нему раскрывается подменю), то
это свойство можно не трогать;
ps - аналогично txt, но выводится после него;
endcheck - флаг, определяющий, надо ли возвращаться в текстовый режим после отработки меню. Если надо, возвращает true, если нет -
nil.
Далее определен объект mainmenu: menu. Этот объект является оболочкой для всех меню, определяемых пользователем. Запуск меню осуществляется
по инструкции
mainmenu.start(firstmenu), где firstmenu - имя отображаемого пользовательского объекта-меню.
В файле также в качестве примера реализовано системное меню (объект smenu), позволяющее сохранить текущую игру (за это "отвечает" объект savem), загрузить ранее сохраненную игру (объект loadm), перезапустить текущую игру (объекты restartm и restsysyes), завершить игру (объекты sysquit и sysqyes).
К сожалению, библиотека пока не отлажена, меню работают с огрехами, однако получить представление о том, как это должно выглядеть, можно.
Ненавижу определения.
БЕНДЖАМИН ДИЗРАЭЛИ (BENJAMIN DISRAELI), Вивиан Грей (1826)
| Приложение A | Содержание | Приложение C |