
В прошлой главе мы подключили System.Reactive к Godot и, претерпев соответствующие муки, почти добрались до изобретения реактивных свойств. Сегодня мы их наконец-то изобретём и за несколько шагов доведём до ума.
Я говорил об этом в прошлом заключении и повторю сейчас: всё, что я предлагаю, не является единственно верным решением. Возможны альтернативы, которые я здесь не затрагиваю. В первой главе их можно было спокойно игнорировать, потому что их объём совпадал со свободным пространством в надетом сапоге. Но к концу этой главы мы будем держать в руках ложку, которой надо выскоблить самые ценные куски из бабушкиного зур бэлиша. В такой ситуации стоит хорошо понимать, чего именно мы хотим. Ну или хотя бы чего хочу я.
Когда-то я начинал экспериментировать с DSL лишь потому, что мне нравился сам процесс построения нового языка. Однако со временем обнаружилось, что DSL — это отличный способ снять часть груза ответственности с пользователей и возложить его на плечи автора DSL, то есть меня. За это мне неоднократно припоминали бас-фактор. Но так получилось, что большую часть времени мне надо было работать ещё и с людьми, чьи возможности были значительно ниже моих. Они не были тупыми (иначе бы я их не привлекал), но они чисто исторически не могли быть подготовлены на моём уровне. Обилие DSL в таком сценарии позволяло успешно для обеих сторон грузить отважных дилетантов задачами, которыми, по формальным признакам, их грузить было нельзя.
Сейчас развитие технологий и общая экономическая ситуация в сочетании с моей любовью к DSL внезапно вылились в забавный выверт. До подведения его итогов мне ещё далеко, поэтому я оставлю этот «анонс» в скомканном виде в расчёте на то, что он зацепит лишь человека со сходным предчувствием. Если же описать мои хотелки без этого крайне мутного «выверта», то они заключаются в стремлении избавить рядового пользователя от рисков и беспокойства сделать что-либо не так.
Устройство проекта
Здесь всё устроено по той же схеме, что и в прошлый раз.
Почти все примеры можно найти в этом проекте, собранный из него .exe лежит в архиве здесь. Это проект из прошлой главы, который был скопирован, переименован, сохранён отдельно и дополнен свежими примерами. Их снова 9 штук (включая неправильные), и они расположены в хронологическом порядке. Нумерация в статье и в проекте совпадает.
Всего одна.tscn-сцена (не считая EntryPoint.tscn), которая конфигурируется через аргументы при запуске. Новый профиль Sample 2-All загрузит в неё Chapter2/AllSamples.fs. Этот же профиль настроен для запуска из редактора или .exe.
Общий профиль для всех примеров из обеих глав я не заводил. Можете собрать его самостоятельно по образу и подобию.
Тонна типов и их расширений из первой главы была оставлена в местах своего определения. То, что было признано полезным, было продублировано в Chapter2/Utils.fs и улучшено без упоминания в тексте.
За 9 шагов мы создадим 5 версий реактивных свойств. Они неустранимо конфликтуют между собой, поэтому в этот раз переносить их из примера в пример придётся руками.
There is only Var
1. Var
Мы закончили на том, что 'a Observable.CachePrevious очень сильно похож на «реактивное свойство». Здесь я кавычу этот термин, потому что не смог убедить себя в том, что он действительно существует. Однако все мои предыдущие собеседники хорошо понимали, что это некая ячейка данных, которая умеет сообщать о своих изменениях вовне.
Правда, есть серьёзные расхождения по поводу того, кто именно должен сообщать об изменениях. Владелец свойства или оно само? В MVVM-фреймворках это почти всегда владелец, то есть ViewModel (INotifyPropertyChanged) или DependencyObject.
Однако в экосистеме F# всё существует и ощущается несколько иначе, поэтому под реактивным свойством я буду подразумевать самостоятельный автономный объект, которым можно кидаться отдельно от его владельца. Людям из геймдева такая абстракция может напоминать Component из ECS. Hopac-оводы знакомы с аналогами этой штуки под именами 'a Stream.Var или 'a Stream.Property, и именно эти типы можно считать прообразом того, что обсуждается в этой главе. Пользователи System.Reactive первое время могут ассоциировать эту штуку с 'a SubjectBehavior, которым мы воспользуемся в первой версии, но очень быстро вынуждены будем отказаться от неё в пользу кастомной структуры.
Первая попытка начинается так:
module Observable = type 'a Var = inherit System.IObservable<'a> abstract Value : 'a type 'a MVar = inherit Var<'a> abstract Value : 'a with set module Var = let paranoid (var : _ Var) = { new Var<'a> with member _.Value = var.Value interface System.IObservable<'a> with override _.Subscribe observer = var.Subscribe observer }
'a Observable.Var — это реактивное свойство, которое доступно только для чтения. Оно наблюдаемо и его содержимое доступно для извлечения в любой момент. По факту сейчас эта штука идентична несуществующему 'a ReadonlySubjectBehavior.
'a Observable.MVar — это реактивное свойство, которое доступно как для чтения, так и для записи. Сейчас оно выступает лишь фасадом над 'a SubjectBehavior. Но в отличие от него MVar не поддерживает 'a System.IObserver, так что держатель экземпляра может только кидаться в него новыми значениями (OnNext). Опции OnCompleted и OnError недоступны.
Var — это очень тонкий и безобидный клиент, поэтому Observable.Var.paranoid «сепарировался» в модуле. А вот MVar всё-таки надо уметь останавливать, что статистически проще всего делать сразу из родительского CompositeDisposable (или аналога):
type CompositeDisposable with member this.MVar value = let output = this.Behavior value { new Observable.MVar<'a> with override _.Value with get () = output.Value and set value = output.OnNext value override _.Subscribe observer = output.Subscribe observer }
Там же размещаем маппинги и прочие хелперы:
type CompositeDisposable with member this.ToVar value observable = let mvar = this.MVar value observable |> this.Subscribe ^ fun p -> mvar.Value <- p Observable.Var.paranoid mvar member this.MapVar mapping var = var |> Observable.tail |> Observable.map mapping |> this.ToVar ^ mapping (var : _ Observable.Var).Value
Модель на таких примитивах может определяться так:
let deltaSource = Event<_>() let model = let progress = disposables.MVar initialProgress deltaSource.Publish |> disposables.Subscribe ^ fun p -> progress.Value <- progress.Value + p let distanceToB = progress |> disposables.MapVar patrolTrack.DistanceToB {| Progress = progress DistanceToB = distanceToB Direction = distanceToB |> Observable.map ^ fun distance -> if distance > 0f then A2B else B2A |> Observable.distinctUntilChanged |> disposables.ToVar A2B Frame = progress |> Observable.map ^ fun p -> props.Lines.Walk.Circledf (10f * p) |> Observable.distinctUntilChanged |> disposables.ToVar ^ props.Lines.Walk.Circledf 0f Position = distanceToB |> disposables.MapVar patrolTrack.PositionOf |}
Она мало чем отличается от версии из конца предыдущей главы, но теперь мы имеем доступ к сеттеру Model.Progress.Value. При желании его можно запараноить, но, пока он открыт, мы можем легко сбросить модель в стартовое (или любое другое) состояние:
for unit in [mason;goodspeed] do asNode ^ FG.Button( Text = sprintf "Перезапустить %sа" unit.Props.Name , SizeFlagsHorizontal = Control.SizeFlags.ShrinkCenter , FocusMode = Control.FocusModeEnum.None , Pressed'Handler = disposables.HandleSignal ^ fun _ () -> unit.Model.Progress.Value <- 0f , Icon = unit.Props.Icon )

Реактивные свойства как самостоятельные объекты — вещь не новая. Однако подавляющее большинство гайдов по RX предлагает скрывать их присутствие от стороннего наблюдателя. Дескать, мы не должны травмировать неподготовленного пользователя и так далее. Довод сам по себе слабый, а в случае инди-геймдева вообще абсурдный.

Ещё один аргумент в пользу сокрытия — возможность несанкционированно вызывать что-то ещё, кроме SetValue за пределами владельца. Торчащий наружу SubjectBehavior можно освободить или завершить, что вряд ли хорошо скажется на здоровье модели. Поэтому мы скрыли MVar.Dispose в недрах фабрики, причём сделали это радикально, хоть и не очень экономично (CompositeDisposable — временами оверкилл). Но кому действительно будет жать перфоманс, перепишет самостоятельно, как посчитает нужным.
В общем, мы не будем скрывать эти объекты, потому что Var / MVar — это автономная самодостаточная штука, которую можно использовать и таскать отдельно от владельца, шарить между несколькими владельцами или создавать в произвольной части кода, где никаких владельцев нет. Это очень серьёзное преимущество, которое хорошо откликается на склонность F# и Godot к композиции.
2. ToVarUnsafe
Метод disposables.ToVar требует от нас передачи инициирующего состояния. В случае Frame и Direction я загрузил значение от балды, потому что знал, что самый первый IObservable в пайпе — это Var (или SubjectBehavior), и он всё равно инициирует отправку в момент подписки, так что левое значение будет моментально перебито правильным. В общем случае мы могли бы воспользоваться Unchecked.defaultof, но Var в процессе эволюции кода может быть незаметно подменён обычным IObservable, и тогда наш null таки пролезет в незащищённый домен. Каким геморроем это может обернуться, я уже рассказывал.
В идеале, нам надо поймать первое сообщение, которое приходит в момент знакомства, создать из него MVar, после чего абсорбировать этим MVar весь последующий поток сообщений. При этом мы обязаны упасть, если приветственное сообщение не пришло:
type CompositeDisposable with member this.ToVarUnsafe observable = let mutable state = None let get () = state |> Option.defaultWith ^ fun () -> invalidOp "IObservable was empty!" observable |> Observable.subscribeObserver { new System.IObserver<'a> with override _.OnNext value = match state with | None -> let local = this.CreateChild() state <- Some {| MVar = local.MVar value Dispose = local.Dispose |} | Some state -> state.MVar.Value <- value override _.OnCompleted () = get().Dispose() override _.OnError exn = get().Dispose() } |> this.Add get().MVar |> Observable.Var.paranoid
Код сложнее, чем мог бы быть при написании { new Observable.MVar<'a> ... } с нуля, но нам надо пройти через CompositeDisposable.MVar, чтобы потом не дублировать изменения в «конструкторе» по всем хелперам. С этим методом модель можно будет описать так:
let model = let progress = disposables.MVar initialProgress deltaSource.Publish |> disposables.Subscribe ^ fun p -> progress.Value <- progress.Value + p let distanceToB = progress |> disposables.MapVar patrolTrack.DistanceToB {| Progress = progress DistanceToB = distanceToB Direction = distanceToB |> Observable.map ^ fun distance -> if distance > 0f then A2B else B2A |> Observable.distinctUntilChanged |> disposables.ToVarUnsafe Frame = progress |> Observable.map ^ fun p -> props.Lines.Walk.Circledf (10f * p) |> Observable.distinctUntilChanged |> disposables.ToVarUnsafe Position = distanceToB |> disposables.MapVar patrolTrack.PositionOf |}
Визуальных изменений этот код не даёт, однако на большом проекте ToVarUnsafe создает до половины всех Var.
Судьба Value
3. Value после смерти
Разобравшись с «началом» Var, впору подумать о его «конце». Например, что происходит с Value после условного MVar.Dispose? Можем ли мы подглядеть финальные значения модели после смерти юнита, чтобы заспавнить на его месте копию-духа?
let killUnit (unit : Unit) = let unit = unit.Core unit.Disposables.Dispose() try unit.Model.Direction.Value.Destination |> sprintf "%s убит в %0.3f, когда шёл в точку %s." unit.Props.Name unit.Model.Progress.Value |> messages.Add Colors.Green FG.Node2D( Disposables = disposables , Parent = center , Position = unit.Model.Position.Value , Modulate = Colors.Blue.With(A = 0.6f) + Colors.White * 0.2f ).Add'Children [ UnitLabel.text unit.Props.LastWords FG.Sprite2D( Spritesheet = unit.Props.Styles.Outlined , TextureFilter = CanvasItem.TextureFilterEnum.Nearest , Scale = Vector2.One * scale , Frame = unit.Model.Frame.Value , FlipH = unit.Model.Direction.Value.IsB2A ) ] |> center.AddChild with | ex -> sprintf "Ошибка при чтении из %sа:\n%s" unit.Props.Name ex.Message |> messages.Add Colors.Red
Я считаю, что можем, но конструкция try ... with намекает, что нет. Мёртвый SubjectBehavior при обращении к Value бросает исключение.

Я догадываюсь, что такое поведение связано с необходимостью вовремя отпустить объект в Value. Но если мне понадобится от него гарантированно избавиться, я подберу другой инструмент. А для стандартного сценария ожидаю, что Value у меня никто не отберёт.
4. Возвращаем Value
Subject.behavior меняем на Subject.broadcast. Value сохраняем сами и потом грузим его в каждого нового подписчика:
type CompositeDisposable with member this.MVar value = let mutable value = value let output = this.Broadcast() { new Observable.MVar<'a> with override _.Value with get () = value and set newValue = if not output.IsDisposed then value <- newValue output.Trigger newValue override _.Subscribe observer = observer.Trigger value output.Subscribe observer }

Всё работает, юниты умирают, духи жалуются.
Тут можно придраться к тому, что мы просто игнорируем попытки установить новое значение в Value, а могли бы бросаться исключениями. Но по моим наблюдениям, в играх этого лучше избегать. Количество перекрёстных связей огромно, и, в силу устройства движка, не всякое сообщение о смерти моментально доходит до адресата. Чаще всего загибающиеся акторы успеют один раз пнуть мёртвые Value перед тем, как сами уйдут на покой. Беспокоить нас и уж тем более игрока по такому пустяку нерационально.
Это также справедливо для падающих Dispose. Если я что-то высвободил, оно должно исчезнуть молча, однако даже в этом проекте нашлась пара мест, где мёртвые решили постучаться обратно. Я вынужденно воспользовался DisposeSafe и подозреваю, что это будет причиной, по которой я таки заменю CompositeDisposable в будущих статьях на Хабре.
Для тех редких случаев, где нам действительно необходимо падение, можно бахнуть ещё один хелпер вида:
type CompositeDisposable with member this.MVarBiddy value = let mutable value = value let output = this.Broadcast() { new Observable.MVar<'a> with override _.Value with get () = value and set newValue = if not output.IsDisposed then value <- newValue output.Trigger newValue else invalidOp "MVar was disposed." override _.Subscribe observer = observer.Trigger value output.Subscribe observer }
Хотя с учётом столь склочного поведения, быть может, будет лучше создать отдельный тип, чтобы его можно было идентифицировать на расстоянии.
Freezable
5. Подписка после смерти
Предположим, что визуализация нашего юнита лежит в отдельной функции:
and makeView disposables props model = FG.Node2D( Disposables = disposables , Parent = center , Position'Bind = disposables.Bind model.Position ).Add'Children [ FG.Sprite2D( Name = "Sprite" , Spritesheet = props.Styles.Outlined , TextureFilter = CanvasItem.TextureFilterEnum.Nearest , Scale = Vector2.One * scale , Frame'Bind = disposables.Bind model.Frame , FlipH'Bind = disposables.BindMap model.Direction ^ fun p -> p.IsB2A ) ]
Мы дёргаем её при создании юнита:
let view : Node2D = makeView disposables props model GD.Implements._process(fun _ delta -> deltaSource.Trigger ^ float32 delta).Parent <- view Unit {| Disposables = disposables Props = props Model = model View = view |}
И хотим дёрнуть второй раз при создании призрака:
let view = makeView disposables unit.Props unit.Model view.Modulate <- Colors.Blue.With(A = 0.6f) + Colors.White * 0.2f view.AddChild ^ UnitLabel.text unit.Props.LastWords
При спавне призрака unit.Disposables уже мёртв. Соответственно мертвы и все Var в модели. Но это не должно помешать нам создать ещё одну вьюху, на базе свежего CompositeDisposable, ведь информация с последними значениями всё ещё в модели. Так звучит в теории, однако на практике System.Reactive опять стреляет нам в ногу.
Попытка подписаться на мёртвый Subject тоже вызывает исключение:
try let view = makeView disposables unit.Props unit.Model view.Modulate <- Colors.Blue.With(A = 0.6f) + Colors.White * 0.2f view.AddChild ^ UnitLabel.text unit.Props.LastWords with ex -> messages.Add Colors.Red ^ sprintf "Ошибка при спавне призрака %s:\n%s" unit.Props.Name ex.Message

6. Заморозка
Соответственно, нам надо проверять состояние output до подписки и при его смерти никого не подписывать, а сообщать observer-у о том, что с изменениями покончено:
type CompositeDisposable with member this.MVar value = let mutable value = value let output = this.Broadcast() { new Observable.MVar<'a> with override _.Value with get () = value and set newValue = if not output.IsDisposed then value <- newValue output.Trigger newValue override this.Subscribe observer = observer.Trigger value if output.IsDisposed then observer.OnCompleted () IDisposable.empty else output.Subscribe observer }

Н-ное число статей назад мы обсуждали тип Freezable из мира XAML-фреймворков. Этот тип создан для объектов, которые изначально могут наблюдаемо изменяться, но после команды Freeze становятся фиксированным слепком данных. В лице MVar мы получили нечто близкое и поэтому столкнёмся со свойственной Freezable проблемой — зафриженный MVar может попасть в контекст, который захочет его поменять. Гарантированно избежать этого не получится, но риск здорово минимизируется профилактическими средствами.
От точечной паранойи:
let view : Node2D = {| model with Progress = Observable.Var.paranoid model.Progress |} |> makeView disposables props
До изоляции в духе CQRS:
let model, commands = let progress = disposables.MVar initialProgress deltaSource.Publish |> disposables.Subscribe ^ fun p -> progress.Value <- progress.Value + p let distanceToB = progress |> disposables.MapVar patrolTrack.DistanceToB {| Progress = // Запараноили. Observable.Var.paranoid progress DistanceToB = distanceToB Direction = distanceToB |> Observable.map ^ fun distance -> if distance > 0f then A2B else B2A |> Observable.distinctUntilChanged |> disposables.ToVarUnsafe Frame = progress |> Observable.map ^ fun p -> props.Lines.Walk.Circledf (10f * p) |> Observable.distinctUntilChanged |> disposables.ToVarUnsafe Position = distanceToB |> disposables.MapVar patrolTrack.PositionOf |} , {| // Вынесли команды в отдельный узел. ResetProgress = fun () -> progress.Value <- 0f |}
OnFrozen
7. Ждём смерти
Когда у нас есть доступ к полю Disposables, мы можем докинуть в него экземпляр IDisposable, который известит нас о смерти юнита. Однако F# свойственна атомизация скоупов. Вполне возможно, что нам придётся реагировать на остановку юнита, когда у нас на руках только лишь несколько Var-ов. По идее мы можем получить его окольным путём через подписку на IObservable:
for unit in [mason;goodspeed] do let core = unit.Core // ... let completed () = messages.Add Colors.Gray ^ sprintf "%s прекратил движение." core.Props.Name core.Model.Position |> Observable.subscribeObserver { new System.IObserver<_> with override this.OnNext _ = () override this.OnError _ = completed () override this.OnCompleted () = completed () } |> disposables.Add

Но проверка показывает, что смерть disposables не триггерит IObserver. При детальном изучении обнаружится, что output.Dispose (из недр MVar) всего лишь молча убивает Subject. Я привык мыслить категориями Hopac, и на мой взгляд, output.Dispose перед освобождением вызывать OnCompleted.
Это поведение раздражает меня в System.Reactive больше всего, потому что оно для меня абсолютно контринтуитивно и, несмотря на это, чрезвычайно распространено по всей библиотеке. Весь модуль Observable заполнен функциями, которые могут остановить обработку и ничего никому об этом не сказать. Это местный канон, и у него даже есть кое-какое объяснение, которое я проигнорирую, потому что наличие оправдания не заставит меня сменить свой канон.
8. Сообщаем о смерти
В Hopac молчаливое прерывание Hopac.Stream технически тоже возможно, но встречается очень редко, и, как правило, я к этому заранее готов. От Var-ов я хочу того же. Если Var умер, то он должен известить об этом своих подписчиков, а не просто забыть о них.
В коде это достигается через прокси между broadcast-ом и CompositeDisposable:
type CompositeDisposable with member this.MVar value = let mutable value = value let output = Subject.broadcast this.Add ^ IDisposable.create ^ fun () -> output.OnCompleted() output.Dispose() { new Observable.MVar<'a> with member _.Value with get () = value and set newValue = if not output.IsDisposed then value <- newValue output.Trigger newValue override _.Subscribe observer = observer.Trigger value if output.IsDisposed then observer.OnCompleted () IDisposable.empty else output.Subscribe observer }

Решение работает, но оно локально. Его хочется как-то распространить на весь проект:
type CompositeDisposable with member this.Broadcast () = let broadcast = Subject.broadcast this.Add ^ Disposable.create ^ fun () -> broadcast.OnCompleted() broadcast.Dispose() broadcast
Однако и в таком виде у нас сохраняется риск, что кто-то или что-то зевнёт и создаст экземпляр в обход хелпера. Поэтому в идеальном случае нам стоит вовсе отказаться от Subject.broadcast в основном теле проекта и создать вместо него ещё один примитив:
type CompositeDisposable with member this.Subject () = let inner = Subject.broadcast this.Add ^ Disposable.create ^ fun () -> if not inner.IsDisposed then inner.OnCompleted() inner.Dispose() { new Subjects.ISubject<'a> with override _.OnCompleted () = if not inner.IsDisposed then inner.OnCompleted() override _.OnError error = if not inner.IsDisposed then inner.OnError error override _.OnNext value = if not inner.IsDisposed then inner.OnNext value override _.Subscribe observer = if inner.IsDisposed then observer.OnCompleted() Disposable.empty else inner.Subscribe observer }
Попутно в него можно запихнуть фикс для вызовов после смерти.
Свойства
9. Property
Вместо очередной версии MVar заведём ещё один примитив:
module Observable = type 'a Property when 'a : equality = inherit Observable.Var<'a> type 'a MProperty when 'a : equality = inherit Observable.MVar<'a> inherit Property<'a> module Property = let paranoid (property : _ Property) = { new Property<'a> with override _.Value = property.Value override _.Subscribe observer = property.Subscribe observer } type CompositeDisposable with member this.MProperty value = let mutable value = value let output = this.Subject () { new Observable.MProperty<'a> with override _.Value with get () = value and set newValue = if not this.IsDisposed && value <> newValue then value <- newValue output.Trigger newValue override _.Subscribe observer = observer.Trigger value output.Subscribe observer } member this.ToProperty value observable = let property = this.MProperty value observable |> this.Subscribe ^ fun p -> property.Value <- p Observable.Property.paranoid property // Вполне сознательно берём Var, а не Property. member this.MapProperty mapping var = var |> Observable.tail |> Observable.map mapping |> this.ToProperty ^ mapping (var : _ Observable.Var).Value member this.ToPropertyUnsafe observable = this.createFromFirst (fun p -> p.MProperty) (fun p value -> p.Value <- value) observable |> Observable.Property.paranoid
MProperty — это тот же MVar, но с защитой от дублей. То есть мы руками фильтруем поток подобно тому, как это происходит в distinctUntilChanged. При этом MProperty чуть строже, потому что требует от дженерика поддержки эквивалентности (в distinctUntilChanged он может быть любым).
В теории мы могли бы ожидать фильтрацию по дублям уже в MVar, что при использовании Unchecked.equals даже не ограничило бы тип дженерика. Но я предпочитаю держать такие фильтры отдельно, потому что проверка эквивалентности на некоторых типах ощутимо жрёт ресурсы. Нам нужен способ объяснить системе, что вот в этом месте не надо ничего сравнивать, потому что мы точно знаем, что пришедшее дерево хотя бы на 1%, но другое.
Промежуточное заключение
Var — это ядерный тип для выражения «реактивного свойства». Его определение завершено в этой главе, и дальше оно будет кочевать из статьи в статью без значимых изменений. По крайней мере до тех пор, пока мы не сменим Godot на что-то другое. Например, в мире WPF или Avalonia Var дополнится имплементацией INotifyPropertyChanged и, быть может, научится отправлять сообщение только в основном потоке.
Текущий Var очень примитивен и потому наиболее универсален среди всех аналогов, что я писал до этого или находил в других фреймворках. Поэтому его проще всех использовать в произвольном окружении. Однако упаковывать его в пакет я смысла не вижу. Кода мало и его легко кастомизировать под особенности конкретного ТВД.
Причём под «особенностями» я подразумеваю не новые фичи, а новые проблемы, связанные с тем, что кто-то что-то куда-то не сообщил или сообщил несвоевременно. О том, в какое адище может превратиться универсальное решение, можно судить по исходникам System.Reactive, Gjallarhorn или даже Hopac. Хотя в последнем случае картину сильно улучшает наличие Hopac.Core, в недра которого вынесено изрядное количество инфраструктурных корнер-кейсов.
В следующей главе мы поговорим о симуляции поведения юнитов на базе реактивных потоков. С синтаксическими особенностями, разумеется.
НЛО прилетело и оставило здесь промокод для читателей нашего блога: -15% на заказ нового VDS — HABRFIRSTVDS.
VYudachev
За отсылку к "Скале" отдельный респект, музыка Ханса Циммера сама в голове заиграла!
kleidemos Автор
Ага. Зимой показывал другой материал с этими же юнитами в одной локальной группе. Все сошлись во мнении что:
Музыкальную тему Хаммеля всё ещё хорошо помнят и переживают за него больше, чем за всю американскую рать во всех фильмах вместе взятых.
Ту бодрую музыку, под которую бегут морпехи, тоже многие помнят, но она в официальном саундтреке длится ровно столько, сколько длится в кино, то есть около минуты. Это ужасно мало.