Создание и Использование Скриптов
Поведение игровых объектов контролируется с помощью компонентов ( Components ), которые присоединяются к ним. Несмотря на то, что встроенные компоненты Unity могут быть очень разносторонними, вскоре вы обнаружите, что вам нужно выйти за пределы их возможностей, чтобы реализовать ваши собственные особенности геймплея. Unity позволяет вам создавать свои компоненты, используя скрипты . Они позволяют активировать игровые события, изменять параметры компонентов, и отвечать на ввод пользователя каким вам угодно способом.
Unity изначально поддерживает три языка программирования:
- C# (произносится как Си-шарп), стандартный в отрасли язык подобный Java или C++;
- UnityScript, язык, разработанный специально для использования в Unity по образцу JavaScript;
В дополнение к этим, с Unity могут быть использованы многие другие языки семейства .NET, если они могут компилировать совместимые DLL — см. эту страницу для получения подробностей.
Изучение искусства программирования и использования этих языкам выходит за рамки данного введения. Однако есть множество книг, обучающих материалов и ресурсов для изучения программирования в среде Unity. Посетите Обучающий раздел на нашем сайте для получения подробной информации.
Создание скриптов
В отличии от других ассетов, скрипты обычно создаются непосредственно в Unity. Вы можете создать скрипт используя меню Create в левом верхнем углу панели Project или выбрав Assets > Create > C# Script (или JavaScript/Boo скрипт) в главном меню.
Новый скрипт будет создан в папке, которую вы выбрали в панели Project. Имя нового скрипта будет выделено, предлагая вам ввести новое имя.
![]()
Лучше ввести новое имя скрипта сразу после создания чем изменять его потом. Имя, которое вы введете будет использовано, чтобы создать начальный текст в скрипте, как описано ниже.
Структура файла скрипта
После двойного щелчка на скрипте в Unity, он будет открыт в текстовом редакторе. По умолчанию Unity будет использовать MonoDevelop, но вы можете выбрать любой редактор из панели External Tools в настройках Unity.
Содержимое файла будет выглядеть примерно так:
using UnityEngine; using System.Collections; public class MainPlayer : MonoBehaviour < // Use this for initialization void Start () < >// Update is called once per frame void Update () < >>
Скрипт взаимодействует с внутренними механизмами Unity за счет создания класса, наследованного от встроенного класса, называемого MonoBehaviour . Вы можете думать о классе как о своего рода плане для создания нового типа компонента, который может быть прикреплен к игровому объекту. Каждый раз, когда вы присоединяете скриптовый компонент к игровому объекту, создается новый экземпляр объекта, определенный планом. Имя класса берется из имени, которое вы указали при создании файла. Имя класса и имя файла должны быть одинаковыми, для того, чтобы скриптовый компонент мог быть присоединен к игровому объекту.
Основные вещи, достойные внимания, это две функции, определенные внутри класса. Функция Update — это место для размещения кода, который будет обрабатывать обновление кадра для игрового объекта. Это может быть движение, срабатывание действий и ответная реакция на ввод пользователя, в основном всё, что должно быть обработано с течением времени во игровом процессе. Чтобы позволить функции Update выполнять свою работу, часто бывает полезно инициализировать переменные, считать свойства и осуществить связь с другими игровыми объектами до того, как будут совершены какие-либо действия. Функция Start будет вызвана Unity до начала игрового процесса (т.е. до первого вызова функции Update), и это идеальное место для выполнения инициализации.
Заметка для опытных программистов: вы можете быть удивлены, что инициализация объекта выполняется не в функции-конструкторе. Это потому, что создание объектов обрабатывается редактором и происходит не в начале игрового процесса, как вы могли бы ожидать. Если вы попытаетесь определить конструктор для скриптового компонента, он будет мешать нормальной работе Unity и может вызвать серьезные проблемы с проектом.
A UnityScript script works a bit differently to C# script:
#pragma strict function Start () < >function Update ()
Здесь функции Start и Update имеют такое же значение, но класс не объявлен явно. Предполагается, что скрипт сам по себе определяет класс; он будет неявно производным от MonoBehaviour и получит своё имя от имени файла скриптового ассета.
Управление игровым объектом
Как было сказано ранее, скрипт определяет только план компонента и, таким образом, никакой его код не будет активирован до тех пор, пока экземпляр скрипта не будет присоединен к игровому объекту. Вы можете прикрепить скрипт перетаскиванием ассета скрипта на игровой объект в панели Hierarchy или через окно Inspector выбранного игрового объекта. Имеется также подменю Scripts в меню Component, которое содержит все скрипты, доступные в проекте, включая те, которые вы создали сами. Экземпляр скрипта выглядит так же, как и другие компоненты в окне Inspector:-

После присоединения скрипт начнет работать, когда вы нажмете Play и запустите игру. Вы можете проверить это добавив следующий код в функцию Start:-
// Use this for initialization void Start ()
Debug.Log это команда, которая просто выводит сообщение на консольный вывод Unity. Если вы нажмете сейчас Play, вы увидите сообщение внизу основного окна редактора Unity в окне Console (меню: Window > Console ).
Как написать скрипт к игре?
В основу материала положена статья Lizzie Stark, Elin Nilsen and Trine Lise Lindahl. Прочитать статью на английском языке можно здесь.
Что такое скрипт?
Скрипт — это текст игры, который включает в себя инструкции мастерам игры, игрокам, перечень упражнений (если они есть), список того, что необходимо для проведения игры, а также персонажи игры.
Для чего нужен скрипт?
- Скрипт позволяет провести игру не только ее авторам, но и всем желающим, так как грамотно составленный скрипт служит инструкцией по ее проведению и организации.
- Скрипт помогает сохранить игру. Скрипт позволяет вернуться к игре позже, чтобы что-либо доделать или переделать.
- Написание скрипта позволяет авторам игры взглянуть на игру «извне», получить чье-либо мнение или критику: часто то, что написано, не похоже на то, что мы произносим вслух.
- Если у игры есть скрипт, то она имеет возможность быть проигранной много раз совершенно разными людьми.
Что нужно указать в скрипте?
Укажите в описании общее виденье игры, ее цель и задачи. Опишите сюжет, а также сеттинг игры.
Пример: «Игра «The Touch Of Your Voice» была написана командой ларперов в рамках проекта Larp Exchange Academy в Осло в апреле 2013 года. Данная игра посвящена проблеме взаимодействия и общения людей, которые либо были слепыми с детства, либо стали такими. Игра рассчитана на 7 участников. Длительность игры — 3 часа.»
Опишите этап подготовки к игре. Укажите, что нужно для проведения игры. Это касается как вещей, к которым нужно готовится заранее, так и то, что нужно сделать непосредственно перед игрой.
Укажите структуру ларпа, то, из чего игра состоит.
Пример, игра состоит из 3 актов, начало и конец которых обозначается выключением света.
Укажите основные правила игры, включая правило «Stop/break».
Заслуживает упоминания то, что может «сломать» игру или сделать ее проигрыш невозможным.
Пример: «В «Танго для двоих» каждый персонаж отыгрывается 2 игроками – один играет Оно, другой – Я. Вместе они образуют индивид (от англ. Individual – неделимый).»
Пример: «Пол игрока. В реальности не было батальонов, укомплектованных женщинами, но в этой игре предлагается отступить от истории и не обращать внимание на пол игрока. Для игры это не существенно.»
- Подробное описание каждого элемента игры
Опишите в подробностях (желательно с указанием временных интервалов) всю игру, включая воркшопы (если есть) до игры и дибрифинг или упражнения после игры.
Сюда относятся описание персонажей (роли), любой раздаточный материал, который нужен игрокам, текст вводной или описания игры.
Скачать текст в формате pdf — Как написать скрипт игры.
Что такое скрипты и с чем их едят — Lua & C++
Если вы разрабатывали большие проекты (к примеру, масштабные игры), замечали, что с каждой новой сотней строк кода компиляция идет медленней?
В игре создается больше оружия, больше диалогов, больше меню, больше etc.
Одна из самых главных проблем, возникающих в связи с нововведениями — поддерживать бессчетное множество оружия и бейджиков довольно сложное занятие.
В ситуации, когда просьба друга/босса/напарника изменить диалог или добавить новый вид оружия занимает слишком много времени, приходится прибегать к каким-то мерам — например, записи всей этой фигни в отдельные текстовые файлы.
Почти каждый геймдевелопер когда-нибудь делал карту уровней или диалоги в отдельном текстовом файле и потом их считывал. Взять хотя бы простейший вариант — олимпиадные задачи по информатике с файлом ввода
Но есть способ, на голову выше — использование скриптов.
Решение проблемы
«Окей, для таких дел хватает обычного файла с описанием характеристиков игрока. Но что делать, если в бурно развивающемся проекте почти каждый день приходится немножко изменять логику главного игрока, и, следовательно, много раз компилировать проект?»
Хороший вопрос. В этом случае нам на помощь приходят скрипты, держащие именно логику игрока со всеми характеристиками либо какой-либо другой части игры.
Естественно, удобнее всего держать, логику игрока в виде кода какого-нибудь языка программирования.
Первая мысль — написать свой интерпретатор своего скриптового языка, выкидывается из мозга через несколько секунд. Логика игрока определенно не стоит таких жутких затрат.
К счастью, есть специальные библиотеки скриптовых языков для С++, которые принимают на вход текстовый файл и выполняют его.
Об одном таком скриптовом языке Lua пойдет речь.
Как это работает?
Прежде чем начать, важно понимать, как работает скриптовый язык. Дело в том, что в скриптовых языках есть очень мало функций, при наличии конструкций for, while, if, прочих.
В основном это функции вывода текста в консоль, математические функции и функции для работы с файлами.
Как же тогда можно управлять игроком через скрипты?
Мы в С++-программе делаем какие-либо функции, «регистрируем» их под каким-нибудь именем в скрипте и вызываем в скрипте. То есть если мы зарегистрировали функцию SetPos(x,y) для определения позиции игрока в С++-программе, то, встретив эту функцию в скрипте, «интерпретатор» из библиотеки скриптового языка вызывает эту функцию в С++-программе, естественно, с передачей всех методов.
Удивительно, да? 🙂
UPD: Внимание! Один юзер обратился мне с мейлом, что, когда я заливал код, я не полностью устранил все ошибки — habrahabr.ru/post/196272/#comment_6850016
В коде с позволения хабра проникли жучки
Замените участки кода вроде
template T MethodName();
template T MethodName();
И еще вместо lua_CFunction проскакивает lua_cfunction
Спасибо!
Я готов!
Когда вы поняли преимущества скриптовых языков программирования, самое время начать работать!
Скачайте из репозитория на гитхабе (низ топика) lib’у и includ’ы Lua, либо возмите их на официальном сайте.
Создаем консольный проект либо Win32 (это неважно) в Visual Studio (у меня стоит версия 2012)
Заходим в Проект->Свойства->Свойства конфигурации->Каталоги VC++ и в «каталоги включения» и «каталоги библиотек» добавьте папку Include и Lib из репозитория соответственно.
Теперь создаем файл main.cpp, пишем в нем:
int main()
Как вы догадались, у меня консольное приложение.
Теперь переходим к кодингу
Обещаю, что буду тщательно объяснять каждый момент
У нас за скрипты будет отвечать класс Script. Я буду объявлять и одновременно реализовывать функции в Script.h/.cpp
Создаем Script.cpp и пишем в нем
#include "Script.h"
Создаем Script.h и пишем в нем
#ifndef _SCRIPT_H_ #define _SCRIPT_H_ #endif
После 2 строчки и перед #endif мы определяем класс скриптов
Этот код пишется для предотвращения взаимного включения файлов. Допустим, что файл Game.h подключает Script.h, а Script.h подключает Game.h — непорядок! А с таким кодом включение выполняется только 1 раз
Теперь пишем внутри этого кода вот это
#pragma comment(lib,"lua.lib") extern "C" < #include #include #include >
Первая строчка подключает сам lua.lib из архива.
Для чего нужен extern «C»? Дело в том, что lua написан на С и поэтому такой код необходим для подключения библиотек.
Дальше идет подключение хорошо известных многим файлов для работы с консолью
#include #include #include using namespace std;
Теперь приступим к определению класса
class Script
Самый главный объект библиотеки Lua для C++ — lua_State, он необходим для выполнения скриптов
private: lua_State *lua_state;
Дальше идут публичные функции
public: void Create();
Эта функция инициализирует lua_State
Create()
Его определение в Script.cpp
void Script::Create() < lua_state = luaL_newstate(); static const luaL_Reg lualibs[] = < , , >; for(const luaL_Reg *lib = lualibs; lib->func != NULL; lib++) < luaL_requiref(lua_state, lib->name, lib->func, 1); lua_settop(lua_state, 0); > >
Первой строчкой мы инициализируем наш lua_State.
Потом мы объявляем список «подключенных библиотек». Дело в том, что в «чистом» виде в луа есть только функция print(). Для математических и прочих функций требуется подключать специальные библиотеки и потом вызывать их как math.foo, base.foo, io.foo. Для подключения других библиотек добавьте в lualibs, например, . Все названия библиотек начинаются с luaopen_. в конце lialibs должен стоять
void Close();
Эта функция освобождает ресурсы Lua
Ее определение
void Script::Close()
Просто используем lua_close()
int DoFile(char* ScriptFileName);
А эта функция выполняет файл. На вход она принимает название файла, например, «C:\\script.lua».
Почему она возвращает int? Просто некоторые скрипты могут содержать return, прерывая работу скрипта и возвращая какое-нибудь значение.
DoFile()
Ее определение
int Script::DoFile(char* ScriptFileName)
Как вы видите, я выполняю скрипт и возвращаю int. Но возращать функция может не только int, но еще и bool и char*, просто я всегда возвращаю числа (lua_toboolean, lua_tostring)
Теперь мы сделаем функцию, регистрирующую константы (числа, строки, функции)
template void RegisterConstant(T value, char* constantname);
RegisterConstant()
Мы действуем через шаблоны. Пример вызова функции:
RegisterConstant(13,"goodvalue");
Ее определение
template<> void Script::RegisterConstant(int value, char* constantname) < lua_pushinteger(lua_state, value); lua_setglobal(lua_state,constantname); >template<> void Script::RegisterConstant(double value, char* constantname) < lua_pushnumber(lua_state, value); lua_setglobal(lua_state,constantname); >template<> void Script::RegisterConstant(char* value, char* constantname) < lua_pushstring(lua_state, value); lua_setglobal(lua_state,constantname); >template<> void Script::RegisterConstant(bool value, char* constantname) < lua_pushboolean(lua_state, value); lua_setglobal(lua_state,constantname); >template<> void Script::RegisterConstant(lua_CFunction value, char* constantname)
Для каждого возможного значения class T мы определяем свои действия.
*Капитан* последнее определение — регистрация функции
Функции, годные для регистрации, выглядят так:
int Foo(lua_State*) < // . return n; >
Где n — количество возвращаемых значений. Если n = 2, то в Луа можно сделать так:
a, b = Foo()
Читайте мануалы по Луа, если были удивлены тем, что одна функция возвращает несколько значений 🙂
Следующая функция создает таблицу для Луа. Если непонятно, что это значит, то тамошная таблица все равно что массив
void Array();
Ее описание
void Script::Array()
Следующая функция регистрирует элемент в таблице.
template void RegisterConstantArray(T value, int index);
RegisterConstantArray()
Ее описание
template void Script::RegisterConstantArray(int value, int index) < lua_pushnumber(lua_state, index); lua_pushinteger(lua_state, value); lua_settable(lua_state, -3); >template void Script::RegisterConstantArray(double value, int index) < lua_pushnumber(lua_state, index); lua_pushnumber(lua_state, value); lua_settable(lua_state, -3); >template void Script::RegisterConstantArray(char* value, int index) < lua_pushnumber(lua_state, index); lua_pushstring(lua_state, value); lua_settable(lua_state, -3); >template void Script::RegisterConstantArray(bool value, int index) < lua_pushnumber(lua_state, index); lua_pushboolean(lua_state, value); lua_settable(lua_state, -3); >template void Script::RegisterConstantArray(lua_CFunction value, int index)
Если вы не знаете Lua, вы, наверное, удивлены тем, что в один массив помещается столько типов? 🙂
На самом деле в элементе таблицы может содержаться еще и таблица, я так никогда не делаю.
Наконец, заполненную таблицу нужно зарегистрировать
void RegisterArray(char* arrayname);
RegisterArray()
Ее описание
void Script::RegisterArray(char* arrayname)
Ничего особенного нет
Следующие функции предназначены в основном только для функций типа int foo(lua_State*), которые нужны для регистрации в Луа.
Первая из них — получает количество аргументов
int GetArgumentCount();
Create()
Ее описание
int Script::GetArgumentCount()
Эта функция нужна, например, для функции Write(), куда можно запихать сколь угодно аргументов, а можно и ни одного
Подобную функцию мы реализуем позже
Следующая функция получает аргумент, переданный функции в скрипте
template T GetArgument(int index);
GetArgument()
Ее описание
template int Script::GetArgument(int index) < return lua_tointeger(lua_state,index); >template double Script::GetArgument(int index) < return lua_tonumber(lua_state,index); >template char* Script::GetArgument(int index) < return (char*)lua_tostring(lua_state,index); >template bool Script::GetArgument(int index)
Можно получить все типы, описывавшиеся ранее, кроме таблиц и функций
index — это номер аргумента. И первый аргумент начинается с 1.
Наконец, последняя функция, которая возвращает значение в скрипт
template void Return(T value);
Return()
Ее описание
template<> void Script::Return(int value) < lua_pushinteger(lua_state,value); >template<> void Script::Return(double value) < lua_pushnumber(lua_state,value); >template<> void Script::Return(char* value) < lua_pushstring(lua_state,value); >template<> void Script::Return(bool value)
Боевой код
Пора что-нибудь сделать!
Изменяем main.cpp
#include "Script.h" int main()
Компилируем. Теперь можно приступить к тестированию нашего класса
Помните, я обещал сделать функцию Write? 🙂
Видоизменяем main.cpp
#include "Script.h" // Нужен для _getch() #include // Объект скрипта Script script; // Функция Write для текста int Write(lua_State*) < // Тут мы считываем количество аргументов и каждый аргумент выводим for(int i = 1; i < script.GetArgumentCount()+1; i++) cout (i); // После вывода ставим консоль на паузу _getch(); return 0; > int main() < script.Create(); // Имя у луашной функции такое же, как у сишной script.RegisterConstant(Write,"Write"); script.DoFile("script.lua"); script.Close(); >
А в папке с проектом создаем файл script.lua
Write(1,2,3,4)

Компилируем и запускаем проект.

Теперь изменяем script.lua
for i = 1, 4 do Write(i, "\n", "Hier kommt die Sonne", "\n") end
Теперь программа будет выводить по 2 строки ("\n" — создание новой строки), ждать нажатия Enter и снова выводить строки.

Экспериментируйте со скриптами!
Вот пример main.cpp с функциями и пример script.lua
#include "Script.h" #include #include #include Script script; int Write(lua_State*) < // Тут мы считываем количество аргументов и каждый аргумент выводим for(int i = 1; i < script.GetArgumentCount()+1; i++) cout (i); cout int GetString(lua_State*) < // Считываем строку с помощью cin и возвращаем ее, используя методы Script char* str = ""; cin >> str; script.Return(str); // Не забудьте! У нас возвращается 1 результат -> return 1 return 1; > int Message(lua_State*) < // Выводим обычное сообщение MessageBox из Windows.h // Кстати, вам домашнее задание - сделайте возможность вывода сообщений с несколькими аргументами :) char* msg = script.GetArgument(1); MessageBox(0,msg,"Сообщение",MB_OK); return 0; > int GetTwoRandomNumbers(lua_State*) < // Возвращаем два рандомных числа до 1000 srand(time(NULL)); for(int i = 0; i < 2; i++) script.Return(rand()%1000); // Вовзращаем 2 значения return 2; > int GetLotOfRandomNumbers(lua_State*) < // Возвращаем много рандомных чисел до 1000 srand(time(NULL)); for(int i = 0; i < script.GetArgument(1); i++) script.Return(rand()%1000); // Вовзращаем столько значений, сколько задано в аргументе return script.GetArgument(1); > int main() < script.Create(); script.RegisterConstant(Write,"Write"); script.RegisterConstant(GetString,"GetString"); script.RegisterConstant(Message,"Message"); script.RegisterConstant(GetTwoRandomNumbers,"Rand1"); script.RegisterConstant(GetLotOfRandomNumbers,"Rand2"); script.Array(); script.RegisterConstantArray(1,1); script.RegisterConstantArray(2,2); script.RegisterConstantArray(3,3); script.RegisterConstantArray(4,4); script.RegisterArray("mass"); script.DoFile("script.lua"); script.Close(); // Пауза после скрипта _getch(); >
for i = 1, 4 do Write(i, "\n", "Hier kommt die Sonne", "\n") end Write(2*100-1) Message("Привет!") a, b = Rand1() Write(a, "\n", b, "\n") Write(Rand1(), "\n") a, b, c, d = Rand2(4) Write(a, "\n", b, "\n", c, "\n", d, "\n") return 1
Полезные советы
- Для класса Script все равно, в каком расширении находится скрипт, хоть в .txt, хоть в .lua, хоть в .bmp, просто .lua открывается множеством редакторов именно ЯП Луа
- Используйте редакторы Lua кода, очень трудно писать код, можно забыть написать end, do, либо что-нибудь еще. Программа из-за ошибки в луа скрипте не вылетит, но просто не выполнит код
- Lua может оказаться намного гибче, чем вам могло показаться. К примеру, числа свободно преобразуются в строки, он нетипизирован. Если передать в функцию 100 параметров, а она в С++ считывает только первые 2, то программа не вылетит. Есть еще много подобных допущений.
Вопросы и ответы
- Вопрос: Почему мы не используем луа стейт, который есть в каждой подобной функции — int foo(lua_State* L)?
Ответ: За всю программу мы используем только один стейт в Script, где регистрируем функции, инициализируем его и делаем прочие штучки. К тому же просто невыгодно было бы, написав целый класс, опять обращаться начистоту к lua_State через lua_pushboolean и прочие функции.
Полный листинг Script.h и Script.cpp
Script.h
#ifndef _SCRIPT_H_ #define _SCRIPT_H_ #pragma comment(lib,"lua.lib") extern "C" < #include #include #include > class Script < private: lua_State *lua_state; public: void Create(); void Close(); int DoFile(char* ScriptFileName); templatevoid RegisterConstant(T value, char* constantname); void Array(); template void RegisterConstantArray(T value, int index); void RegisterArray(char* arrayname); int GetArgumentCount(); template T GetArgument(int index); template void Return(T value); >; #endif
Я удалил инклуды для работы с консолью
Script.cpp
#include "Script.h" void Script::Create() < lua_state = luaL_newstate(); static const luaL_Reg lualibs[] = < , , >; for(const luaL_Reg *lib = lualibs; lib->func != NULL; lib++) < luaL_requiref(lua_state, lib->name, lib->func, 1); lua_settop(lua_state, 0); > > void Script::Close() < lua_close(lua_state); >int Script::DoFile(char* ScriptFileName) < luaL_dofile(lua_state,ScriptFileName); return lua_tointeger(lua_state, lua_gettop(lua_state)); >template<> void Script::RegisterConstant(int value, char* constantname) < lua_pushinteger(lua_state, value); lua_setglobal(lua_state,constantname); >template<> void Script::RegisterConstant(double value, char* constantname) < lua_pushnumber(lua_state, value); lua_setglobal(lua_state,constantname); >template<> void Script::RegisterConstant(char* value, char* constantname) < lua_pushstring(lua_state, value); lua_setglobal(lua_state,constantname); >template<> void Script::RegisterConstant(bool value, char* constantname) < lua_pushboolean(lua_state, value); lua_setglobal(lua_state,constantname); >template<> void Script::RegisterConstant(int(*value)(lua_State*), char* constantname) < lua_pushcfunction(lua_state, value); lua_setglobal(lua_state,constantname); >void Script::Array() < lua_createtable(lua_state, 2, 0); >template<> void Script::RegisterConstantArray(int value, int index) < lua_pushnumber(lua_state, index); lua_pushinteger(lua_state, value); lua_settable(lua_state, -3); >template<> void Script::RegisterConstantArray(double value, int index) < lua_pushnumber(lua_state, index); lua_pushnumber(lua_state, value); lua_settable(lua_state, -3); >template<> void Script::RegisterConstantArray(char* value, int index) < lua_pushnumber(lua_state, index); lua_pushstring(lua_state, value); lua_settable(lua_state, -3); >template<> void Script::RegisterConstantArray(bool value, int index) < lua_pushnumber(lua_state, index); lua_pushboolean(lua_state, value); lua_settable(lua_state, -3); >template<> void Script::RegisterConstantArray(lua_CFunction value, int index) < lua_pushnumber(lua_state, index); lua_pushcfunction(lua_state, value); lua_settable(lua_state, -3); >void Script::RegisterArray(char* arrayname) < lua_setglobal(lua_state, arrayname); >int Script::GetArgumentCount() < return lua_gettop(lua_state); >template<> int Script::GetArgument(int index) < return lua_tointeger(lua_state,index); >template<> double Script::GetArgument(int index) < return lua_tonumber(lua_state,index); >template<> char* Script::GetArgument(int index) < return (char*)lua_tostring(lua_state,index); >template<> bool Script::GetArgument(int index) < return lua_toboolean(lua_state,index); >template<> void Script::Return(int value) < lua_pushinteger(lua_state,value); >template<> void Script::Return(double value) < lua_pushnumber(lua_state,value); >template<> void Script::Return(char* value) < lua_pushstring(lua_state,value); >template<> void Script::Return(bool value)
Все вопросы посылайте мне в ЛС, либо в этот топик, либо, если вам не повезло быть зарегистрированным на хабре — на мейл izarizar@mail.ru
Туториал 0: Юнити и C# скрипт - основы
Скажу честно, я не программист, так что вполне возможно будут какие-то неточности. Это не игровой туториал. Я постараюсь рассказать, как работают скрипты в Юнити 3Д.
С# относительно не сложный язык. Точнее сама основа языка простая, сложности начинаются, когда уже совсем далеко углубляешься в него. Но на самом деле с помощью Юнити3Д можно делать простенькие игрушки только используя основы С#. C# объектно ориентированный язык програмирования. Это пишут все, но как я понял большинство не особо понимает смысл этого, как и я. Но учитывая, что придется работать со скриптами, это не так и важно для начала. Не стоит пытаться создать один огромный трудно понимаемый скрипт для всей игры. Пробуйте разделить игру на части. В свою очередь эти части могут взамодействовать друг с другом. Используйте эти части как кирпичи для создания итоговой игры. В C# используется class, который исполняет роль кирпичика. В Юнити довольно просто создать такой class. Создаете новый C# скрипт и называете его по желанию. И, грубо говоря, созданный скрипт и выполняет роль class в Юнити3Д. Далее можно использовать скрипт как компонет для игрового объекта.
Небольшой пример:
Как пример, решили сделать простенькую космическую стрелялку. Что-то похожее на этот шедевр:
В Юнити3Д это будет сцена с множеством игровых объектов: фон, звезды, камера, враг, астероид, игрок. Каждый объект в игре это GameObject. И все GameObjects состоят из Components. Некотрые компоненты заранее заготовленны в Юнити3Д. Как пример: Transform (определяет позицию объекта в пространстве), Sprite Renderer (рисует заданный объект в мире), UI Text (показывает текст в интерфейсе) и много других компонентов. И ваши C# скрипты тоже будут компонентами, которые будут присоединяться к объектам. У C# скриптов есть доступ к другим компонетами. По сути, вся работа со скриптами это просто работа с переменными.
Как использовать C# скрипты ?
Создадим empty GameObject(пустышку) в сцене. У этого объекта уже будет Transform компонент (у каждого объекта в Юнити3Д есть Transform компонент). У созданного объекта пока нет компонента отвечающего за отрисовку, поэтому мы не увидим его игре. Поэтому добавим ешё один компонент Sprite Renderer. И укажем какую картинку должен рисовать этот компонент, например астероид. Тогда мы сможем увидеть астероид в игре.
Просто смотреть на астероид скучно, поэтому можно сделать скрипт для его управления.
Не забываем, это не игровой туториал, только вкратце о принципе работы с Юнити3Д.
Создаём новый С# скрипт и называем его(например Moving, так как этот скрипт будет перемещать астероид). Если мы откроем скрипт, то увидим следующую заготовку:
using UnityEngine;
using System.Collections;
public class Moving : MonoBehaviour
// Use this for initialisation
void Start () >
//Update is called once per frame
void Update () >
>
Небольшое объяснение строчек:
| Using UnityEngine; | Добавляем доступ на UnityEngine библиотеку. Это набор различных классов/функций от Юнити3Д. |
| using System.Collections; | Это стандартная библиотека от Microsoft .NET. |
| public class Moving : MonoBehaviour | public даёт возможность доступа на этот скрипт с других скриптов. class Moving название нашего скрипта/класса. MonoBehaviour это основной класс от Юнити3Д, в нём такие важные функции как Update(), Start (). Смотрите Unity Documentation для более точного описания. |
| // Use this for initialization | Это просто комментарий. Только для вашего удобства. |
| void Start () <> | void Обозначение, что последующая функция не будет возвращать параметр (то-есть никаких вернувшихся переменных после её вызова не намечается). Start () <> эта функция выполнится один раз при старте скрипта. |
| void Update () <> | Эта функция будет выполняться заново каждый игровой кадр. |
Теперь мы можем передвинуть астероид в центр игрового мира (находится на координатах (0, 0, 0)). Позиция игрового объекта определяется в Transform компоненте. Нам надо присоединить наш скрипт к астероиду. С этого скрипта мы можем менять переменные в Transform компонент. Эти переменные и определяют положение объекта в сцене.
Например мы хотим переместить астероид в центр при старте игры.
Если надо получить доступ на какой-то компонент игрового объекта, то обычно надо сделать следующие шаги:
1. Найти нужный игровой объект: Тут много разных вариантов, все зависит от условий.
- Можно использовать поиск из C# скрипта GameObject.Find ("Name") / GameObject.FindWithTag ("Tag"). Это поиск по имени или тэгу.
- можно создать переменную типа игровой объект public GameObject; и потом в эдиторе указать к какому объекту привязана эта переменная.
- можно получить линк на игровой объект с различных функций. Например: (Trigger, Raycast. ).
- и не нужен поиск объекта, если скрипт уже находится на этом объекте.
2. Получить доступ на компонент этого объекта: через команду gameobject.GetComponent (); или GetComponent (); если скрипт на том-же объекте.
Доступ к Transform компоненту:
Для удобства есть простой путь доступа на свой Transform компонент, если компонент и скрипт находятся на одном объекте. Просто используете transform. Для доступа на другие компоненты используйте GetComponent (в старых версиях Юнити таких быстрых доступов было больше, не забываем об этом при работе с неактульными туториалами)
Позиция в игровом мире это вектор (x,y,z). Если мы хотим поместить астероид в центр, то нам надо изменить координаты вектора на (0,0,0). C# строчка будет:
transform.position = new Vector3 ( 0 , 0 , 0 );
Если мы хотим сделать это перемещение один раз в начале игры, то нам надо поместить эту строчку в функцию void Start () <> . И наш скрипт будет:
using UnityEngine;
using System.Collections;
public class Moving : MonoBehaviour
// Use this for initialisation
void Start () //сменить местоположение игрового объекта
transform.position = new Vector3 ( 0 , 0 , 0 );
>
//Update is called once per frame
void Update () >
>
Если мы запустим нашу игру, то астероид будет перемещён в центр игрового мира.
Теперь посмотрим на Transform компонент:
Используйте команду transform. для доступа к Transform компоненту на том-же игровом объекте. И в нём можно изменить позицию, вращение и размер игрового объекта (пример: transform.localScale = new Vector3 (0.5F, 1, 1);). Ваш IDE (редактор) будет пытаться помочь в наборе команд и будут показанны различные возможные варианты.
Можно не только изменять переменные, но и просто запросить их значения.
Теперь посмотрим как работать с другими компонентами. У нашего астероида есть компонент для его отрисовки (рендерер).
Например мы хотим зеркально повернуть астероид вдоль y-оси. Так как наш скрипт уже прикреплён к астероиду, то нам не нужен его поиск в игровом мире. Мы можем получить доступ на компонент командой GetComponent ().. Название компонента можно посмотреть в инспекторе игрового объекта (только осторожно с пробелами). C# команда будет:
GetComponent< SpriteRenderer >().flipY = true ;
И скрипт будет:
using UnityEngine;
using System.Collections;
public class Moving : MonoBehaviour
// Use this for initialisation
void Start () //сменить местоположение игрового оьъекта
transform.position = new Vector3 ( 0 , 0 , 0 );
//доступ к компоненту отрисовки и сменить переменную, отвечающую за зеркальное отображение по оси Y
GetComponent< SpriteRenderer >().flipY = true ;
>
//Update is called once per frame
void Update () >
>
Не забываем, при наборе кода ваш IDE будет пытаться показывать возможные варианты.
Обычно, если планируете работать часто с каким-нибудь компонентом, то лучше сделать ссылку на этот компонент. Для этого вам надо создать ссылочную переменную того же типа, что и компонент (тип переменной будет как и название компонента). И потом указать ссылку на этот компонент GetComponent (). Потом сможете использовать эту переменную для быстрого доступа к компоненту.
using UnityEngine;
using System.Collections;
public class Moving : MonoBehaviour
//декларация ссылочной переменной для компонента отрисовки спрайтов
SpriteRenderer sr;
// Use this for initialisation
void Start () //сменить местоположение игрового оьъекта
transform.position = new Vector3 ( 0 , 0 , 0 );
//делаем ссылку на компонент
sr = GetComponent< SpriteRenderer >();
//меняем переменную, отвечающую за зеркальное отображение по оси Y
sr.flipY = true ;
>
//Update is called once per frame
void Update () >
>
Похожим образом мы можем получить и доступ к компонентам на других игровых объектах.
Для начала нам надо "найти" другой игровой объект. Как я уже и писал, тут довольно много различных вариантов в зависимости от ситуации. Например в сцене есть другой игровой объект. Его имя Ship и тэг Player (Tag используется для идентификации объектов (похоже на имя, только скорость обработки быстрее)).
1. Если игровой объект находится в сцене с самого начала и не пропадает до запроса к нему, то мы можем создать открытую ссылочную переменную playerShip (с тимпом GameObject) в нашем скрипте и добавить этот объект в эту переменную через инспектор (просто перетащить объект на переменную в редакторе). И тогда через эту переменную у нас будет доступ на игровой объект. Например мы хотим поместить корабль на позицию (1, 1, 0) при старте игры. C# строчка будет:
playerShip.transform.position = new Vector3 ( 1 , 1 , 0 );
using UnityEngine;
using System.Collections;
public class Moving : MonoBehaviour
//декларация ссылочной переменной для компонента отрисовки спрайтов
SpriteRenderer sr;
//публичная ссылочная переменная для корабля игрока
public GameObject playerShip;
// Use this for initialisation
void Start () //сменить местоположение игрового оьъекта
transform.position = new Vector3 ( 0 , 0 , 0 );
//делаем ссылку на компонент
sr = GetComponent< SpriteRenderer >();
//меняем переменную, отвечающую за зеркальное отображение по оси Y
sr.flipY = true ;
//получаем доступ к transform компоненту игрока и меняем его местоположение
playerShip.transform.position = new Vector3 ( 1 , 1 , 0 );
>
//Update is called once per frame
void Update () >
>
2. Мы можем найти игровой объект в сцене через поиск и сделать на него ссылку через скрипт с помощью команды GameObject.Find ("Name") or GameObject.FindWithTag ("Tag"). Поиск по тэгу производится быстрее чем по имени. C# строчка будет:
playerShip = GameObject .Find( "Ship" );
или:
playerShip = GameObject .FindWithTag( "Player" );
using UnityEngine;
using System.Collections;
public class Moving : MonoBehaviour
//декларация ссылочной переменной для компонента отрисовки спрайтов
SpriteRenderer sr;
//публичная ссылочная переменная для корабля игрока
public GameObject playerShip;
// Use this for initialisation
void Start () //сменить местоположение игрового оьъекта
transform.position = new Vector3 ( 0 , 0 , 0 );
//делаем ссылку на компонент
sr = GetComponent< SpriteRenderer >();
//меняем переменную, отвечающую за зеркальное отображение по оси Y
sr.flipY = true ;
//ищем в сцене корабль игрока и делаем ссылку на него
playerShip = GameObject .FindWithTag( "Player" );
//получаем доступ к transform компоненту игрока и меняем его местоположение
playerShip.transform.position = new Vector3 ( 1 , 1 , 0 );
>
//Update is called once per frame
void Update () >
>
Не забываем: используйте GetComponent ();, если хотите получить доступ на отличный от Transform компонент (transform. это просто укороченный вариант для этого компонента). Например если хотите зеркально повернуть корабль по X-оси из скрипта на астероиде, то комманда в C# будет:
playerShip.GetComponent < SpriteRenderer >().flipX = true ;
using UnityEngine;
using System.Collections;
public class Moving : MonoBehaviour
//декларация ссылочной переменной для компонента отрисовки спрайтов
SpriteRenderer sr;
//публичная ссылочная переменная для корабля игрока
public GameObject playerShip;
// Use this for initialisation
void Start () //сменить местоположение игрового объекта
transform.position = new Vector3 ( 0 , 0 , 0 );
//делаем ссылку на компонент
sr = GetComponent< SpriteRenderer >();
//меняем переменную, отвечающую за зеркальное отображение по оси Y
sr.flipY = true ;
//ищем в сцене корабль игрока и делаем ссылку на него
playerShip = GameObject .FindWithTag( "Player" );
//получаем доступ к transform компоненту игрока и меняем его местоположение
playerShip.transform.position = new Vector3 ( 1 , 1 , 0 );
//указываем, что работаем с кораблем игрока, получаем доступ к компоненту отрисовки и зеркально отображаем по оси Х
playerShip.GetComponent < SpriteRenderer >().flipX = true ;
>
//Update is called once per frame
void Update () >
>
3. Мы можем получть объект с различных игровых функций. Я покажу некотрые из них в последующих туториалах (как пример: OnTriggerEnter2D (Collider2D otherCollider) <> Ссылка на объект попавший в триггер будет в otherCollider переменной).
Наверняка уже заметили, что создание игры в Юнити - это просто работа с переменными в компонентах игровых объектов (я сейчас не говорю о создании музыки, моделей, текстов . Это уже совсем другая история). Теперь посмотрим на основы С# скриптов. Описание будет довольно коротким и затронет только базовые части. Так что для подробностей придется немножко погуглить или побродить по форумам.
Основы С# скриптов:
1. Переменные:
Переменные это именованные области памяти, хранящие определенную информацию. Так как придется работать с переменными, то конечно лучше знать их основные типы:
Spoiler int:
Этот тип переменных может принимать значение целого (не дробного) числа. Переменная лежит в диапазоне от -2 147 483 648 до 2 147 483 647. Обычно используется для подсчета количества объектов или индексации массивов/циклов (о них чуть позже). int score;
int healthPoint = 5 ;
float:
Этот тип для чисел с плавающей запятой (дробные числа). Переменная лежит в диапазоне от -3.4 × 10^38 до +3.4 × 10^38. Обычно используется там, где важна дробная часть (как пример - расстояние до цели). Используйте точку для разделения знаков. float speed;
float distanceToShoot = 10.5 ;
bool:
Это тип переменных имеющих всего два значения true/false (истинно/ложно). Используется в проверке условий (условные операторы). bool isDead;
bool canMove = false;
char:
Тип переменных для символов Юникода. Например отдельные буквы. Используйте одинарные кавычки при инициализации. char litera;
char firstLitera = 'A' ;
string:
Тип переменных для символьной последовательности/текст (на самом деле это ссылочная переменная, то есть в ней хранится ссылка на область памяти, где находится эта символьная последовательность. Но её принцип работы похож на обычные переменные). В классе string содержится несколько функций. Одна из них string.Length, позволяющая узнать количество символов в строке. Для инициализации используйте кавычки. string newText;
string enemyText = "Stop! Don't move";
//пример использования функции string.Length
int howManyLetters = enemyText.Length; Vector3:
Я поместил вектор3 к обычным переменным, но на самом деле это структура. Структуры довольно похожи на классы, но в отличии от класса со значениями стурктуры можно работать напрямую, а не через ссылку. Поэтому они частично похожи на переменные. Возможны арифметические операции. Далее структура Vector3 содержит довольно много функций для работы с векторами. Смотрите Unity Documentation для более точного описания. При инициализации вектора3 надо создавать новую инстанцию с помощью new или использовать уже существующий вектор3 (тогда будет созданна его копия). Часто используется для определения местоположения объектов или их скорости и направления движения. Vector3 move;
Vector3 enemyPos = new Vector3 ( 1 , 1 , 0 );
//считывание длинны вектора
float vectorLength = enemyPos.magnitude; Существуют и другие векторы. Например Vector2 или Vector4, но принцип их работы не отличается (кроме многомерности). var:
Это ключевое слово, с помощью которого можно задекларировать переменную без обозначения её типа. Тип переменной будет определен позже в контексте программы. var summe;
float a = 1 ;
float b = 1 ;
//переменная summe получит тип float
summe = a + b;
2. Ссылочные переменные классов:
Как уже видно из описания, такие переменные хранят в себе не классы, а только ссылки на области памяти с этими классами. В качестве примера, если у вас есть переменная типа игровой объект с объектом "игрок" и вы присвоите ей значение объект "враг", то ваш "игрок" никуда не пропадёт, вы просто измените ссылку на другой объект в этой переменной. Объект, на который указывает такая ссылка, является классом с названием по типу переменной. Так вы можете создать ссылочную переменную для компонентов и объектов в Юнити. Основной смысл таких переменных в Юнити это доступ к самому классу (объекту/компоненту) или к его функциям и переменным. Ниже приведу несколько примеров:
Spoiler GameObject:
Все объекты в сцене Юнити это игровые объекты. Поэтому GameObject как базовый класс используется довольно часто. Как и большинство классов содержит в себе не только различные переменные, но и функции. Смотрите Unity Documentation для более точного описания. GameObject player;
//поиск оьъекта с тэгом Enemy и создание переменной с ссылкой на него
GameObject enemy = GameObject .FindWithTag ( "Enemy" );
Transform:
Один из очень часто используемых компонентов. Этот компонент есть у любого игрового объекта в Юнити. Отвечает за местоположение и размеры объекта в игровом мире. Так как в Юнити есть упрощённый доступ к компонету Transform у игрового объекта через команду gameobject.transform. , то используется как ссылочная переменная не так уж и часто. Смотрите Unity Documentation для более точного описания. Transform enemyPosition;
//считывание координаты х из трансформ компонента
float x = enemyPosition.position.x;
Sprite:
Класс представляющий 2Д картинку (спрайт) в качестве рессурса в Юнити. Если вы импортируете спрайт в Юнити, то будет автоматически создан новый класс содержащий этот спрайт с его различными настройками. В качестве ссылочной переменной понадобится при работе с компонентом отрисовки спрайтов. Смотрите Unity Documentation для более точного описания. Sprite enemyBullet;
SpriteRenderer:
Класс отвечающий за отрисовку (рендеринг) спрайта на экране. Рессурс для отрисовки берется из Sprite (см. выше). Как и большинство компонентов содержит в себе различные переменные и функции. Смотрите Unity Documentation для более точного описания. SpriteRenderer sr;
//активация переменной, отвечающей за зеркальное отображение по оси Y
GetComponent< SpriteRenderer >().flipY = true ;
С# скрипты и другие компоненты:
Как я уже говорил, ваши скрипты являются компонентами в Юнити. Поэтому ссылочные переменные работают аналогичным образом.
1. создаёте переменную по типу компонента (используйте его название).
2. получаете доступ к компоненту через ссылочную переменную: variable = GetComponent ();
В качестве примера скрипт из вступления: Moving moving;
moving = GetComponent< Moving >();
moving.playerShip.transform.position = new Vector3 ( 1 , 1 , 0 );
Все остальные компоненты работают аналогично. Не стану их описывать, так как их просто огромное количество.
3. Массивы (статические и динамические):
Массив это упорядочненая структура данных состоящая из элементов одного типа. Массивы могут быть не только одномерными, но и многмерными. Все элементы массива проиндексированны, для целенаправленного доступа к ним. Статический массив имеет определённый размер (количество элементов), который нельзя изменить после декларации. Размер динамического массива можно менять. Индексация массива начинается с 0, то есть первый элемент массива имеет индекс [0].
Spoiler статические массивы:
Так как размер такого массива заранее определен, то скорость работы с таким массивом выше. Поэтому используйте статические массивы, если размер массива заранее известен и будет постоянен. //декларация двумерного массива типа int, состояшего из 2*5 элементов
int [,] numbers = new int [ 2 , 5 ];
//декларация одномерного массива типа GameObject, размер массива определяется через инспектор игрового объекта
public GameObject [] enemy;
//декларация одномерного массива типа string, c его последующей инициализацией
string [] animals = new string [2] < "кот" , "собака" >;
динамические массивы:
Динамические массивы используют класс List. Этот класс находится в пространстве System.Collections.Generic, поэтому лучше присоединить это пространство к скрипту с помощью using System.Collections.Generic;. Динамические массивы позволяют различные действия с размером массива. Можно добавлять, вставлять и удалять элементы. Смотрите MSDN для более точного описания. //присоединение пространства для работы с классом List
using System.Collections.Generic;
//декларация динамического массива типа string
List < string >cars = new List < string >();
//добавление к массиву нового элемента
cars.Add( "Запорожец" );
//вставка нового элемента в массив как первый элемент
cars.Insert(0, "Ауди" );
//удаление элемента "Запорожец"
cars.Remove( "Запорожец" );
4. Модификаторы доступа:
В С# переменные могут быть с разным уровнем доступа. Уровень доступа определяет возможность обращения к переменной.
Spoiler private:
По умолчанию (если вы никак не обозначили переменную) она получает приватный уровень доступа. Так же этот уровень можно и указать с помощью private. Доступ к таким перменным возможен только внутри их содержащих классов. float speed;
private int score;
public:
Уровень доступа public даёт неограниченный доступ. Например такие переменные можно изменить из других классов. Так же переменная с публичным доступом будет видна в редакторе, это даёт возможность её настройки через инспектор. У компонентов в Юнити публичный уровень доступа. public float speed;
public GameObject player;
protected:
Уровень доступа для базового и наследуемых классов.
5. Области видимости(действия) переменных:
Место декларации переменной определяет область её видимости в содержащем скрипте.
Spoiler глобально в классе:
Переменная декларированная в классе, но не входящая в функции этого класса может быть использована глобально всеми функциями этого класса.
локально в функции:
Переменная декларированная в функции, может быть использована только в этой функции.
локально в цикле:
Область видимости такой переменной ещё меньше, она используется только локально в пределах цикла. using UnityEngine;
using System.Collections;
public class Moving : MonoBehaviour
//переменная speed может быть использованна любой функцией этого класса
public int speed;
void RandomFunction () //переменная isMoving может быть использованна только в пределах RandomFunction () <. >
bool isMoving = true;
//переменная i может быть использованна только в пределах цикла
for ( int i = speed; i < 0 ; i--) speed = i;
>
isMoving = false;
>
>
6: Арифметические операторы:
С переменными, содержащими значения, возможны различные арифметические действия. Тут приведу только основные примеры.
Spoiler Будьте осторожны при арифметических действиях с разными типами переменных. Если например записать дробный результат в целую переменную, то дробная часть потеряется. float a = 10 ;
float b = 5 ;
float c;
//сложение: c = 10 + 5
c = a + b;
//вычитание: a = 10 - 2
a = a - 2 ;
//деление: b = 8 / 2
b = a / 2 ;
//умножение: с = 10 * 1.5
с = 10 * 1.5 ;
//присвоение: a = 15
a = c;
//инкремент: увеличение а на единицу
a++;
//декремент: уменьшение а на единицу
a--;
//инкремент/декремент: могут стоять до или после переменной, изменяя порядок вычислений
7. Математические функции:
В С# есть структура Mathf для различных математических функций. Смотрите Unity Documentation для более точного описания.
Spoiler //функция вернет значение -1, так как проверочный результат отрицательный
float sign = Mathf .Sign (-5);
8. Условия и логические операторы:
Для разветвления (выбора другого варианта исполнения) программ есть различные условные операторы. Для сравнения вариантов используются логические операторы сравнения.
Spoiler логические операторы сравнения:
Результат сравнения это бинарный результат, то есть ложно или истинно (true/false). Возможны следующие сравнения:
== - равно
!= - не равно
> - больше
< - меньше
>= - больше или равно
условные операторы:
Условные операторы позволяют провести сравнение и выполнить определенную часть кода в зависимости от результата.
if . else:
Краткая форма этого условного оператора состоит только из условия и выполняемой части кода, если условие истинно. if (hp isDead = true ;
canFight = false ;
> Полная форма состоит из условия, выполняемой части кода, если условие истинно и выполняемой части кода, если условие ложно. if (hp isDead = true ;
canFight = false ;
> else isDead = false ;
canFight = true ;
> Возможно объединение различных условий в одну конструкцию. if (hp isDead = true ;
canFight = false ;
> else if (hp == 100 ) isDamaged = false ;
> бинарные логические операторы:
С помощью таких операторов можно создавать более сложные условия, состоящих из нескольких подусловий.
&& - логическое И . Будет истинно, если оба условия истинны. Или ложно, если оба или одно из них ложно.
|| - логическое ИЛИ . Будет истинно, если одно из условий истинно. И ложно, если оба условия ложны.
if (hp < 0 || hp >0 ) isZero = false ;
> else isZero = true ;
> switch:
Этот логический оператор используется для обработки множества вариантов при нахождении истинного значения. string direction = "left" ;
//искомое выражение
switch (direction) //возможный вариант, если совпадает, то выполняется последующий код
case ( "up" ):
move = Vector2 .up;
isMoving = true ;
//прерывает дальнейшее выполнение логического оператора (при совпадении варианта)
break ;
//возможный вариант, если совпадает, то выполняется последующий код
case ( "down" ):
move = Vector2 .down;
isMoving = true ;
//прерывает дальнейшее выполнение логического оператора (при совпадении варианта)
break ;
//в данном примере выполнится эта часть кода и работа логического оператора будет завершена
case ( "left" ):
move = Vector2 .left;
isMoving = true ;
//прерывает дальнейшее выполнение логического оператора (при совпадении варианта)
break ;
//возможный вариант, если совпадает, то выполняется последующий код
case ( "right" ):
move = Vector2 .down;
isMoving = true ;
//прерывает дальнейшее выполнение логического оператора (при совпадении варианта)
break ;
//если ни один из вариантов не был истинной, то выполняется часть кода стоящая после default
default :
move = Vector2 .zero;
isMoving = false ;
//прерывает дальнейшее выполнение логического оператора
break ;
>
9. Циклы:
Циклы используются для многократного исполнения определенных задач (фрагментов кода).
Spoiler for:
Этот цикл выполняется определённое количество раз. //для примера, декларация массива на 10 целых элементов
public int [] numbers = new int [ 10 ];
//int i = 0; декларация с инициализацией счетчика цикла
//i < 10;проверка возможности запуска следующего цикла (пока условие истинно)
//i++; изменение счетчика цикла
for ( int i = 0 ; i < 10 ; i++) //исполняемая часть кода при каждом новом цикле
//в данном примере, заполнение массива числами от 0 до 9
numbers [i] = i;
> Хоть это и не обязательно, но советую использовать в счетчиках циклов целые значения, чтобы избежать ошибок от дробных вычислений.
while:
Этот цикл выполняется пока условие истинно. //для примера, декларация массива на 10 целых элементов
public int [] numbers = new int [ 10 ];
//декларация с инициализацией переменной к, которую будем использовать для проверки условия цикла
int k = 9 ;
//проверка условия цикла, выполнить цикл, если условие истинно
while (k >= 0 ) //выполняемый фрагмент кода в фигурных скобках
//заполнение массива числами от 9 до 0 в обратном порядке
numbers [k] = k; //уменьшение переменной на 1 (чтобы получить ложное условие)
k--;
> Будьте осторожны с циклами, чтобы не получить "вечный" цикл, когда условие всегда истинно и цикл повторяется вечно.
do. while:
Отличие этого цикла от цикла while только в том, что проверка условия производится после выполнения фрагмента кода. Поэтому этот цикл выполнится всегда как минимум один раз. //декларация публичной текстовой переменной
public string testText;
//декларация и инициализация целой переменной, для условия цикла
int j = 0 ;
//выполнение фрагмента кода цикла
do //добавление к текстовой переменной цифры преобразованной в текстовый символ
testText = testText + j.ToString();
//увеличение j на единицу
j ++;
//проверка условия, повторить цикл, если условие истинно
> while (j < 10 );
//результат работы цикла это текст "0123456789"
foreach:
Цикл для работы с массивами. Перебирает все элементы по одному. //декларация и инициализация массива
int [] numbers = new int [ 5 ] < 21 , 28 , 13 , 4 , 15 >;
//декларация массива для копирования
int [] numbersCopy = new int [ 5 ];
//вспомогательная переменная для индекса массива
int i = 0 ;
//запуск цикла проходяшего по всем элементам массива
//переменная number должна совпадать с типом элементов массива
foreach ( int number in numbers) //копирование текущего элемента в другой массив
numbersCopy [i] = number;
//увеличение индекса на 1, для доступа к следующему элементу в массиве для копии
i++;
>
//итог цикла это копирование элементов в новый массив
операторы break и continue:
Эти операторы помогают управлять исполнением циклов.
break - этот оператор полностью прекращает цикл и переходит к дальнейшему исполнению программы
continue - этот оператор прекращает текущее исполнение цикла и начинает новое
//вспомогательная переменная для индекса массива
int i = 0 ;
//запуск цикла проходяшего по всем элементам массива
//переменная number должна совпадать с типом элементов массива
foreach ( int number in numbers) //копирование текущего элемента в другой массив
numbersCopy [i] = number;
//увеличение индекса на 1, для доступа к следующему элементу в массиве для копии
i++;
//как переменная для индекса стала равна 3, прекращаем исполнение цикла
if (i == 3 )
break ;
>
10. Функции:
Функция это обособленный фрагмент кода для выполнения определенной задачи. Функция может вызываться многократно в тех случаях, когда нужно решить эту задачу. Это позволяет избежать повторения кода. Функции могут быть как сделанные вами индивидуально для достижения ваших целей, так и заготовками от Юнити для стандартных решений. Функции являются частью классов. Функции, как и переменные, имеют различные уровни доступа. К public функциям возможен доступ из других классов, доступ к private функциям возможен только внутри их содержащих классов. Для работы функциям могут понадобиться входные данные - аргументы (функции могут использовать и глобальные переменные их содержащих классов). После своей работы функция может возвращать какой-то результат (используйте Return для возвращения результата). Тип функции должен соответсвовать типу возвращаемого результата. Существуют и функции не возвращающие результат, такие функции имеют тип void.
Spoiler стандартные функции от Юнити:
Существует много различных функций в Юнити. Тут я точно не смогу показать и малой части. Поэтому пока ограничимся несколькими примерами. В дальнейшем в туториалах будут попадаться и новые функции.
Instantiate:
Эта функция помещает клон объекта в сцену. Обычно используется для клонирования префаба(образца). //создаёт клон префаба в сцене на заданной позиции (Vector3) с заданным вращением (Quaternion)
Instantiate (prefab, position, rotation); Destroy:
Эта функция удаляет объект из сцены. //удаляет игровой объект из сцены после заданного интервала (или сразу, если время не указать)
Destroy (gameobject, time); функции классов:
Часто, если используете какой-то компонент (класс), то он содержит различные функции для работы с ним. Список этих функций можно увидеть в редакторе C# после набора ссылочной переменной (+ точка) указывающей на этот компонент. //изменяет дробную переменную в компоненте аниматор
GetComponent < Animator >().SetFloat ( "Speed" , 0 );
функции пользователя:
Конечно можно использовать и свои функции для выполнения нужных задач. //функция нанесения повреждений
public void DoDamage ( int damage) hp = hp - damage;
if (hp Destroy (gameObject);
>
11. События:
События похожи на функции, только их запуск привязан к различным событиям. Приведу только несколько примеров.
Spoiler void Awake() //это событие вызывается один раз при загрузке скрипта. Обычно используется для инициализации объектов.
void Awake() //C#
> void Start() //это событие вызывается один раз после того, как все void Awake() были выполнены. Используется для инициализации переменных.
void Start() //C#
> void Update() //это событие вызывается заново каждый новый кадр. Обычно содержит основной код для управления игровым объектом.
void Update() //C#
> void LateUpdate() //это событие вызывается заново каждый новый кадр после обработки всех Update(). Обычно используется для управления камерой, чтобы отрисовать уже готовую сцену.
void LateUpdate() //C#
> void FixedUpdate() //это событие вызывается через фиксированный интервал (стандарт 0.02). Используется в расчетах физики (физика не считается в Юнити каждый кадр).
void FixedUpdate() //C#
> OnTriggerEnter2D()
Возможны и другие варианты срабатывания триггера (Enter, Exit, Stay). //это событие вызывается при попадании коллайдера2Д в триггер2Д. Переменная other будет содержать ссылку на попавший в триггер объект.
void OnTriggerEnter2D( Collider2D other) //C#
>