Adobe Flash 11 Stage3D (Molehill) game programming (Chapter 6 - 10) / Программирование игр в Adobe Flash 11 Stage3D (Molehill) (Глава 6 - 10): Таймеры, ввод и сущности: Великолепный геймплей!

Теперь вы вступаете на уровень 7.
Следующий шаг в нашем грандиозном приключении – реализовать управление игрока, так чтобы действительно чувствовалось, что вы что-то делаете! Прекрасной графики и фантастической частоты кадров уже не достаточно – пришло время взять узду и укротить это животное, добавив таймеры и класс игровых сущностей для более простого контроля действий.

Orion45 19.05.13 в 14:23

Интерактивность – отличительный признак игры. Геймплей - это результат обратной связи входных данных, которые приводят к интересным выходным данным. Действие и реакция. Нажмите кнопку и выстрелите пулей. Выстрелите ракетницей и разнесите пришельца в щепки. Уничтожьте босса и перейдите на следующий уровень. Всё это – цикл обратной связи, который превращает демо в игру. Причина и следствие, которые комбинируясь приводят к геймплею.

Orion45 11.06.13 в 19:45

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

Orion45 11.06.13 в 20:05

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

Orion45 15.06.13 в 16:07

Ваша скорость будет зависеть от частоты кадров, это значит, что она будет в зависимости от времени и не будет ускоряться или замедляться, если FPS изменится. Игровой мир будет увеличиваться и сложности с дополнительными астероидами и небом на заднем фоне. GUI игрового движка будет обновлено благодаря добавлению HUD (хэдз-ап-дисплей) графики, которая накладывается поверх 3D-графики. Наконец, ваш космический корабль будет иметь светящийся анимированный двигатель, чтобы быть немного более привлекательным.

Orion45 15.06.13 в 17:18

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

Orion45 15.06.13 в 17:29

Сохраняем простоту.
Как и во многих приключениях путь к нашей цели ведёт нас через искушения. Мы можем поддаться искушению добавить так много геймплея и так много характеристик, что мы можем упустить ошибки в чрезмерно сложной игре.
Мы начнём с более базового геймплея, цикла обратной связи: простота действий, которая складывается в ответную реакцию геймплея. Мы создадим основной фреймворк общих игровых классов, который, который просто надстроить.

Orion45 22.06.13 в 05:39

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

Orion45 22.06.13 в 05:53

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

Orion45 22.06.13 в 06:07

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

Orion45 22.06.13 в 06:17

Для того, чтобы сделать это, мы должны создать повторно используемый игровой класс таймера, который отслеживает сколько времени прошло до сих пор, а также сколько точно времени прошло с момента предыдущего кадра. Это важно, потому что FPS будет постоянно изменяться ( без потерь пользователь играет на супер-мощном компьютере, и частота кадров никогда не падает ниже максимальной). Каждый кадр в игре будет занимать различный период времени и изредка будут большие расхождения между частотой кадров и периодом времени в ходе игровой сессии. Когда много всего происходит или есть сразу много мешей на экране, требуется длительное время, чтобы отобразить экран и обновить модели.

Orion45 22.06.13 в 06:33

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

Orion45 22.06.13 в 06:39

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

Orion45 22.06.13 в 06:49

Наконец, вместо заполнения одного исходного файла Action Script с тысячами линий связанного кода, чтобы создавать и анимировать различные игровые объекты, такие как космические корабли, рельеф, будет мудро создать абстрактный класс игровых сущностей. Этот класс сущностей будет отвечать за инициализацию объектов , расчёт матриц трансформации каждого объекта, рендеринг себя, и т.д.

Orion45 22.06.13 в 07:00

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

Orion45 22.06.13 в 07:08

Делаем нашу игру более интерактивной.
Для того, чтобы успешно завершить квест, намеченный ранее, мы должны совершить следующее:
Добавить HUD-дисплей поверх графики
Запрограммировать класс игрового таймера
Создать простой класс входящих игровых данных
Реализовать абстрактный класс сущностей
Спроектировать оформление для нашего нового, улучшенного игрового мира
Обновить наш игровой движок, чтобы управлять всем этим новым хламом

Orion45 22.06.13 в 07:16

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

Orion45 22.06.13 в 07:32

Добавляем HUD-дисплей поверх графики.
Мы наложим изображение поверх нашего Stage3D вида, которое действует в качестве привлекательного окна для нашей 3D-графики. Создайте .PNG файл в вашем основном редакторе изображений, таком как Photoshop. Убедитесь, что большая часть этого изображения прозрачная. Вы можете добавить ориентационную сетку (прицел), или стекло кубрика корабля, или маленький компьютерный терминал. Для нашего примера игры-шутера с космическим кораблём, мы используем это изображение:

Orion45 25.06.13 в 18:17

Немного техно-метала и пара компьютерных экранов – это всё, что требуется, чтобы получить немного стиля в нашей игре. Вы можете использовать множество изображений или только одно изображение (как выше), которое точно такого же размера как и ваша игровая сцена. Импортируйте это изображение во Flash, перетащив его на палитру библиотеки и убедитесь, что оно использует корректное имя и доступно в вашем Action Script. Если вы используете чистый AS3 или Flex, тогда просто добавьте его в код тегом [Embed].

Orion45 25.06.13 в 18:35

Время для действий: накладываем GUI.
Создайте ссылку на ваше новое наложенное изображение HUD в коде, лучше на верху вашего класса Stage3dGame.as, где-нибудь под определением класса, например:
public class Stage3dGame extends Sprite {
// наложенное изображение HUD:
// Версия для чистого AS3:
[Embed (source = "hud_overlay.png")]
private var hudOverlayData:Class;
private var hudOverlay:Bitmap = new hudOverlayData();
// Версия Adobe CS5:
private var hudOverlay:Bitmap =
new Bitmap(new hudTextureBitmapData(640,4 80));

Orion45 25.06.13 в 18:44

Мы только встроили AS3 код или версию для CS5 в зависимости от вашей рабочей среды. Сейчас, всё, что мы должны сделать – это добавить этот новый hudOverlay битмап на сцену во время инициализации вашей игры. Добавьте следующие строчки наверх вашей существующей функции initGUI() следующим образом:
private function initGUI():void {
// накладываем хэдз-ап-дисплей
addChild(hudOverlay);

Orion45 25.06.13 в 18:51

Что же произойдёт?
Теперь, когда вы соберёте и запустите ваш SWF, вы должны увидеть наложение поверх вашего Stage3D вида. Помните, что причина, по которой мы можем добавить его на сцену в любое время (перед или после создания Stage3D) в том, что 3D графика всегда рендерится первой, ниже всех обычных Flash спрайтов.

Orion45 25.06.13 в 19:00

Отслеживаем время: игровой класс таймера.
Следующий шаг в нашем квесте обновления нашей игры – реализовать простой класс, который будет в конечном счёте пульсом нашей игры. Он должен отслеживать время, которое проходит, так, чтобы мы знали когда предметы должны двигаться , взрываться или обновляться.

Orion45 06.07.13 в 05:46

Один из очень удобных приёмов, который может быть использован, чтобы сохранить вашу игровую частоту кадров невероятно быстрой, это совершать сложные вычисления каждое время от времени, а не каждый отдельный кадр. Хотя многое в вашей игровой логике должно делаться каждый кадр как часть цикла рендеринга, большинство мастеров программирования игр полагаются на замечательную технику оптимизации, которую иногда называют функцией «сердцебиения». Это техника оптимизации, которую большинство ААА игр используют, чтобы сохранить FPS таким высоким, как это возможно.

Orion45 06.07.13 в 06:04

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

Orion45 06.07.13 в 06:18

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

Orion45 06.07.13 в 06:34

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

Orion45 06.07.13 в 06:44

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

Orion45 06.07.13 в 06:53

Для того, чтобы успешно реализовать предыдущие особенности, вы должны совершить следующее:
1. Создать новый класс с переменными для записи времени и счётчиков.
2. Создать конструктор, занимаемый функцией указателем для использования как функция сердцебиения.
3. Запрограммировать функцию счёта, которая выполняется каждый кадр и измеряет интервал времени.
4. Запускать функцию сердцебиения только когда это нужно.

Orion45 06.07.13 в 07:01

Время действовать - создаем класс таймер для игры
Описанные выше шаги кратко излагают то, что должно быть запрограммировано в классе GameTimer, что бы быть готовым к использованию в нашей игре. Для начала, давайте создадим новый класс. Создайте новый файл в папке проекта, и назовите его GameTimer.as и опишите таймер следующим образом:
// Stage3d game timer routines version 1.0
package
{
import flash.utils.*;
public class GameTimer {
// когда игра начата
public var gameStartTime:Number = 0.0;
// метка: предыдущий фрейм
public var lastFrameTime:Number = 0.0;
// метка: текущий фрейм
public var currentFrameTime:Number = 0.0;
// сколько милисекунд назад был вызван предыдущий кадр
public var frameMs:Number = 0.0;
// колличество фреймов в текущей игре
public var frameCount:uint = 0;
// когда показывать следующий
public var nextHeartbeatTime:uint = 0;
// сколько милисекунд прошло
public var gameElapsedTime:uint = 0;
// как часто происходит сердцебиение
public var heartbeatIntervalMs:uint = 1000;
// функция для запуска удара сердца
public var heartbeatFunction:Function;
}

oneassasin 03.07.13 в 15:31

Что же произойдёт?
В предыдущем коде всё, что мы сделали, это создали новый класс по имени GameTamer, который сохраняет несколько удобных публичных переменных, которые могут быть необходимы нашей игре. Во время нашего игрового цикла рендеринга мы будем обновлять наш таймер, и эти значения будут меняться.

Orion45 06.07.13 в 07:10

Время для действий: добавляем конструктор класса GameTimer.
Теперь мы запрограммируем конструктор таймера. Наша игра захочет передать ссылку на функцию сердцебиения, которой мы хотим вызывать таймер, и как часто мы хотим запускать его:
//конструктор класса
public function GameTimer(
heartbeatFunc:Function = null, heartbeatMs:uint = 1000)
{
if (heartbeatFunc != null)
heartbeatFunction = heartbeatFunc;
heartbeatIntervalMs = heartbeatMs;
}

Orion45 06.07.13 в 18:03

Что же произойдет?
Предыдущий код просто инициализирует наш новый класс GameTimer , объявляя ссылки на функцию обратного вызова, которую наша игра, возможно, должна запускать через определённые интервалы.

Orion45 06.07.13 в 18:20

Время для действий: реализуем функцию отсчёта.
Нашей игре нужно обновлять таймер каждый кадр, так что она получает возможность измерять время, прошедшее с предыдущего кадра и, возможно, запускать функцию сердцебиения если нужно. Следующая функция отсчёта будет делать для нас эту работу.
public function tick():void {
currentFrameTime = getTimer();
if (frameCount == 0)
// первый кадр?
{
gameStartTime = currentFrameTime;
trace("First frame happened after "
+ gameStartTime + "ms");
frameMs = 0;
gameElapsedTime = 0;
}
else
{
// сколько времени прошло с последнего кадра?
frameMs = currentFrameTime - lastFrameTime;
gameElapsedTime += frameMs;
}
if (heartbeatFunction != null)
{
if (currentFrameTime >= nextHeartbeatTime)
{
heartbeatFunction();
nextHeartbeatTime = currentFrameTime + heartbeatIntervalMs;
}
}
lastFrameTime = currentFrameTime;
frameCount++;
}
} // конец класса
} // конец пакета

Orion45 06.07.13 в 18:32

Что же произойдет?
На этом мы закончим наш воображаемый новый класс GameTimer! Как вы можете видеть, это очень простой кусок кода. Тем не менее, он тоже очень полезен и достаточно мощен: фактически, каждая ига, даже готовая, использует что-то вроде этого, чтобы следить за временем, и вызывает события в зависимости от прошедшего времени.

Orion45 06.07.13 в 18:41

Функция getTimer возвращает значение в миллисекундах. Запомнив предыдущее значение, наш класс таймера может рассчитать, сколько мс прошло с начала игры или с последнего раза, когда вызывалась функция отсчёта.

Orion45 06.07.13 в 19:32

Зачем измерять время постоянно? Разве не проще обновлять локации и анимации каждый кадр? Причина этого в том, что мы никогда не можем быть уверены, что наша частота кадров не будет колебаться. Человек, запустивший вашу игру на менее мощной машине, будет иметь более низкую частоту кадров, чем некто, запустивший игру на мощном игровом устройстве. Используя таймеры, ваша игра будет запускаться с одинаковой скоростью, несмотря на FPS, и по мере роста, она будет запускаться с точно такой же скоростью, независимо от того, насколько мощная машина.

Orion45 08.07.13 в 01:49

В вашей игре вместо изменения положения движущейся ракеты с помощью жёстко закодированного расстояния каждый кадр, например, вы можете перемещать её на нужное расстояние путём умножения скорости на время его последнего обновления. Это называется независимая от частоты кадров симуляция.

Orion45 08.07.13 в 01:57

Измерение времени – это первый шаг в создании интерактивности в игре. Анимации должны знать, сколько времени прошло, и игровые события часто происходят только в определённые интервалы. Некоторые объекты в нашей игре, возможно, должны знать свой «возраст», для того, чтобы взрываться после определённого периода времени. На данный момент это всё, что нам нужно, для того, чтобы перейти к следующему шагу.

Orion45 08.07.13 в 02:05

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

Orion45 08.07.13 в 02:16

Так как многие игры могут вместо этого использовать мышь для перемещения или чтобы осмотреться, что должно быть удобно в шутерах от первого лица, мы должны также отслеживать местоположение мыши и обнаруживать нажатия кнопки и перетаскивания. Наконец, обычно многие игры используют клавиши клавиатуры W, A, S, D для перемещения, как альтернатива использованию клавиш со стрелками. Эта схема ввода данных очень распространена в шутерах и также является удобной , что обеспечит пользователям запуск вашей игры на устройствах без клавиш со стрелками (таких как некоторые телефоны), и они всё ещё смогут управлять вашей игрой.

Orion45 08.07.13 в 02:31

Для того, чтобы запрограммировать предыдущие характеристики, мы должны совершить следующее:
1. Создать новый класс по имени GameInput
2. Добавить переменные, используемые для отслеживания текущих состояний ввода.
3. Запрограммировать конструктор, который инструктирует Flash отправлять события, когда входящие данные изменились.
4. Обработать входящие события, обновляя текущее состояние входных данных.

Orion45 08.07.13 в 02:37

Время для действий: создаём класс GameInput.
Принимая во внимание предыдущие шаги, создадим новый файла класса по имени GameInput.as в вашей папке проекта:
//алгоритм ввода данных Stage3D игры, версия 1.0
//
package
{
import flash.display.Stage;
import flash.ui.Keyboard;
import flash.events.*;
public class GameInput {
// текущее состояние мыши
public var mouseIsDown:Boolean = false;
public var mouseClickX:int = 0;
public var mouseClickY:int = 0;
public var mouseX:int = 0;
public var mouseY:int = 0;
// текущее состояние управления с клавиатуры
public var pressing:Object =
{ up:0, down:0, left:0, right:0, fire:0 };
// если обзор мышью включён, он добавляется вслед за камерой
public var cameraAngleX:Number = 0;
public var cameraAngleY:Number = 0;
public var cameraAngleZ:Number = 0;
// если trueперетаскивая мышь, изменяем угол камеры
public var mouseLookMode:Boolean = true;
// основная сцена игры
public var stage:Stage;

Orion45 08.07.13 в 17:44

Что же произойдёт?
В предыдущем коде мы импортировали во Flash функциональность, требующуюся для мыши и клавиатурных событий. Затем мы определяем на ш класс GameInput и сохраняем переменные, которые будут использоваться в нашей игре, чтобы запрашивать текущее состояние ввода. Например, в нашей игре мы сможем, в конечном счёте, проверить, если нашклассввода.нажатие.левое истинно или нет, и тогда действовать соответственно.

Orion45 08.07.13 в 17:55

Время для действий: программируем конструктор класса Gamelnput.
Непосредственно под объявлением переменных, которые мы только что добавили, добавьте конструктор класса, который будет выполняться всякий раз, когда мы создаём новый объект GameInput в нашей игре. Мы сделаем это следующим образом:
//конструктор класса
public function GameInput(theStage:Stage)
{
stage = theStage;
// получаем нажатия клавиш и обнаруживаем потерю фокуса игры
stage.addEventListener(KeyboardEvent.KEY_DOWN, keyPressed); stage.addEventListener(KeyboardEvent.KEY_UP, keyReleased);
stage.addEventListener(Event.DEACTIVATE, lostFocus);
stage.addEventListener(Event.ACTIVATE, gainFocus);
stage.addEventListener(MouseEvent.MOUSE_DOWN, mouseDown); stage.addEventListener(MouseEvent.MOUSE_UP, mouseUp); stage.addEventListener(MouseEvent.MOUSE_MOVE, mouseMove);
}

Orion45 08.07.13 в 18:04

Что же произойдет?
Так как процедуре ввода требуется ссылка на сцену игры, мы должны отправлять её этой процедуре. Затем мы инструктируем Flash информировать нас, когда происходит любое из событий, связанных с вводом игрока. Они включают события отпускания и нажатия клавиши, события мыши и события, которые сообщают игре, когда теряется фокус (такие как когда пользователь щёлкает другое окно браузера и больше не глядит на игру). Это важно, потому что когда игра теряет фокус клавиатуры, мы, возможно, захотим приостановить игру или предположить, что клавиши движения, нажатые ранее, уже не в таком состоянии: мы можем никогда не получить события KEY_UP, если клавиша была отпущена после того, как игра потеряла фокус ввода.

Orion45 08.07.13 в 18:20

Время для действий: определяем движения мыши.
Следующий шаг это запрограммировать значения, чтобы определять местоположение мыши, нажата ли кнопка или нет, и запоминать начало клика с перетаскиванием, так чтобы мы могли измерить расстояние, которое преодолела мышь, перед тем, как была отпущена кнопка. Мы сделаем это следующим образом:
private function mouseMove(e:MouseEvent):void {
mouseX = e.stageX;
mouseY = e.stageY;
if (mouseIsDown && mouseLookMode)
{
cameraAngleY = 90 * ((mouseX - mouseClickX) / stage.width);
cameraAngleX = 90 * ((mouseY - mouseClickY) / stage.height);
}
}

Orion45 08.07.13 в 18:30

Следующая функция будет запускаться каждый раз, когда игрок перемещает мышь. В ситуациях, когда кнопка мыши удерживается нажатой, мы хотим отслеживать пройденное расстояние с момента, когда кнопка была нажата первый раз, для того чтобы надлежащим образом осуществлять «обзор мышью» в нашей игре.
private function mouseDown(e:MouseEvent):void {
trace('mouseDown at '+e.stageX+','+e.stageY);
mouseClickX = e.stageX;
mouseClickY = e.stageY;
mouseIsDown = true;
}

Orion45 11.07.13 в 00:19

Предыдущая функция срабатывает, когда впервые нажимается кнопка мыши. Текущее положение курсора мыши записывается для использования в предыдущей функции mouseMove, так что мы знаем, где «перетаскивание мышью» началось впервые, что позволяет нам измерять расстояние, которая она прошла по экрану.
private function mouseUp(e:MouseEvent):void {
trace('mouseUp at '+e.stageX+','+e.stageY+' drag distance:'+ (e.stageX-mouseClickX)+','+(e.stageY-mouseClickY));
mouseIsDown = false;
if (mouseLookMode)
{
// reset camera angle
cameraAngleX = cameraAngleY = cameraAngleZ = 0;
}
}

Orion45 11.07.13 в 00:26

Что же произойдёт?
В предыдущем коде, каждый раз, когда срабатывает новое событие мыши, мы сохраняем информацию для использования в нашей игре. Для функциональности обзора мышью мы измеряем расстояние, пройденное мышью, и вычисляем подходящий угол камеры путём умножения 90 градусов на число процентов от размера сцены, который прошла мышь.

Orion45 11.07.13 в 00:33