Disaster

Ответы в темах

Просмотр 14 сообщений - с 1 по 14 (из 14 всего)
  • Автор
    Сообщения
  • в ответ на: О том, как я игрушку на BGE делал #13369
    Disaster
    Disaster
    Участник

    Что я могу рассказать такого, что бы вы не забыли про меня?)
    Работы ведутся. Правда, не сильно быстро т.к. работы работать нужно нормальные, кроме развлечений в bge…
    Бонусом ещё и обновление само по себе жирное готовится.
    Я оглашу список, но к выходу обновления не обещаю соблюдение всех пунктов:

    1. Планирую новую карту. Какой она будет – сказать не могу. Но она будет типа “спринт” для удобной оптимизации в виде лодов для карты и более удобного определения времени заезда, процента прохождения и т.д. Бонусом “спринт” это стандартная для ралли штука. Скорее всего трасса будет летняя, покрытие типа гравий, песок, асфальт.

    2. Переход на 2.78. В первую очередь переход на более позднюю версию принесёт в игру pbr шейдер, исправление ошибок и увеличение производительности.

    3. Как я уже сказал выше – pbr шейдер. Он уже достаточно оптимизирован и проверен на lancia stratos. Добавились красивые фейковые отражения с преломлением и карта отражений (правда шейдер пришлось править для оптимизации). Стоит уделить внимание крыше, на которой видно преломление отражений. Это и есть основная фича pbr в rallycross =) В динамике можно также заметить разное преломление у загрязнений на стёклах, на капоте и багажнике. Да и вообще в динамике всё лучше)

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

    5. Машинка будет вести себя на разных покрытиях по-разному в физическом плане. Это в первую очередь касается сцепления и динамики разгона\торможения.

    6. Планируется интерфейс. Уже продумана чёткая как часики и быстрая реализация паузы, системы профилей и настройки. Тоесть, теперь в процессе игры можно будет менять\сохранять\загружать настройки (да-да, прямо в файлы). Готовы скрипты для всяких регуляторов\галочек под интерфейс. Это будет полезно для всех рабов bge, независимо от их целей =)

    7. Частично продумана смена автомобилей с разными настройками. В перспективе это будет набор текстур, меш и cfg файл с характеристиками. Но далеко не факт, что появится в следующем обновлении т.к. есть ещё некоторые проблемы. В основном трудности были в открытии\чтении конфигов, но с недавних пор я таки овладел этим сложным делом и осталось всего-лишь продумать “сборку” модели из внешних ресурсов в самом движке.

    Тоесть, фактически, игра изменится очень-очень сильно. Она станет не только сложнее в плане кода и структуры исходника, но и проще для последующих работ или модификаций, если таковые будут. Добавиться много нового функционала типа паузы, скрипты полей для ввода, чекбоксов, регуляторов, работа со внешними файлами через функции чистого python. Если повезёт я задействую даже сторонние библиотеки(по-научному модули) python для упрощения работы с конфигами и разбивания данных cfg документов на пары ключ=значение.

    На этом пока всё. В процессе обязательно буду информировать вас о процессе и степени готовности обновления =)

    в ответ на: О том, как я игрушку на BGE делал #13271
    Disaster
    Disaster
    Участник

    А теперь её можно ещё и покрутить =)

    в ответ на: О том, как я игрушку на BGE делал #13268
    Disaster
    Disaster
    Участник

    Всем привет!
    Вчера вот задумался о том, какие крутые тачки делала фирма Lancia!

    Марка эта, кстати, не сильно популярна (скажем так – про митсубиши и субару вы явно слышали чаще). Однако – Lancia хоть и была дочерней фирмой фиата, но делала невероятно красивые автомобили! (шутка про то, что фиаты страшные).
    Впрочем, как показывает практика – дочерние фирмы не всегда берут пример с родительских. Посмотреть на тот же Pixar. Он хоть и является частью Disney, но в мультфильмах Pixar на 99% больше смысла и на столько же меньше песен =)

    Визитной карточкой этой марки является Lancia Stratos. Это, пожалуй, один из самых узнаваемых автомобилей в мире.

    Главная особенность Lancia Stratos после внешнего вида – двигатель Ferrari Dino V6 (2.4л).
    Почти 200 л.с в автомобиле весом 980 кг! И это в купешке 1972г! Да тазы даже сегодня таких мощей выдать не могут.
    Бонусом – это автомобиль не для асфальта. Конструкционно он должен летать по грязям, щебням, пескам и снегам, что определяет многие требования к узлам.
    Короче говоря – очень рекомендую загуглить это прекрасный аппарат.

    Собственно – думал я о машинке, думал и решил, что надо бы её сделать для своей игрушки!
    В любой уважающей себя игрушке про ралли обязаны быть Subaru Impreza, Mitsubishi lancer и Lancia Stratos.
    Собственно – подумал, подумал да и сделал.
    На ваш суд =)


    Да, колёсики из Need For Speed Pro Streer)

    Ну а вот так оно выглядит в последнем обновлении:

    4946 треугольников, текстура 2048х2048 (для возможности её потом пожать)

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

    в ответ на: Курс по BGE от drdotmom #13266
    Disaster
    Disaster
    Участник

    Написание курса пока заморожено. Идёт переосмысление порядка глав и подачи информации.
    Скорее всего разделю курс на большие части вместо глав.
    – Сам bge. Его особенности, отличия, структура.
    – Bge python. Написание скриптов и использование стандартных функций python в bge
    – Игровая графика. шейдеры, освещение – всё, что касается графической части.
    – Игровые модели. Особенности игровых моделей от моделей “только для рендеринга”, лоды\коллижн-модели, текстуры – всё в таком духе.
    – Звук. Всё про особенности игровых звуков, подбор, создание, адаптация к игре.
    (итоговый порядок может и будет отличаться)

    в ответ на: Курс по BGE от drdotmom #13255
    Disaster
    Disaster
    Участник

    @stkopp, если бы я умел писать GLSL шейдеры – я бы не подрабатывал сейчас автомехом=)
    В любом случае я обязательно посмотрю, что там и как, но ничего не обещаю ибо мне все эти vector3+vector2 – тёмный лес короче.

    Бонусом я пока ещё не до конца разобрался с bge python. Нужно ещё много сказать и переоформить сам курс, выделив отдельно всё, что касается питона и с более жёсткой структурой.

    в ответ на: Курс по BGE от drdotmom #13205
    Disaster
    Disaster
    Участник

    Глава 4.
    Подробнее про синтаксис и сам процесс написания скриптов на bge python.

    Как я понял – синтаксис был затронут слишком поверхностно. Попробую рассказать о нём подробно.

    Подготовка пространства Blender 3D для работы с BGE
    Во-первых – стоит заменить таймлайн на редактор логики. Таймлайн в процессе создания игрушки вам врядли пригодится. Вообще я настоятельно рекомендую создавать все объекты в другой сессии блендера. Это позволит вам сосредоточиться строго на объекте и не путаться в сцене.
    Далее – окно 3D вида стоит разделить и в одном из получившихся открыть Text Editor для редактирования скриптов.
    При желании можно так же потянуть за уголок, но с зажатым шифтом для того, что бы вместо разделения текущего окна создалось отдельное, которое можно в случае чего свернуть.
    Тип рендера следует переключить на Blender Game, в n-панели 3D вида во вкладке Shading установить режим материала на GLSL.
    В редакторе текста нажать Ctrl+T (появится T-панель) и во вкладке Proporties включить Line Numbers (нумерация строк), Word Wrap (перевод строк) и Syntax Highlight (подсветка синтаксиса)

    Заповеди bge python.
    1. Всё, что вы имеете в скрипте – можно присвоить переменной.
    Это и значения, и имена объектов, и функции. При присвоении используется оператор ‘=’. При этом значение правой части присваивается переменной в левой части
    x = y \\ x принимает значение y
    color = [1.0, 1.0, 1.0] \\ color принимает набор значений
    object = scene.objects [‘Empty’] \\ object принимает значение объекта Empty становясь “ссылкой” на него.
    debug = bge.render.showProperties \\ debug принимает значение функции, показывающей переменные. Теперь для её активации достаточно написать debug = True для активации или debug = False для деактивации.

    2. Всегда соблюдай табуляцию.
    В текстовом редакторе Blender табуляция (Tab) по-умолчанию ровняется четырём пробелам, однако смысловая разница есть.
    Табуляция используется под каждым логическим оператором.

    ##########################################
    if x == t:
    	y = 4
    elif x != t and y<1:
    	y = 2
    else:
    	y = 6
    ##########################################
    if x == t:
    	if x == 3:
    		y = 1
    	if x == 4:
    		y = 3
    	else:
    		y = 0
    else:
    	y = 2
    
    #########################################

    Табуляция – способ разделения условия от операции, производимой при соблюдении этого самого условия.
    Кстати говоря – вы можете записать операции и в одну строку, разделив их знаком ;
    if x == t: y = 4; g = 2; e = 0
    Но это уже вопрос читабельности – вариант с записью в одну строку читать намного труднее. Я мог бы и промолчать про эту возможность для того, что бы вы так не делали, но это было бы не проффесионально. Так что знайте, но не используйте, пожалуйста =)
    3. Помни про регистр.
    “String” не равен “string”!

    4. Держи скрипт в чистоте и порядке.
    Это не обязательно и на работу скрипта не влияет, но очень даже желательно. Даже если никому не собираешься показывать код – тебе самому, возможно, придётся в нём ползать, искать ошибки и добавлять \ менять функции.
    Два скрипта ниже абсолютно одинаковые по функциям, но со вторым работать приятнее

    5. Не путай сравнение и равенство!
    Для логических операторов используется только “==”
    Для присваивания только “=”

    if x==y:
    	t=q

    Также не забываем про двоеточие в конце вопроса.

    6. Если код не работает – виноват сам код.
    Лично у меня за всё время ползанья по bge (а это чуть больше 2х лет) ни разу не случалось ошибок bge. Только мои собственные. Если и есть шанс бага блендера – он настолько мизерный, что его можно не брать в расчёт и в любом случае начинать с проверки кода.

    Глава 5.
    Процессируем в Text Editor на пальцах.

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

    Посмотреть полную версию скрипта можно в последнем обновлении.

    О процессе создания.

    Этап первый – подготовка.
    Первым делом было написано :

    import bge	\\ импортируем библиотеку BGE
    cont = bge.logic.getCurrentController()	 \\ сокращаем получение текущего контроллера
    own = cont.owner	\\ сокращаем доступ к объекту, на котором находится контроллер
    scene = bge.logic.getCurrentScene()	\\ сокращаем получение информации от текущей сцены

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

    Этап второй – планирование.
    Самое время задуматься о том, что требуется от скрипта.
    Из обязательного – включение\выключение ламп заднего хода и тормоза без использования анимации.
    Смотрим на наши возможности – открываем python reference и вводим в поиск “light”
    Она нам выдаёт внушительный список, но нас интересует только bge.

    В списке в первой позиции имеется bge.types.KX_Scene.lights – читаем и видим A list of lights in the scene, (read-only).
    Это нам не подходит т.к. функция позволяет лишь получить список ламп в сцене. Возвращаемся в поиск.

    Листаем ниже и находим bge.types.KX_LightObject. Под ним находим переменные этого LightObject – дистанция, энергия, цвет, тип источника света – то, что нужно. Значит, это функция отвечает непосредственно за источник освещения.

    Смотрим в пример:

    import bge
    co = bge.logic.getCurrentController()
    light = co.owner
    light.energy = 1.0
    light.color = [1.0, 0.0, 0.0]

    Из примера становится ясно, что управляется источник света через Объект.функция света = (значение)
    Потому как bge.logic.getCurrentController().owner равнозначно текущему объекту. Это хорошо потому, что вместо текщего объекта можно поставить любой другой. Значит, можно уместить код на одном объекте без сложностей указав лампы из кода и накинуть скрипт куда-нибудь на пустышку, объединяющую все лампы.

    Наличие переменной цвета нам очень даже пригодится – мы можем те же задние лампы использовать и в качестве ламп заднего хода, что хорошо – сэкономим на кол-ве источников света.

    Этап третий – пишем код.
    Если мы хотим расположить скрипт на одном объекте – нужно указать все лампы.

    База у нас уже была, а потому дописываем:

    lamp1 = scene.objects['StopL']
    lamp2 = scene.objects['StopR']

    Мы присвоили этим двум переменным значение объектов-ламп тормоза.
    Теперь можно задуматься о способе включения ламп.

    Из очевидного – включать лампы когда нажата клавиша S, но это не то т.к. лампы будут работать и при заднем ходе. Идём в объект-автомобиль и попутно открываем Powertrain. В планах переключать переменную только тогда, когда констреинт будет использовать торможение.
    Находим в Powertrain.py блок, отвечающий за торможение – def Brakes()
    В нём нас интересует только # brake и # no brakes потому, что # emergency это ручной тормоз, а # emergencyD – копипаста ручника при смерти, которая клинит колёса.

    До и После

    сам скрипт я немного модифицировал т.к. старый не работал. Он проверял разные состоряния нажатия клавиши тормоза (brake.positive == True) и клавиши занего хода (reverse.positive == False), хотя это была одна клавиша – ‘S’.
    Я добавил проверку скорости и состояния клавиши газа. Таким образом, тормоза срабатывали [при скорости выше 0 и при нажатом тормозе] или [при скорости ниже 0 и при нажатом газе ]

    Конструкция проверки уже имеется и нам остаётся только дописать под функциями присвоение нашей переменной.
    Состояние записывается в пееременную BrakeBool (True или False). Записана она в виде “own[‘BrakesBool’]” потому, что находится в N-панели редактора логики и, соответственно, сперва приходится указывать объект, на котором скрипт уже будет искать переменную.
    Нам осталось только получить состояние этой переменной в скрипте освещения.

    Всё, что было сделано в Powertrain.py – чисто для определения состояния тормоза. ну, за исключением правки скрипта. Таким образом на выходе мы имеем переменную, которая имеет значение <True или False в зависимости от состояния тормоза.

    Содаём объект-пустышку и родительской связью привязываем его к фонарям. У пустышки создаём через редактор логики сенсор Always (всегда), включаем обновление (кнопочка с тремя точками сверху) и соединяем с контроллером “python” с указанием нашего скрипта.

    Далее идём в скрипт и собираем всю необходимую информацию от объекта-автомобиля:

    car = scene.objects['Cube']	\\ сокращаем получение информации от объекта "Cube" (коллайдер автомобиля, на котором "держится" основная часть логики машины)
    brake = car['BrakeBool']  \\ присваиваем переменной brake состояние переменной BrakeBool от объекта-автомобиля
    rear = car.sensors['Reverse']	\\ присваиваем переменной rear состояние сенсора "Reverse"(по-сути просто нажатие клавиши S)
    speed = car['speed']	\\ присваиваем переменной speed переменную speed из объекта автомобиля.

    Далее просто собираем всю информацию в код.

    if brake == True:	\\ если тормоз включён
        stop1.energy = 8.0	\\ энергия первой лампы = 8
        stop2.energy = 8.0
        stop1.color = [1.0,0.0,0.0]	\\ цвет первой лампы красный (значения указываются по палитре RGB  [r,g,b])
        stop2.color = [1.0,0.0,0.0]
    elif rear.positive and speed < 0:	\\ иначе если нажата клавиша S и скорость меньше 0 (задний ход)
        stop1.energy = 1.0	\\ энергия первой лампы равна 1
        stop2.energy = 1.0
        stop1.color = [1.0,1.0,1.0]	\\ цвет первой лампы белый
        stop2.color = [1.0,1.0,1.0]
    else:	\\ иначе (если машина не тормозит и не включён задний ход)
        stop1.energy = 0.0	\\ энергия первой лампы = 0
        stop2.energy = 0.0

    По тормозам вроде всё. Для наполнения скрипта я ещё добавил фары и в кирпичики поставил переключение boolean переменной при нажатии клавиши H

    front1 = scene.objects['FrontL']		\\ присваиваем переменной front1 объект-лампу
    front2 = scene.objects['FrontR']
    FrontLight = own['FrontLight']		\\ присваиваем переменной FrontLight переменную с таким же названием, но созданную в редакторе логики (которая регулируется кирпичиками)
    
    if FrontLight == True:	\\ если переменная имеет значение True
        front1.energy = 2.0	\\ энергия фары1 = 2
        front2.energy = 2.0
    else:			\\ иначе (т.е. если переменная имеет значение False)
        front1.energy = 0.0	\\ энергия = 0
        front2.energy = 0.0

    Весь скрипт в основном состоит из той самой конструкции проверки:

    Если условие выполнено:
    выполняем действие

    в ответ на: О том, как я игрушку на BGE делал #13198
    Disaster
    Disaster
    Участник

    Rally Game Update 3.

    Лог:

    Звук:
    1. Добавлены звуки для ручника, заднего хода (тестовый), 4 звука удара, звук максимальных оборотов, звук запуска двигателя перед стартом.
    2. Все звуки конвертированы в mp3 и пожаты, у всех звуков отключен параметр “3D” для ускорения.

    Графика:
    1. Улучшена анимация повреждений крыши. Теперь она мнётся сильнее.
    2. Для некоторых текстур включён Normal Mapping.
    3. У деревьев улучшено качество среднего лода.
    4. Добавлены стоп-сигналы, фары и фонари заднего хода.
    5. Починил маяк! Теперь его основание снова отображается!
    6. Поправлен материал колёс и отражения кузова.

    Физика:
    1. Улучшена работа физики автомобиля. Теперь колёса значительно реже проваливается в карту, столкновения в большинстве случаев обрабатываются правильно.
    2. Изменены настройки физики для острова, деревьев, моста и колёс. Теперь они требуют меньше ресурсов и реже вызывают ошибки.

    Геймплей:
    1. Автомобиль теперь сложнее вывести из заноса.
    2. Отключил смерть при перевороте.

    Логика:
    1. Ещё больше “кирпичиков” переведено в скрипты, в большинстве объектов в редакторе логики наведён порядок.
    2. При движении назад камера разворачивается.
    3. Починил тормоза. Теперь машинка тормозит на клавишу S при движении вперёд и на клавишу W при движении назад.
    4. Изменён механизм коробки передач. Теперь обороты на высоких передачах набираются медленнее, коробка научилась сбрасывать передачи, от передачи и оборотов зависит мощность.
    5. Всё, что касается звука убрано в один скрипт “SoundScript”
    6. Всем освещением автомобиля управляет один скрипт – “Car_Light”

    Файл .blend:
    1. Удалены лишние текстуры, звуки, скрипты и материалы, что сократило вес файла в 2 раза
    2. Много ресурсов было переименовано для большей наглядности.

    Скриншоты обновления:

    Скачать через Яндекс.Диск (да-да. Без регистрации и смс :D)

    в ответ на: Курс по BGE от drdotmom #13170
    Disaster
    Disaster
    Участник

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

    Обсуждения между главами очень даже важны – если что-то не понятно, мало информации или любые другие вопросы, появившиеся в процессе чтения – лучше отписать. Я занесу эти изменения в документик с пометкой и при правке\копировании темы дополню недостающей информацией или в конце сложной главы добавлю “вопрос>ответ” в зависимости от вашего вопроса. До тех пор смогу ответить прямо в комментариях т.к. понимание моего текста – важная часть понимания всего курса в целом. Речь будет не только о программировании на bge python. Надеюсь, что в конце вы сможете не просто создать задуманное, но и чётко понимать смысл своих действий и процесса для других игр в любом жанре и практически на любом движке.

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

    Приятно видеть, что курс читается. Теперь хоть знаю, что мои труды нужны, а это очень важная часть мотивации =)

    Важно понимать, что вы не просто читаете курс, но и являетесь эдакими бета-тестерами. В мечтаниях этот курс должен охватить всё, что касается базы BGE на доступном языке и кидаться ссылкой как ответ =)

    в ответ на: Курс по BGE от drdotmom #13163
    Disaster
    Disaster
    Участник

    Глава 3.
    Физика в Rally Cross. Или “учимся читать” + продолжение к теме логики.

    Загнул я про построчное чтение физики машинки – не нужно это. Чуть позже поймёте почему.

    Физика Rally Cross базируется на небольшом примере.
    Собственно – к первичному варианту мало чего добавилось – лишь корректировки переменных да всякие мелочи вроде нормальной работы сцепления с дорогой, адекватной управляемости через лёгкий занос и более-менее приятной динамики ускорения (а с недавних пор ещё и зависимость мощности от “оборотов” (тык по RallyCross в этой главе – на ЯД исходник(ну, или тут)). Сразу скажу, что это только тестовая версия обновления и она не содержит трассы и интерфейса!
    Ну, не суть. Сейчас-то речь идёт о физике.
    Вам потребуется записать новое слово:
    Констреинт, Constraint. Это физическая связь объектов. Лучший пример такой связи – две сосиски в одной оболочке. Та сосиска, которая будет дочерней – вращается свободно, но только относительно “главной” сосиски. Констреинт же не только создаёт эту связь, но и ограничивает её. Констреинт автомобиля, о котором идёт речь ниже – значительно сложнее и включает в себя несколько связей + подвеску.

    Итак, вся логика машинки находится в трёх скриптах:
    1. CarSetup. Этот скрипт определяет положение колёс, их размеры, направение и т.д.
    2. Suspension. Этот скрипт, как понятно из названия – по подвеске. В нём находятся параметры, отвечающие за жёсткость подвески на сжатие, усилие отбоя и поперечную стабилизацию.
    3. Powertrain. Содержит в себе кучу регулировок – там и мощность двигателя, и сцепление колёс, и клавиши управления – всё-всё-всё, чего нет в двух прошлых скриптах.

    Все переменные упаковываются в аккуратные функции, превращаясь в аргументы для одной единственной функции – bge.constraints.getVehicleConstraint

    Да, вот так просто. Фактически эта функция – это здоровенная такая кнопка “сделать красиво”.
    Всё, что перечисленно в этих трёх скриптах – является упаковкой аргументов для красивого вида кода и удобного редактирования.
    Все “упаковки” можно определить по заголовку “def имя_функци()”

    На примере Tire_Objects():
    def Tire_Objects():  //создаём функцию
    	frontDriver    = "FLWheel" //Переднее левое колесо
    	frontPassenger = "FRWheel"//
    	rearDriver     = "RLWheel"//
    	rearPassenger  = "RRWheel"//
    	scene = bge.logic.getCurrentScene()// Сокращение функции "текущая сцена"
    	objList = scene.objects// Сокращение функции "получить объекты из текущей сцены
    	tire_0 = objList[frontDriver]//присвоение объекта-колеса из сцены переменной tire_0
    	tire_1 = objList[frontPassenger]//
    	tire_2 = objList[rearDriver]//
    	tire_3 = objList[rearPassenger]//
    	return (tire_0, tire_1, tire_2, tire_3)//Перечисление. Эти переменные (в полном виде типа bge.logic.getCurrentScene().objects['имя колеса1'] ) функция отправит тогда, когда её вызовут.

    На самом деле можно было бы и сократить до:

    def Tire_Objects(): Создаём функцию
    	scene = bge.logic.getCurrentScene() Текущая сцена
    	objList = scene.objects Объекты в текущей сцене
    	tire_0 = objList["FLWheel" ] Присвоить переменной tire_0 объект из текущей сцены с именем FLWheel
    	tire_1 = objList"FRWheel"]
    	tire_2 = objList"RLWheel"]
    	tire_3 = objList"RRWheel"]
    	return (tire_0, tire_1, tire_2, tire_3) Перечисляем то, что функция вернёт при вызове.

    Но, мысль кодера сложна и он почему-то решил, что будет круто создать 4 лишних переменных.
    Иначе говоря – мы можем получить все 4 колеса всего одной функцией – Tire_Objects()
    Например:

    objects=Tire_Objects()
    objects.localScale=[2,2,2]

    Таким образом одновременно увеличив размер всех колёс. (правда в самом скрипте это не работает ищ-ща определённых особенностей констреинта)

    Далее – что такое vehicle ID?
    vehicleID указывает на тип констреинта и объект, на который этот констреинт накладывается.
    Иначе говоря vehicleID это сокращение bge.constraints.getVehicleConstraint(bge.constraints.createConstraint(bge.logic.getCurrentController().owner.getPhysicsId(), 0, 11).getConstraintId())

    Что переводится как “Констреинт автомобиля (создать констреинт для(текущего контроллера).получив его физический идентификатор и применив аргументы 0 и 11, которые являются то ли типом констреинта, то ли ограничениями, то ли осями (фиг его разберёт короче. Я так и не смог найти на это ответа )”

    Фактически чувак просто взял и грамотно, чисто и красиво подготовил переменные для установки оных как аргументов к констреинту. Местами, правда, перестарался и получилась фигня, как с Tire_Objects(). Бонусом лишняя регулировка поворачивающих колёс в CarSetup, которая не работает.

    Почему во многих функциях присутствует точка? Что это и зачем?
    Я до знакомства с bge python пописывал на gml и общий принцип работы кода знал, но эти точки сожгли мой стул. Без хорошего примера тут определённо не обойтись:
    Мы, допустим, имеем большой дом. В доме есть коридор, который ведёт к разным дверям. Разные двери открывают разные комнаты, в каждой из которых свои элементы. Чайник, ванная, кровать, окно и т.д.
    Таким образом, что бы использовать определённый элемент нам нужно пройти к нему.
    коридор.комната.кухня.чайник
    Как-то так.

    Для того, что бы сослаться на определённый актуатор – нам нужно пройти довольно большой путь:

    bge.logic.getCurrentController().actuators ["Актуатор1"]
    bge.logic.getCurrentController().actuators ["Актуатор2"]

    Мы можем это дело исравить
    #1

    qwerty=bge.logic
    qwerty.getCurrentController().actuators ["Актуатор1"]
    qwerty.getCurrentController().actuators ["Актуатор2"]

    #2

    cont=bge.logic.getCurrentController()
    cont.actuators ["Актуатор1"]
    cont.actuators ["Актуатор2"]

    #3

    act = bge.logic.getCurrentController().actuators 
    act["Актуатор1"]
    act["Актуатор1"]

    #
    Все 3 варианта равнозначны. Другое дело – целесообразность и удобство использования\чтения.

    т.к. писать много мне лень, да и не получилось с физикой машинки ибо всё слишком просто – опишу как пользоваться API документацией.

    Использование документации.
    В Game Engine Modules вы найдёте все функции, работающие чисто с bge.

    Game Types (bge.types) – тут имеются все актуаторы, сенсоры и контроллеры. Чисто технически они сами по себе вам не нужны, однако в них можно найти функции актуаторов, что уже значительно полезнее.
    Так, например, для актуатора Action (BL_ActionActuator(SCA_IActuator)) вы можете увидеть список всех регулировок вроде начального кадра, конечного, текущего и т.д.
    Для актуатора Sound( KX_SoundActuator(SCA_IActuator)) – pitch, громкость, пауза и т.д.
    Использовать эти функции просто:

    envSound = cont.actuators ["Sound_wind"]
    envSpeed = (speed*0.02)+.3
    envSound.pitch = abs(envSpeed)
    if impulse.positive:
        cont.activate(envSound)

    Эта функция активирует актуатор Sound с именем ‘Sound_Wind’, присваивая в процессе значение pitch, в зависимости от скорости автомобиля (abs превращает любое значение скорости в положительное)

    Аналогично можно и с любым другим актуатором:

    action = bge.logic.getCurrentController().actuators ["FGHY"]
    action.frame=35
    action.activate

    Установит Action актуатору с именем FGHY 35 кадр.
    Иначе говоря – если вы видете регулироку у актуатора и хотите её поменять кодом или вовсе поставить зависимость и менять в процессе игры – вы можете найти её в интересующем вас Актуаторе в разделе Game Types.Более того – там можно найти даже то, чего нет в настройках кирпичиков.

    Game Logic (bge.logic)
    В первую очередь в логике нас интересуют:

    bge.logic.getCurrentController()
    bge.logic.getCurrentScene()

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

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

    Rasterizer (bge.render). Как понятно (или не очень) из названия – содержит в себе все функции, касающиеся растеризации (см Часть1). Это и тип рендера (GLSL или Multitexture), и разрешения\V-Sunc\AA\mipmapping – вся вот эта вот лабуда. Может также создавать скриншоты в файл, показывать фпс и дэбаг переменных\физики, что просто незаменимая вещь, если вы хотите сделать менюшку с настройками перед игрой.

    Video Texture (bge.texture) содержит в себе функции, касающиеся чисто анимированных текстур. Если вам хочется добавить в игру видеоролик, написать свой шейдер, использующий текстуру или изменить текстуру объекта в процессе игры – вам сюда.

    Game Keys (bge.events) отвечает за обработку событий клавамыши.
    Пример:

    Wkey=bge.events.WKEY
    if Wkey.positive:
    	действие

    Действие произойдёт по нажатию на клавишу. вроде всё просто)

    Physics Constraints (bge.constraints) – это констреинты. Функции, содержащиеся в этом разделе помогут вам правильно настроить физические связи между объектами (например открывающиеся двери авто после аварии или дверь, которая будет открываться брошеным в неё камнем)

    Application Data (bge.app) поможет вам, если вы хотите проверить версию блендера соседа, открывшего вашу игрушку(если я правильно понял), определить, подключен ли джойстик.

    Ну, на этом пока всё. Меня пугает эта тишина. Вы хоть отпишите, что эту фигню хоть кто-то читает) А то вдруг я пишу просто так) Да и интересно – может есть какие пожелания к следующим главам, способе подачи или ещё чего.

    в ответ на: Курс по BGE от drdotmom #13099
    Disaster
    Disaster
    Участник

    Глава 2. Логика.

    Очень много букв!

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

    Как обьяснить компьютеру, чего ты от него хочешь или “вход, обработка, выход”.

    Плиточки Blender Game Engine (они же ноды).
    По-умалчанию блендер делит эти ноды на сенсоры, контроллеры и актуаторы.

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

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

    Актуаторы – определяют действие, которое случится после того, как контроллер обработает сенсор и даст “добро” на выполнение при соблюдении условий.

    Эти базовые ячейки заменяют стандартную конструкцию проверки:
    “Если условие выполнено, то происходит действие”

    Их минусом явлеятся узкий функционал как в количестве актуаторов, так и в их качестве.
    Так, например, имея актуатор “Sound” – мы можем настроить для звука параметр “pitch” и “volume” перед запуском игры. Но как быть, если эти параметры нам нужно будет менять в процессе игры для, например, звука двигателя?
    Тут уже необходимо использовать скрипт на bge phyton или, по-разговорному – код.

    Весь код упирается в написание инструкции из предоставленных движком функций.

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

    Первая мысль, которая проскакивает в голове человека, решившего написать свой первый код – “как мне написать то, что мне нужно на выбранном мной языке?”

    Синтаксис.
    Что такое синтаксис?
    Синтаксис – это правила, которые регулируют написание кода. Как мы руководствуемся правилами при написании писем в реальном мире – так и в компьютерном должны следовать правилам. Причём если человек поймёт “превед медвед” – компьютер решит, что вы больны.

    Операции.
    Операции это действия, которые мы можем выполнить над функциями и переменными.
    Так, например, складывая скорость с положением в пространстве – мы получим в лобешник за эту дичь воспользуемся арифметическим оператором “+”

    Арифметические операторы:
    1. “+” – сложение
    2. “-” – вычитание
    3. “*” – умножение
    4. “/” – деление
    5. “%” – возвращает только остаток от деления (например при делении 11 на 4 – вернёт остаток – 3)
    6. “//” – цельночисленное деление(например при делении 11 на 4 – вернёт 2)
    7. “**” – возведение в степень.

    Операторы сравнения:
    1. “==” – сравнение. Выражение 5==5 вернёт “true”.
    2. “!=” – не равно. Выражение 5!=5 вернёт “false”.
    3. “<” и “>” – меньше или равно \ больше или равно.
    4. “<=” и “>=” – меньше или равно \ больше или равно.
    Операторы присваивания:
    1. “=” – присваивает значение правого операнда левому. (например x=5)
    2. “+=” / “-=” / “*=” и т.д. – присваивание с арифметической операцией. Так, например, выражение x+=y вернёт резултат сложения и присвоит его переменной “x”

    Логические операторы:
    1. “if” – “если”. (если x=y – выполняется действие)
    2. “else” / “or” – “Иначе” / “или” (Если x = y – выполняется действие 1, иначе – действие 2)

    Разберём небольшой кусочек кода bge:

    import bge
    player = bge.logic.getCurrentController()
    step = player.sensors ["KeyboardW"]
    sound = player.actuators ["Step_Sound"]
    
    if step.positive:
        player.activate(sound)
    else:
        player.deactivate(sound)

    Указываем player как локальное имя(т.е. только для этого скрипта)для текущего контроллера (объекта, на котором запускается скрипт)
    Указываем step как локальное имя для сенсора с именем “KeyboardW”
    Указываем sound как локальное имя актуатора “Step_Sound”
    Если сенсор был активирован:
    то запускается актуатор “Step_Sound”
    Иначе:
    отключается актуатор “Step_Sound”

    Таким образом в игре мы будем включать звук только когда персонаж двигается.

    Что касается логического оператора.
    Если вы задаёте вопрос – должен быть ответ. Ответов может быть несколько и все они должны содержаться строчкой ниже и с отступом в одну табуляцию относитьно логического оператора.
    #

    if x=y:
    	функция;
    if t!=s:
    	функция;
    	функция;
    	функция;

    #

    if g<=4:
    	высунуть язык;
    	if g<0:
    		присесть;
    		моргнуть;
    	else:
    		съесть бревно;
    else:
    	пролить чай;
    #

    Если g меньше 4х, то персонаж высовывает язык. Если при этом g<0 – то персонаж высунув язык приседает и моргает. Если g меньше 4, но больше 0 – персоаж высунув язык съедает бревно. Если g больше 4х – персонаж проливает чай.

    Теперь о самом важном – о применении.

    import bge // Открывает библиотеку функций игрового движка
    cont = bge.logic.getCurrentController //текущий контроллер
    own = cont.owner //переменные текущего контроллера
    
    sound = cont.actuators ["Sound_onlow"] //актуатор текущего контроллера с именем "Sound_onlow"
    gear = own['gear'] //переменная текущего контроллера с именем "gear"
    
    sound.pitch = (own["rpm"]*0.01)+ (gear / 50) // для актуатора "Sound_onlow" параметр pitch будет равен переменной "rpm" умноженной на 0.01  плюс результат деления переменной gear на 50.
    cont.activate(sound) // для текущего контроллера выполняется актуатор  ["Sound_onlow"] cо значением pitch, зависящим от оборотов и передачи.

    Переменная оборотов и переменная текущей передачи регулирует уровень pitch для звука двигателя по формуле (rpm*0.01)+(gear/50). Формула для правильного звучания двигателя определялась опытным путём.

    При присвоении вы можете использовать любые имена для читабельности кода. Так, например, вы можете bge.logic.getExitKey()(узнать клавишу выхода) присвоить переменной с именем edgjluvbhe, но зачем?

    Ссылка на Blender Phyton References, в котором вы найдёте все функции bge phyton с описанием, дополнительной информацией и примерами.

    В целом синтаксис приходит с опытом и потому нужно активнее читать скрипты на bge phyton и других яп. Искать общую логику, характерные особенности. То, что я вам сейчас описал – не позволит вам прямо сейчас начать писать GTA6, но поможет изучить bge phyton или, как минимум – начать его читать.

    Надеюсь, был полезен.
    В следующей главе планирую разобрать физику машинки из Rally Cross по строчкам.

    в ответ на: О том, как я игрушку на BGE делал #13023
    Disaster
    Disaster
    Участник
    в ответ на: О том, как я игрушку на BGE делал #9827
    Disaster
    Disaster
    Участник

    Давно пора было… [Типа красивый заголовок]

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

    После публикации поста как – то захотелось его подготовить ” в последний путь”. Немного навести красоты перед уходом. Как генеральная уборка перед выездом на дачу на летние каникулы. Но разбираясь в старом хламе я неосознанно заметил за собой, что кроме наведения чистоты, удаления лишних объектов и максимального поворота “лицом” к следующим пользователям я начал улучшать проект.
    Ну а почему бы и нет? Вот так и случилось достаточно масштабная (по меркам этого маленького проекта) обновление. Размеры изменений я могу сравнить, пожалуй, с вводом системы повреждений.

    Первым делом после осознания того, что наведённый порядок уже является неким обновлением я захотел улучшить графику. Прошлая версия была достаточно жёсткой и беспощадной к ресурсам, но после улучшения чистоты картинки настройкой шейдеров я понял, что освободил ресурсов. Начал так начал!
    Первыми под косу оптимизации пошли текстуры, которые были кривых разрешений и, местами, через мерно качественными. Ещё читая справку к дополнению Ultimate 3D для Game maker я узнал, что разрешение текстур должно быть кратно двум. В противном случае они пожимаются до меньшего разрешения. Тоесть все мои текстурки разрешением 800х800 жрали как 800х800, а выглядели как 512 х 512. Я не мог допустить такого транжирства и порезал их.
    Шейдеры. DoF был абсолютно бесполезен. Он хорошо смотрится в стрелялке или красивой гонке, но когда речь идёт о ралли с частыми поворотами, не дающими посмотреть вдаль – он лишний. *Удалено*
    Bloom и SSAO раздваивали объекты, создавая вокруг них полупрозрачные копии. Это очень сильно загрязняло картинку и я решил перенастроить это дело. Получилось даже быстрее.

    Оптимизация прошла с небольшим улучшением графона. Зачем жить без графона?
    Разумеется, графон тоже относительный и Dirt 3 у меня не получится, но, в целом, немного подправить можно.
    С этой мыслёй я закатал рукова и начал адаптировать модельку Lancer 10 к игровому миру. Адаптация прошла успешно. Модель вписывается в графон и имеет тот же функционал, что и прошлая. Поправляя физику случайно улучшил управляемость и реакцию на неровности ландшавта. Правда местами ландшафт был совсем кривой и я его выравнил. Заодно сменил направление. В другую сторону ехать как – то проще и пейзажи краше =)

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

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

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

    начал я с самого начала – добавление такой штуки как rpm.
    При нажатии на клавишу газа значение переменной возрастало, а при отпускании падало. Это всё очень хорошо, но абсолютно ничего общего со скоростью не имеет, да ещё и одна единственная передача. Пришлось вводить симулятор коробки, который на определённой скорости при определённых оборотах сбрасывал обороты и переключался на следующую “передачу” уже с другими условиями для переключения.
    Всё по – взрослому =)

    На самом деле выглядит это очень просто. Объяснить работу – сложнее, а придумать это – вообще вынос мозга. Сложнее чем придумать, пожалуй, только настроить для качественной работы.
    В целом же получилось удачно, но ещё предстоит допилка.

    Пожалуй, вот так и было создано обновление.

    Геймплей в новой версии

    Ссылка на пост с последним исходником

    Спасибо за внимание, с вами был drdotmom!

    в ответ на: Машинка из головы #7474
    Disaster
    Disaster
    Участник

    На самом деле делать что – то существующее – в разы труднее же. Есть с чем сравнивать, есть определённые пропорции и формы, которые приходится делать не так, как проще, а так как выглядит. В конце – концов сеточку продумывать надо :с

    Спасибо, буду продолжать вип до тех пор, пока самому не надоест или не будет чего – то более – менее внятного =)

    в ответ на: Машинка из головы #7473
    Disaster
    Disaster
    Участник

    Да, именно так и было =\
    Думаю сделать прикидку, а потом в порядке создания допиливать детализацию.

Просмотр 14 сообщений - с 1 по 14 (из 14 всего)

О сайте

На данном сайте Вы сможете найти множество уроков и материалов по графическому
редактору Blender.

Контакты

Для связи с администрацией сайта Вы можете воспользоваться следующими контактами:

Email:
info@blender3d.com.ua

Следите за нами

Подписывайтесь на наши страницы в социальных сетях.

На сайте Blender3D собрано огромное количество уроков по программе трехмерного моделирования Blender. Обучающие материалы представлены как в формате видеоуроков, так и в текстовом виде. Здесь затронуты все аспекты, связанные с Blender, начиная от моделирования и заканчивая созданием игр с применением языка программирования Python.

Помимо уроков по Blender, Вы сможете найти готовые 3D-модели, материалы и архивы высококачественных текстур. Сайт регулярно пополняется новым контентом и следит за развитием Blender.