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 = _);
}
