public void RegistTurnReactiveProperty(IReactiveProperty <bool> _isMyTurn) { _isMyTurn.Subscribe(isMyTurn => { returnLocalInput = isMyTurn; }); }
public void Ctor(IReactiveProperty <EnumBattleWindow> battleState) { base.Ctor(); LevelGeneratorPanel.Ctor(); FightPanel.Ctor(); VictoryPanel.Ctor(); PausePanel.Ctor(); FailPanel.Ctor(); _battleState = battleState; _battleState.Subscribe(_ => { if (!enabled) { return; } if (_battleState.Value == EnumBattleWindow.DungeonGenerator) { LevelGeneratorPanel.Show(); } else { LevelGeneratorPanel.Hide(); } if (_battleState.Value == EnumBattleWindow.Fight) { FightPanel.Show(); } else { FightPanel.Hide(); } if (_battleState.Value == EnumBattleWindow.Victory) { VictoryPanel.Show(); } else { VictoryPanel.Hide(); } if (_battleState.Value == EnumBattleWindow.Fail) { FailPanel.Show(); } else { FailPanel.Hide(); } if (_battleState.Value == EnumBattleWindow.Pause) { PausePanel.Show(); } else { PausePanel.Hide(); } }).AddTo(_subscriptions); }
public Node() { _script = new Script(Parameters); Script.Subscribe(x => { _script.Content = x; }); }
public void SubscribeProperty(string name, IReactiveProperty <int> property) { if (_subscriptions.ContainsKey(name)) { _subscriptions[name].Dispose(); } _subscriptions[name] = property.Subscribe(_ => this[name] = _); }
private static IDisposable CreateTowWayBinding <T, TTarget, TProperty>(IReactiveProperty <T> self, TTarget target, Expression <Func <TTarget, TProperty> > propertySelector, Func <T, TProperty> convert, Func <TProperty, T> convertBack, IObservable <Unit> targetUpdateTrigger, TProperty propertyFallbackValue, T sourceFallbackValue) { if (targetUpdateTrigger == null) { throw new NotSupportedException("TwoWay binding required targetUpdateTrigger parameter."); } var propertyName = default(string); var d = new CompositeDisposable(); var targetUpdating = false; var sourceUpdating = false; targetUpdateTrigger .Subscribe(_ => { if (sourceUpdating) { return; } targetUpdating = true; try { self.Value = convertBack(AccessorCache <TTarget> .LookupGet(propertySelector, out propertyName)(target)); } catch (Exception ex) { Debug.WriteLine(ex); self.Value = sourceFallbackValue; } targetUpdating = false; }) .AddTo(d); self.Subscribe(value => { if (targetUpdating) { return; } var setter = AccessorCache <TTarget> .LookupSet(propertySelector, out propertyName); sourceUpdating = true; try { setter(target, convert(value)); } catch (Exception ex) { Debug.WriteLine(ex); setter(target, propertyFallbackValue); } sourceUpdating = false; }) .AddTo(d); return(d); }
protected ClosableViewController(T view) { _view = view; _isOpen = new ReactiveProperty <bool>().AddTo(Disposer); _isOpen .Subscribe(_view.SetIsVisible) .AddTo(Disposer); }
protected Parameter() { Value.Subscribe(x => { foreach (var parameter in Targets) { parameter.Value.Value = x; } }); }
public void Ctor(IReactiveProperty <EnumBattleWindow> battleState) { base.Ctor(); _battleState = battleState; _battleState.Subscribe(_ => { _forTextureRenderCamera.gameObject.SetActive( _battleState.Value == EnumBattleWindow.DungeonGenerator); }); }
public void RegistTurnReactiveProperty(IReactiveProperty <bool> _isMyTurn) { _isMyTurn.Subscribe(isMyTurn => { if (isMyTurn) { transform.position = myIndicatorPotision; } else { transform.position = oppIndicatorPotision; } }); }
public void Ctor(IReactiveProperty <EnumMainWindow> activeWindow, IReactiveProperty <EnumBattleWindow> battleState) { _battleState = battleState; _activeWindow = activeWindow; CharacterWindow.Ctor(); EquipmentWindow.Ctor(); BattleWindow.Ctor(_battleState); SpellsWindow.Ctor(); TalentsWindow.Ctor(); _activeWindow.Subscribe(_ => { ShowOnlyActiveWindow(); }); }
public InputFieldBinding(InputField inputField, IReactiveProperty <string> property) { this.inputField = inputField; this.property = property; inputField.onValueChanged.AddListener(OnValueChanged); binding = property.Subscribe(newVal => { if (inEventHandler) { return; } this.inputField.text = newVal; }); }
public ToggleBinding(Toggle toggle, IReactiveProperty <bool> property) { this.toggle = toggle; this.property = property; binding = property.Subscribe(newValue => { if (inEventHandler) { return; } this.toggle.isOn = newValue; }); toggle.onValueChanged.AddListener(OnToggle); }
public void Ctor(IReactiveProperty <EnumMainWindow> activeWindow, IReactiveProperty <EnumBattleWindow> battleState, IReactiveProperty <EnumCharacterWindow> charWindow, ListOfCharactersController listOfCharactersController) { _activeWindow = activeWindow; _battleState = battleState; _charWindow = charWindow; _listOfCharactersController = listOfCharactersController; CharacterPanel.Ctor(_activeWindow, _charWindow, _listOfCharactersController); EquipmentPanel.Ctor(); BattlePanel.Ctor(_battleState); SpellsPanel.Ctor(); TalentsPanel.Ctor(); NavigationBar.Ctor(_activeWindow, _battleState); _activeWindow.Subscribe(_ => { ShowOnlyActivePanel(); }); _battleState.Subscribe(_ => { ShowBattleOnlyActivePanel(); }); }
/** * <summary>Through this method, it is possible to define multiple behaviors, like for example the * onClick event/function that should be triggered when a button is pressed.</summary> */ private void AddObservables() { connectButton.OnClickAsObservable().Subscribe(connect => ConnectSensors()).AddTo(disposables); DeviceOption1.OnClickAsObservable().Subscribe(click => SelectedDevice(DeviceOption1)).AddTo(disposables); DeviceOption2.OnClickAsObservable().Subscribe(click => SelectedDevice(DeviceOption2)).AddTo(disposables); DeviceOption3.OnClickAsObservable().Subscribe(click => SelectedDevice(DeviceOption3)).AddTo(disposables); DeviceOption4.OnClickAsObservable().Subscribe(click => SelectedDevice(DeviceOption4)).AddTo(disposables); DeviceOption5.OnClickAsObservable().Subscribe(click => SelectedDevice(DeviceOption5)).AddTo(disposables); DeviceOption6.OnClickAsObservable().Subscribe(click => SelectedDevice(DeviceOption6)).AddTo(disposables); DeviceOption7.OnClickAsObservable().Subscribe(click => SelectedDevice(DeviceOption7)).AddTo(disposables); DeviceOption8.OnClickAsObservable().Subscribe(click => SelectedDevice(DeviceOption8)).AddTo(disposables); DeviceOption9.OnClickAsObservable().Subscribe(click => SelectedDevice(DeviceOption9)).AddTo(disposables); DeviceOption10.OnClickAsObservable().Subscribe(click => SelectedDevice(DeviceOption10)).AddTo(disposables); DeviceOption11.OnClickAsObservable().Subscribe(click => SelectedDevice(DeviceOption11)).AddTo(disposables); sensorsConnectedProperty.Subscribe(sensorsConnected => SensorsConnectionChange(sensorsConnected)).AddTo(disposables); scanButton.OnClickAsObservable().Subscribe(click => Scan()).AddTo(disposables); statusTextProperty.SubscribeToText(statusText).AddTo(disposables); valueTextProperty.SubscribeToText(valueText).AddTo(disposables); }
public void Ctor(IReactiveProperty <EnumMainWindow> activeWindow, IReactiveProperty <EnumCharacterWindow> activeCharacterWindow, ListOfCharactersController listCharactersManager) { base.Ctor(); _activeWindow = activeWindow; _activeCharacterWindow = activeCharacterWindow; _listOfCharactersController = listCharactersManager; _newCharPanel.Ctor(_activeCharacterWindow, _listOfCharactersController); _settingCharPanel.Ctor(_activeCharacterWindow, _listOfCharactersController); _listCharPanel.Ctor(_activeWindow, _activeCharacterWindow, _listOfCharactersController); //переключение между дочерними окнами _activeCharacterWindow.Subscribe(_ => { if (_activeCharacterWindow.Value == EnumCharacterWindow.ListCharacters) { _listCharPanel.Show(); } else { _listCharPanel.Hide(); } if (_activeCharacterWindow.Value == EnumCharacterWindow.NewSelectClass) { _newCharPanel.Show(); } else { _newCharPanel.Hide(); } if (_activeCharacterWindow.Value == EnumCharacterWindow.NewSettingsCharacter) { _settingCharPanel.Show(); } else { _settingCharPanel.Hide(); } }).AddTo(_subscriptions); }
public PositioningCharacterInMenuController(IReactiveProperty <EnumMainWindow> activeWindow, IReactiveProperty <EnumBattleWindow> battleState) { _battleState = battleState; _activeWindow = activeWindow; _activeWindow.Subscribe(_ => { if (!_isEnable) { return; } if (!_parentsPositions.ContainsKey(_activeWindow.Value)) { return; } SetPlayerPosition(_parentsPositions[_activeWindow.Value]); }); }
public static IDisposable BindToSlider(this IReactiveProperty <float> This, Slider slider) { bool isChanging = false; // Listen for changes in slider's value UnityAction <float> onSliderValueChanged = x => { // Prevent updating reactive property if change originated from it if (isChanging) { return; } isChanging = true; This.Value = x; isChanging = false; }; slider.onValueChanged.AddListener(onSliderValueChanged); // Listen for changes in reactive property's value var disposable = This.Subscribe(x => { // Prevent updating slider if change originated from it if (isChanging) { return; } isChanging = true; slider.value = x; isChanging = false; }); // Setup disposal return(Disposable.Create(() => { disposable.Dispose(); slider.onValueChanged.RemoveListener(onSliderValueChanged); })); }
public FightCameraController(IReactiveProperty <EnumBattleWindow> battleState, IPlayerView player, FightCamera camera, IReactiveProperty <EnumFightCamera> typeCameraAndCharControl) { _camera = camera; _player = player; _battleState = battleState; _typeCameraAndCharControl = typeCameraAndCharControl; _battleState.Subscribe(_ => { if (_battleState.Value == EnumBattleWindow.Fight) { _followThePlayer = true; } else { _followThePlayer = false; } }).AddTo(_subscriptions); _typeCameraAndCharControl.Subscribe(_ => { if (_typeCameraAndCharControl.Value == EnumFightCamera.TopView) { _move = TopViewFollow; } if (_typeCameraAndCharControl.Value == EnumFightCamera.ThirdPersonView) { _move = ThirdPersonViewFollow; } }).AddTo(_subscriptions); _camera.ThirdTarget = Object.Instantiate( new GameObject("ThirdPersonTargetCamera"), _player.Transform ).transform; _camera.ThirdTarget.localPosition = _camera.OffsetThirdPosition(); _camera.TopTarget = _player.Transform; }
public void Start() { //setup game status, when it get changes gameStatus.Subscribe(status => { print("Game status: " + status.ToString()); btnRestart.gameObject.SetActive(status != GameStatus.InProgress); }) .AddTo(gameObject); //setup button restart btnRestart.OnClickAsObservable() .Subscribe(unit => { SceneManager.LoadScene(0); //restart the game }) .AddTo(gameObject); //setup the layout gridLayout.constraint = GridLayoutGroup.Constraint.FixedColumnCount; gridLayout.constraintCount = gameSetting.Width; //build the board gameBoard.Build(); //create cells foreach (var data in cellData) { var cell = cellFactory.Create(); cell.SetParent(container); cell.SetCellData(data); cells.Add(cell); } //solve the game Observable.FromCoroutine(_ => gameSolver.Solve(1f)).Subscribe(_ => { print("Finished"); }) .AddTo(this); }
public void SetDefaultWeatherProperty(IReactiveProperty <WeatherEnum> weatherProperty) { weatherProperty .Subscribe(weather => WeatherSubject.OnNext(weather)) .AddTo(gameObject); }
public void Ctor(IReactiveProperty <EnumMainWindow> activeWindow, IReactiveProperty <EnumBattleWindow> battleState) { _subscriptions = new CompositeDisposable(); _battleState = battleState; _activeWindow = activeWindow; _activeWindow.Subscribe(active => { switch (active) { case EnumMainWindow.None: break; case EnumMainWindow.Character: CharToggle.isOn = true; break; case EnumMainWindow.Equip: EquipToggle.isOn = true; break; case EnumMainWindow.Battle: BattleToggle.isOn = true; break; case EnumMainWindow.Spells: SpellsToggle.isOn = true; break; case EnumMainWindow.Talents: TalentsToggle.isOn = true; break; default: throw new ArgumentOutOfRangeException(nameof(active), active, null); } }); CharToggle.OnValueChangedAsObservable().Subscribe(x => { if (x) { // Debug.Log($"_activeWindow.Value = EnumMainWindow.Character"); _activeWindow.Value = EnumMainWindow.Character; } }).AddTo(_subscriptions); EquipToggle.OnValueChangedAsObservable().Subscribe(x => { if (x) { // Debug.Log($"_activeWindow.Value = EnumMainWindow.Equip"); _activeWindow.Value = EnumMainWindow.Equip; } }).AddTo(_subscriptions); BattleToggle.OnValueChangedAsObservable().Subscribe(x => { if (x) { // Debug.Log($"_activeWindow.Value = EnumMainWindow.Battle"); _activeWindow.Value = EnumMainWindow.Battle; _battleState.Value = EnumBattleWindow.DungeonGenerator; } }).AddTo(_subscriptions); SpellsToggle.OnValueChangedAsObservable().Subscribe(x => { if (x) { // Debug.Log($"_activeWindow.Value = EnumMainWindow.Spells"); _activeWindow.Value = EnumMainWindow.Spells; } }).AddTo(_subscriptions); TalentsToggle.OnValueChangedAsObservable().Subscribe(x => { if (x) { // Debug.Log($"_activeWindow.Value = EnumMainWindow.Talents"); _activeWindow.Value = EnumMainWindow.Talents; } }).AddTo(_subscriptions); }
public ReactiveCalculator(IReactiveProperty <string> expression) { _subscriptions["Expression"] = expression.Subscribe(_ => Expression = _); }