Просмотр исходного текста страницы Доступ к внешним функциям и свойствам в Papyrus

[[Category:Подробное объяснение]]
[[Category:Papyrus]]
[[Category:Учебники Papyrus]]
{{Tutorial Index
|Prev=:Category:Papyrus
|Next=:Category:Papyrus
|series=Papyrus скриптинг
|chapter=3
|espInitial=EmptyPlugin.esp
|espCompleted=-
|scripts=true
}}
'''Оригинал:''' [http://www.cipscis.com/skyrim/tutorials/externalaccess.aspx cipscis.com]

'''Перевод:''' Кирилл SKV1991 Салтыков

'''Права:''' Копирование строго запрещено!

== Глобальные функции ==
Самым простым типом вызываемых функций являются глобальные функции. Эти функции могут быть определены, используя ключевое слово "global" при объявлении. Например:

<syntaxhighlight lang="papyrus">
ScriptName ExampleLibrary

int Function SumTwo (int a, int b) global
	    { Вернет сумму двух введенных чисел }
	    Return (a + b)
EndFunction
</syntaxhighlight>

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

<syntaxhighlight lang="papyrus">
int Three = SumTwo(1, 2)
</syntaxhighlight>

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

<syntaxhighlight lang="papyrus">
int Three = ExampleLibrary.SumTwo(1, 2)
</syntaxhighlight>
<syntaxhighlight lang="papyrus">
Import ExampleLibrary

int Three = SumTwo(1, 2)
</syntaxhighlight>

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

Однако, даже если вы импортировали скрипт, и есть некоторая двусмысленность в названии функции, то нужно явно указать, в каком скрипте находится эта функция. Например, если я импортирую два скрипта с глобальной функцией  "SumTwo", то я должен вызывать функцию так, как если бы её скрипт не был импортирован, например:
<syntaxhighlight lang="papyrus">
Import ExampleLibrary1
Import ExampleLibrary2

int Three1 = ExampleLibrary1.SumTwo(1, 2)
int Three2 = ExampleLibrary2.SumTwo(1, 2)
</syntaxhighlight>

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

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

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

Был ли присоединен скрипт к объекту в Creation Kit или нет, некоторые скрипты присоединяются игровым движком автоматически, в зависимости от типа объекта. Например, скрипт Actor автоматически присоединяется ко всем ссылкам на актеров.

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

<syntaxhighlight lang="papyrus">
ScriptName TeleportOnBleedout extends Actor

ObjectReference property TeleportMarker auto

Event OnEnterBleedout()
    	MoveTo(TeleportMarker)
EndEvent
</syntaxhighlight>

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

Первая подсказка здесь указана в строке объявления ScriptName. На простом английском, термин "extends Actor" означает "наследовать все свойства и функции скрипта Actor (включая события)". Если же мой скрипт состоит из одной строки, то получается я просто напросто дублирую скрипт Actor.

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

Помимо прямого доступа к любой функции скрипта Actor, мы можем переопределить их, снова написав в нашем скрипте. Например, событие OnEnterBleedout (помните, что события являются функциями) определено в скрипте Actor так:

<syntaxhighlight lang="papyrus">
Event OnEnterBleedout()
EndEvent
</syntaxhighlight>

([[OnEnterBleedout - Actor|OnEnterBleedout]] это нативное событие - игра вызывает его на объекта типа Actor, когда они входят в режим "bleedout"(кровотечение))

Как вы могли заметить, если бы я не переопределил его, ничего бы не происходило при вызове этого события. Однако я его переопределил, поэтому при вызове игрой события OnEnterBleedout на данном актере, будет запущен код, определенный в версии TeleportOnBleedout.

Теперь, если говорить об этом коде - это пример того, насколько просто вызывать функцию на объекте, к которому присоединен этот скрипт.

Хотя функция [[MoveTo - ObjectReference|MoveTo]] не определена в этом скрипте, она все равно остается доступной, потому что объявлена в предке данного скрипта. TeleportOnBleedout наследует скрипт Actor, а скрипт Actor наследует ObjectReference, и функция MoveTo объявлена внутри скрипта [[ObjectReference Script|ObjectReference]].

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

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

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

Есть и другая специальная переменная, доступная в не-глобальных функциях - "Parent". Используя эту переменную, можно вызывать родительскую версию функции, включая события, если она была переопределена в данном скрипте.

=== Свойства и переменные ===

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

Так же, при расширении скрипта (extends), вы не наследуете его переменные. Переменные являются полностью частными, и к ним нельзя получить доступ вне блока, в котором они были объявлены (это называется "блочная зона видимости" (block scope)). Примерами блоков служат функции, блоки if, и блоки while.

== Вызов функций на внешних объектах ==

При вызове функции на объекте, отличающемся от того, к которому присоединен ваш скрипт, синтаксис может получиться более сложным. Самое важно, что стоит запомнить здесь - компилятор может путешествовать ''вверх'' по тропе наследования, но не может ''вниз''. Функции, объявленные в определенном скрипте (назовем его скрипт MyScript) могут быть доступны только из этого скрипта или из скриптов-потомков (т.е. скрипты с указанием extends MyScript в строке определения).

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

Например, сделаем небольшое изменение в TeleportOnBleedout:

<syntaxhighlight lang="papyrus">
ScriptName TeleportOnBleedout extends Actor

ObjectReference property TeleportMarker auto

Function TeleportAway()
	    MoveTo(TeleportMarker)
EndFunction

Event OnEnterBleedout()
	    TeleportAway()
EndEvent
</syntaxhighlight>

Теперь представьте, у меня есть другой скрипт, который я привязал к активатору. Когда игрок активирует его, он найдет актера и отправит его на телепортацию (функция TeleportAway). Перемещаемый актер будет установлен как связанный с моим активатором (через linked reference), так что я получу указатель на него, используя [[GetLinkedRef - ObjectReference|GetLinkedRef]]:

<syntaxhighlight lang="papyrus">
ScriptName TeleportLinkedRef extends ObjectReference

ObjectReference LinkedRef

Event OnActivate(ObjectReference akActionRef)
	    LinkedRef = GetLinkedRef()

	    if (akActionRef == Game.GetPlayer())
        		LinkedRef.TeleportAway()
    	endif
EndEvent
</syntaxhighlight>

Функция [[GetLinkedRef - ObjectReference|GetLinkedRef]] возвращает объект типа ObjectReference, поэтому я присвою возвращаемое ею значение переменной такого же типа. Затем, когда игрок активирует заскриптованный активатор (надеюсь, вы понимаете, что это [[GetPlayer - Game|GetPlayer]] - это глобальная функция из скрипта [[Game Script|Game]]), данный скрипт вызовет функцию TeleportAway, которую я определил.

Хотя, есть проблемка. На первый взгляд все это может выглядеть корректно, но компилятор сообщит, что не может найти функцию TeleportAway. Проблема в том, что переменная LinkedRef имеет тип ObjectReference, компилятор смотрит в скрипт ObjectReference и ищет функцию (включая унаследованные функции, помните) с названием TeleportAway. Хотя такой функции нет, поэтому скрипт не скомпилируется.

Решение включает в себя то, что называется [[Справка по приведению типов|приведением типов]] (cast), оно позволяет привести объект одного типа к объекту другого типа.

Исключая базовые типы, вроде "int" и "bool", объект типа A может быть приведен к объекту типа B если...

* Тип A является предком типа B
* Тип B является предком типа A

Запомните, что функция доступна в скрипте, если она объявлена в этом скрипте, или в одном из его предков. Это значит, что если я хочу, чтобы компилятор мог найти мою функцию TeleportAway, мне нужно привести LinkedRef к типу TeleportOnBleedout или к одному из его потомков.

Сейчас TeleportOnBleedout не имеет ни одного потомка, так что единственным для меня вариантом будет привести к типу TeleportOnBleedout. Однако, если ''есть'' потомки, я не должен приводить LinkedRef к более производному типу, чем сам скрипт, присоединенный к объекту.

Например, если я создам скрипт, расширяющий TeleportOnBleedout с названием TeleportOnBleedoutChild, но не присоединю его к моему актеру, используемому в этом примере, то я не смогу успешно привести его к типу TeleportOnBleedoutChild. Однако компилятор этого не знает, и мой скрипт будет компилироваться. Если приведение типа не удастся по такой причине, то результатом приведения будет служить None.

Для приведения одного типа объекта к другому, вам нужно использовать ключевое слово '''as'''. Есть несколько способов, как я могу решить мою текущую проблему с приведением типов.

<syntaxhighlight lang="papyrus">
ScriptName TeleportLinkedRef extends Activator

ObjectReference LinkedRef

Event OnActivate(ObjectReference akActionRef)
	    LinkedRef = GetLinkedRef()

	    if (akActionRef == Game.GetPlayer())
		        (LinkedRef as TeleportOnBleedout).TeleportAway()
    	endif
EndEvent
</syntaxhighlight>
<syntaxhighlight lang="papyrus">
ScriptName TeleportLinkedRef extends Activator

TeleportOnBleedout LinkedRef

Event OnActivate(ObjectReference akActionRef)
	    LinkedRef = GetLinkedRef() as TeleportOnBleedout

	    if (akActionRef == Game.GetPlayer())
		        LinkedRef.TeleportAway()
    	endif
EndEvent
</syntaxhighlight>

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

Следующий способ возможен, но немножечко некрасивый:

<syntaxhighlight lang="papyrus">
ScriptName TeleportLinkedRef extends Activator

TeleportOnBleedout LinkedRef

Event OnActivate(ObjectReference akActionRef)
	    LinkedRef = GetLinkedRef() as TeleportOnBleedout

	    if (akActionRef == Game.GetPlayer())
        LinkedRef.TeleportAway()
		        ((LinkedRef as Actor) as OtherNewActorChild).OtherFunction()
    	endif
EndEvent
</syntaxhighlight>

Второй метод - преобразование возвращаемого функцией [[GetLinkedRef - ObjectReference|GetLinkedRef]] значения и хранение значения в производном типе - полезно, если важно, чтобы значение имело производный тип большую часть времени, и никогда (ну или почти никогда) не использовалось с типом потомка.

В этих примерах, я использовал переменную для хранения значения, возвращаемого функцией [[GetLinkedRef - ObjectReference|GetLinkedRef]]. Однако, если вы не планируете где-либо повторно использовать значение, то можно использовать возвращаемое функцией значение напрямую для вызова необходимой функции, вроде этого:

<syntaxhighlight lang="papyrus">
ScriptName TeleportLinkedRef extends Activator

Event OnActivate(ObjectReference akActionRef)
    	if (akActionRef == Game.GetPlayer())
		        (GetLinkedRef() as TeleportOnBleedout).TeleportAway()
    	endif
EndEvent
</syntaxhighlight>

При решении вопроса хранить ли что-либо в переменной, так же важно понимать, что имея переменную, указывающую на конкретный объект, вы тем самым склоняете объект к [[Persistence (Papyrus)|постоянству]] (англ. ''persistence''). Если вы хотите использовать переменную, но не хотите сохранять постоянство у данного объекта, вы можете "освобождать" его (если предположить, что больше ничто не заставляет его быть постоянным) присваивая своей переменной значение ''None''.