public void PostInit()
{
SceneLoader instance = SceneLoader.Instance;
DrillAdCooldown = (from _ in TickerService.MasterTicksSlow
select(float) Singleton <AdRunner> .Instance.GetNextTimeToShowAd(AdPlacement.Drill).TotalSeconds into secsLeft
select(int) Mathf.Max(0f, secsLeft)).DistinctUntilChanged().TakeUntilDestroy(instance).ToReactiveProperty();
DrillAdAvailable = (from avail in DrillAdCooldown.CombineLatest(PlayerData.Instance.DrillLevel, (int cd, int lvl) => cd <= 0 && lvl < m_maxDrillAds)
select(avail)).CombineLatest(Singleton <AdRunner> .Instance.AdReady, (bool time, bool ad) => time && ad).TakeUntilDestroy(instance).ToReadOnlyReactiveProperty();
DrillAdCooldownLeft = DrillAdCooldown.Select(delegate(int seconds)
{
string empty = string.Empty;
return((seconds > 0) ? TextUtils.FormatSecondsShort(seconds) : PersistentSingleton <LocalizationService> .Instance.Text("AD.Placement.NotAvailable"));
}).TakeUntilDestroy(instance).ToReadOnlyReactiveProperty();
(from ad in Singleton <AdRunner> .Instance.AdPlacementFinished
where ad == AdPlacement.Drill
select ad).Subscribe(delegate
{
DrillAdFinished();
}).AddTo(instance);
(from ad in Singleton <AdRunner> .Instance.AdPlacementSkipped
where ad == AdPlacement.Drill
select ad).Subscribe(delegate
{
DrillAdSkipped();
}).AddTo(instance);
(from ad in Singleton <AdRunner> .Instance.AdPlacementFailed
where ad == AdPlacement.Drill
select ad).Subscribe(delegate
{
DrillAdSkipped();
}).AddTo(instance);
}
void Awake () {
select_subscription = selected_scores.Subscribe((s)=>{
if (s != null){
if (date_time != null)
date_time.text = s.time.date_recorded_local().ToString();
//Yeah, it's ugly abuse of static variables, but I'll fix it later.
score = s;
MenuStateMachine.fsm.trigger_transition("scores->details");
}
});
rx_player_name = rx_score.SelectMany(s=>{
if (s == null)
return Observable.Never<String>();
return s.rx_player_name.AsObservable();
}).CombineLatest(LanguageController.controller.rx_load_text("score_default_name"), (name, default_name)=>{
if (IsNullOrWhiteSpace(name))
return default_name;
return name;
}).ToReadOnlyReactiveProperty<string>();
rx_player_name.Subscribe(t=>{
if (player_name != null)
player_name.text = t;
});
}
public ChunkRunner()
{
Singleton <PropertyManager> .Instance.AddRootContext(this);
m_raycastMask = 1 << LayerMask.NameToLayer("Blocks");
SceneLoader instance = SceneLoader.Instance;
BindingManager bind = BindingManager.Instance;
ShowNotification = (from _ in BlocksClearTriggered
select true).TakeUntilDestroy(instance).ToSequentialReadOnlyReactiveProperty();
BlocksAmount = (from amount in AllBlockAmount
select(!(BossBlock.Value == null)) ? Mathf.Max(0, amount - 1) : amount).TakeUntilDestroy(instance).ToReadOnlyReactiveProperty();
(from custom in CustomLevel
where custom
select custom).Subscribe(delegate
{
bind.CustomLevelNode.SetActive(value: true);
}).AddTo(instance);
(from custom in CustomLevel.Pairwise()
where !custom.Current && custom.Previous
select custom).Subscribe(delegate
{
bind.CustomLevelNode.SetActive(value: false);
bind.CustomLevelFinishedNode.SetActive(value: true);
}).AddTo(instance);
(from custom in CustomLevel.Pairwise()
where !custom.Current && !custom.Previous
select custom).Subscribe(delegate
{
bind.CustomLevelNode.SetActive(value: false);
bind.CustomLevelFinishedNode.SetActive(value: false);
}).AddTo(instance);
ChunkProgress = CurrentChunkHealth.CombineLatest(ChunkMaxHealth, (BigDouble curr, BigDouble max) => (curr / max).ToFloat()).TakeUntilDestroy(instance).ToReadOnlyReactiveProperty();
ChunkHealthText = CurrentChunkHealth.CombineLatest(ChunkMaxHealth, (BigDouble curr, BigDouble max) => BigString.ToString(curr) + " / " + BigString.ToString(max)).TakeUntilDestroy(instance).ToReadOnlyReactiveProperty();
}
public Service(Oanda.RestClient restClient, string[] instruments)
{
this.restClient = restClient;
this.mt4Commands = new Subject <MT4.Command>();
var prices = this.restClient.GetPriceStream(instruments);
this.Instruments = new ReadOnlyDictionary <string, Instrument>(
instruments
.Select(name => {
var ps = prices.Where(p => p.InstrumentName == name);
var cs = this.mt4Commands.Where(c => c.Instrument == name);
return(new Instrument(name, ps, cs));
})
.ToDictionary(instrument => instrument.Name)
);
var events = this.restClient.GetEventStream().Merge(Observable.Return <object>(null));
this.Account = events
.SelectMany(_ => this.restClient.GetAccount())
.ToReadOnlyReactiveProperty()
;
this.Positions = events
.SelectMany(_ => this.restClient.GetPositions())
.ToReadOnlyReactiveProperty()
;
}
public ListControl()
{
Views = _reactiveViews.ToReadOnlyReactiveProperty();
Models = _models
.Select(x => new ReadOnlyCollection <object>(x))
.ToReadOnlyReactiveProperty();
}
void Start()
{
// Distance display
_distance = new ReadOnlyReactiveProperty <float>(Observable.EveryUpdate().Select(_ =>
Vector3.Distance(player.transform.position, mob.transform.position)));
_distance.SubscribeToText(this.distanceText);
// Mob chase player every update
Observable.EveryUpdate().Subscribe(_ =>
mob.direction.Value = (player.transform.position - mob.transform.position).normalized);
// Time sequence of 1/1, 1/2, 1/3, 1/4...
var fracTimeSequence = Observable.Create <float>(observer =>
{
var i = 1;
return(Scheduler.DefaultSchedulers.TimeBasedOperations.Schedule(System.TimeSpan.FromSeconds(this.initialTime / i), self =>
{
observer.OnNext(i % 2 == 0 ? 1.0f : -1.0f);
i++;
self(System.TimeSpan.FromSeconds(this.initialTime / i));
}));
});
fracTimeSequence.Subscribe(_ => this.player.direction.Value = Vector3.Cross(Vector3.back, this.mob.direction.Value).normalized);
}
public AppModel()
{
CubeTransform = InitializeCubeTransform();
var inclinometer = Inclinometer.GetDefault();
if (inclinometer != null)
{
inclinometer.ReportInterval = 200;
inclinometer.ReadingChanged += (o, e) => InclinationData.Value = e.Reading;
}
var orientationSensor = OrientationSensor.GetDefault();
if (orientationSensor != null)
{
orientationSensor.ReportInterval = 200;
orientationSensor.ReadingChanged += (o, e) => OrientationData.Value = e.Reading;
}
RotationQuaternion = OrientationData.Select(d => d.Quaternion.ToQuaternion()).ToReadOnlyReactiveProperty();
RotationQuaternionString = RotationQuaternion.Select(q => $"{q.W:F2}; ({q.X:F2}, {q.Y:F2}, {q.Z:F2})").ToReadOnlyReactiveProperty();
// Rotation is represented by a matrix, a quaternion or Euler angles (roll, pitch and yaw).
RotationMatrix = OrientationData.Select(d => d.RotationMatrix.ToMatrix3D()).ToReadOnlyReactiveProperty();
//RotationMatrix = RotationQuaternion.Select(q => q.ToMatrix3D()).ToReadOnlyReactiveProperty();
//RotationMatrix = InclinationData.Select(i => i.ToMatrix3D()).ToReadOnlyReactiveProperty();
// An inverse matrix represents the inverse rotation.
RotationMatrix
.ObserveOn(SynchronizationContext.Current)
//.Subscribe(m => matrixTransform.Matrix = m);
.Subscribe(m => { m.Invert(); matrixTransform.Matrix = m; });
}
public BoosterRunner(int booster)
{
SceneLoader instance = SceneLoader.Instance;
BoosterIndex = booster;
m_boosterConfig = PersistentSingleton <Economies> .Instance.Boosters[BoosterIndex];
if (BoosterIndex == 0)
{
m_maxBoosterAmount = PersistentSingleton <GameSettings> .Instance.MaxDamageBoosterPurchaseAmount;
}
else
{
m_maxBoosterAmount = PersistentSingleton <GameSettings> .Instance.MaxBoosterPurchaseAmount;
}
BoosterMaxReached = (from currentAmount in PlayerData.Instance.BoostersBought[BoosterIndex]
select currentAmount >= m_maxBoosterAmount).TakeUntilDestroy(instance).ToReadOnlyReactiveProperty();
BoosterCost = (from amount in PlayerData.Instance.BoostersBought[BoosterIndex]
select Singleton <EconomyHelpers> .Instance.GetBoosterCost(BoosterIndex, amount)).TakeUntilDestroy(instance).ToReadOnlyReactiveProperty();
BoosterAvailable = BoosterCost.CombineLatest(PlayerData.Instance.Gems, (int cost, int gems) => cost <= gems).TakeUntilDestroy(instance).ToSequentialReadOnlyReactiveProperty();
BoosterName.Value = PersistentSingleton <LocalizationService> .Instance.Text("GemBooster.Title." + (BoosterEnum)BoosterIndex);
BoosterDescription.Value = PersistentSingleton <LocalizationService> .Instance.Text("GemBooster.Desc." + (BoosterEnum)BoosterIndex);
BoosterBonus = (from _ in PlayerData.Instance.BoostersEffect[BoosterIndex]
select BoosterCollectionRunner.GetBoosterBonusString((BoosterEnum)BoosterIndex)).TakeUntilDestroy(instance).ToReadOnlyReactiveProperty();
BoosterNextUpgrade = (from _ in BoosterCost
select BoosterCollectionRunner.GetBoosterNextUpgradeString((BoosterEnum)BoosterIndex)).TakeUntilDestroy(instance).ToReadOnlyReactiveProperty();
ActiveBooster = (from active in Singleton <BoosterCollectionRunner> .Instance.ActiveBooster
select active == BoosterIndex).TakeUntilDestroy(instance).ToReadOnlyReactiveProperty();
}
public Person(string givenName, string familyName)
{
GivenName = new ReactiveProperty <string>(givenName);
FamilyName = new ReactiveProperty <string>(familyName);
// If change the givenName or familyName, notify with fullName!
FullName = GivenName.CombineLatest(FamilyName, (x, y) => x + " " + y).ToReadOnlyReactiveProperty();
}
public NotifyWindowViewModel(Window ownerWindow)
{
this._mainWindow = ownerWindow as MainWindow;
if (this._mainWindow == null)
{
throw new ArgumentException(nameof(ownerWindow));
}
var mainWindowViewModel = this._mainWindow.DataContext as MainWindowViewModel;
this.Profiles = mainWindowViewModel.Profiles;
IsAnyConnected = this.Profiles
.ObserveElementObservableProperty(x => x.IsConnected)
.ObserveOnUIDispatcher()
.Select(_ =>
{
this.ProfilesView.Refresh();
return(this.ProfilesView.Count > 0);
})
.ToReadOnlyReactiveProperty()
.AddTo(this.Subscription);
mainWindowViewModel.ReloadCommand.Execute();
}
public UserModel()
{
LoggedInUser = new ReactiveProperty <Type.LoggedInUser>();
HasLoggedIn = LoggedInUser.Select(u => u != null).ToReadOnlyReactiveProperty();
Name = LoggedInUser.Select(u => u == null ? string.Empty : u.Name).ToReadOnlyReactiveProperty();
}
public UnitViewModel(UnitConfig config, UnitModel model, ResourcePackViewModel resources)
{
Assert.IsNotNull(config, nameof(config));
Assert.IsNotNull(model, nameof(model));
Assert.IsNotNull(resources, nameof(resources));
_config = config;
_model = model;
_resources = resources;
_sprite = new ReactiveProperty <Sprite>();
Sprite = _sprite.ToReadOnlyReactiveProperty();
_level = new ReactiveProperty <int>(_model.Level);
Level = _level.ToReadOnlyReactiveProperty();
Income = new ResourceViewModel(model.Income);
_upgradePrice = new ReactiveProperty <ResourceViewModel>(GetUpgradePrice());
UpgradePrice = _upgradePrice.ToReadOnlyReactiveProperty();
_canUpgrade = new ReactiveProperty <bool>(IsUpgradeAvailable());
CanUpgrade = _canUpgrade.ToReadOnlyReactiveProperty();
foreach (var resource in resources.Resources)
{
resource.Value.Amount
.Select(_ => IsUpgradeAvailable())
.Subscribe(isAvailable => _canUpgrade.Value = isAvailable);
}
Level
.Do(l => _model.Level = l)
.Subscribe(OnLevelUpdated);
}
private void Awake()
{
Jump = this.UpdateAsObservable()
.Where(_ => Input.GetButtonDown("Jump"));
var jumpLatch = CustomObservables.Latch(this.FixedUpdateAsObservable(), Jump, false);
Movement = this.FixedUpdateAsObservable()
.Select(_ =>
{
float x = Input.GetAxis("Horizontal");
float y = Input.GetAxis("Vertical");
Vector2 dir2D = new Vector2(x, y);
return(dir2D);
});
MoveInputs = Movement.Zip(jumpLatch, (movement, jump) => new MovementInputs(movement, jump));
Rotation = this.UpdateAsObservable()
.Select(_ =>
{
float mouseX = Input.GetAxis("Mouse X");
float mouseY = Input.GetAxis("Mouse Y");
return(new Vector2(mouseX, mouseY));
});
Run = this.UpdateAsObservable()
.Select(_ =>
{
return(Input.GetButton("Fire3"));
}).ToReadOnlyReactiveProperty();
}
public GameViewModel(IModel model) : base(model)
{
_isPause = new ReactiveProperty <bool>(false);
IsPause = new ReadOnlyReactiveProperty <bool>(_isPause);
InitLevelCommand = new ReactiveCommand <int>();
PlayerGetDamageCommand = new ReactiveCommand <int>();
SetPauseCommand = new ReactiveCommand <bool>();
ChangePlayerAttemptCommand = new ReactiveCommand();
ResetPlayerHpCommand = new ReactiveCommand();
FinishLevelCommand = new ReactiveCommand();
InitLevelCommand.Subscribe(InitNewLevelGameData);
SetPauseCommand.Subscribe(isPause =>
{
_isPause.Value = isPause;
});
ChangePlayerAttemptCommand.Subscribe(_ =>
{
_playerAttempts.Value -= 1;
});
ResetPlayerHpCommand.Subscribe(_ =>
{
_playerHp.Value = Model.GameData.StartPlayerHp;
});
PlayerGetDamageCommand.Subscribe(_ =>
{
_playerHp.Value -= 1;
});
FinishLevelCommand.Subscribe(_ =>
{
Model.PlayerInGameValue.Value += LevelSettings.LevelInGameValuePrice;
Model.PlayerPassedLevel.Value++;
});
}
// Use this for initialization
protected override void Awake()
{
base.Awake();
var hinf = new RaycastHit();
Grounded = Observable.EveryFixedUpdate()
.Select(_ => Physics.Raycast(RaycastOrigin, Vector3.down, out hinf, Level.Instance.DistBetweenAnchors, LayerMask.GetMask("Bounds", "Blocks", "Characters")))
.ToReadOnlyReactiveProperty(true);
Grounded.AddTo(this);
Grounded.Subscribe(x => Anim.SetBool("Falling", !x));
ObservableHP = this.ObserveEveryValueChanged(x => x.CurHp)
.ToReadOnlyReactiveProperty(CurHp);
IsDead = ObservableHP
.Select(x => x <= 0)
.ToReadOnlyReactiveProperty(false);
Rb.OnCollisionEnterAsObservable()
.Select(c => c.collider.GetComponentInParent <GameCharacter>())
.Where(gc => gc && (gc.transform.position - transform.position).y < -Level.Instance.DistBetweenAnchors * .5f)
.TakeUntil(IsDead.Where(x => x))
.Subscribe(gc =>
{
target.Value = gc;
gc.GetHit();
Rb.AddForce(Vector3.up * 3.5f, ForceMode.Impulse);
})
.AddTo(this);
}
protected void bindPreloading(List <FlooredAdProvider> placements)
{
if (placements.Count != 0)
{
ReactiveProperty <bool> highestFloorHasAd = placements.First().AdsReady;
ReadOnlyReactiveProperty <long> source = (from r in highestFloorHasAd
where !r
select r into _
select ServerTimeService.NowTicks()).ToReadOnlyReactiveProperty();
UniRx.IObservable <long> source2 = (from _ in source
select Observable.Return(0L).Concat(Observable.Interval(TimeSpan.FromSeconds(preloadNotAvailableWaitingPeriod))).TakeUntil(from r in highestFloorHasAd
where r
select r)).Switch();
FlooredAdProvider backFiller = placements.Last();
(from _ in source2
where !backFiller.AdsReady.Value
select _).Subscribe(delegate
{
preload(backFiller);
}).AddTo(_disposable);
FlooredAdProvider[] flooredPlacements = (from p in placements
where p != backFiller
select p).ToArray();
if (flooredPlacements.Length > 0)
{
(from _ in source2
select(from p in flooredPlacements
select UniRx.Tuple.Create(p, flooredPlacements.TakeWhile((FlooredAdProvider pr) => pr != p))).ToObservable().SelectMany((UniRx.Tuple <FlooredAdProvider, IEnumerable <FlooredAdProvider> > pair) => Observable.Return(pair).Delay(TimeSpan.FromSeconds(waitTimeForTheNextProvider * pair.Item2.Count())).SelectMany((UniRx.Tuple <FlooredAdProvider, IEnumerable <FlooredAdProvider> > p) => Observable.Return(p).TakeUntil(previousOrMeGotReady(pair.Item1, pair.Item2))))).Switch().Subscribe(delegate(UniRx.Tuple <FlooredAdProvider, IEnumerable <FlooredAdProvider> > p)
{
preload(p.Item1);
}).AddTo(_disposable);
}
}
}
public TodoUsecase(ITodoRepository todoRepository)
{
this.todoRepository = todoRepository;
IsVisibleDone = IsVisibleDoneInternal.ToReadOnlyReactiveProperty();
TodoItems = TodoItemsInternal.ToReadOnlyReactiveCollection();
}
public void PostInit()
{
SceneLoader instance = SceneLoader.Instance;
AdTime = (from _ in TickerService.MasterTicks
select(float) Singleton <AdRunner> .Instance.GetNextTimeToShowAd(AdPlacement.HammerTime).TotalSeconds into secsLeft
select(int) Mathf.Max(0f, secsLeft)).DistinctUntilChanged().TakeUntilDestroy(instance).ToReactiveProperty();
AdAvailable = (from time in AdTime
select time <= 0).CombineLatest(Singleton <AdRunner> .Instance.AdReady, (bool time, bool ad) => time && ad).TakeUntilDestroy(instance).ToReadOnlyReactiveProperty();
AdTimeLeft = AdTime.Select(delegate(int seconds)
{
string empty = string.Empty;
return((seconds > 0) ? TextUtils.FormatSecondsShort(seconds) : PersistentSingleton <LocalizationService> .Instance.Text("AD.Placement.NotAvailable"));
}).TakeUntilDestroy(instance).ToReadOnlyReactiveProperty();
(from ad in Singleton <AdRunner> .Instance.AdPlacementFinished
where ad == AdPlacement.HammerTime
select ad).Subscribe(delegate
{
HammerTimeAdFinished();
}).AddTo(instance);
(from ad in Singleton <AdRunner> .Instance.AdPlacementSkipped
where ad == AdPlacement.HammerTime
select ad).Subscribe(delegate
{
HammerTimeAdSkipped();
}).AddTo(instance);
(from ad in Singleton <AdRunner> .Instance.AdPlacementFailed
where ad == AdPlacement.HammerTime
select ad).Subscribe(delegate
{
HammerTimeAdSkipped();
}).AddTo(instance);
}
public AppModel()
{
// JPEG ファイルは DPI が異なる場合があります (既定では 96 だが、72 などもある)。
// Image コントロールに直接読み込ませると、DPI によりサイズが変化してしまいます。
ImageUrl
.Subscribe(u =>
{
var image = new BitmapImage(new Uri(u));
// ダウンロードの要否で分岐します。
if (image.IsDownloading)
{
image.DownloadCompleted += (o, e) => BitmapImage.Value = image;
}
else
{
BitmapImage.Value = image;
}
});
ImageUrl
.Subscribe(_ => DetectAsync());
IsImageEmpty = ImageUrl
.Select(u => u == null)
.ToReadOnlyReactiveProperty(true);
}
public LapTimeViewModel(int countOfLap, TimeSpan lapTime)
{
CountOfLap = new ReactiveProperty <int>(countOfLap)
.ToReadOnlyReactiveProperty();
LapTime = new ReactiveProperty <TimeSpan>(lapTime)
.ToReadOnlyReactiveProperty();
}
public GearSetCollectionRunner()
{
Singleton <PropertyManager> .Instance.AddRootContext(this);
SceneLoader instance = SceneLoader.Instance;
for (int i = 0; i < 25; i++)
{
BonusMult[i] = CreateObservableForAll((BonusTypeEnum)i).TakeUntilDestroy(instance).ToReadOnlyReactiveProperty();
}
ReactiveProperty <int> mainChunk = PlayerData.Instance.LifetimeChunk;
MaxSetsToShow = (from lvl in mainChunk
select GetMaxSetsToShow(lvl)).TakeUntilDestroy(instance).ToReadOnlyReactiveProperty();
SetUnlocked = (from pair in MaxSetsToShow.Pairwise()
where pair.Previous < pair.Current
select pair into _
select GetUnlockedGears(mainChunk.Value)).Do(delegate
{
BindingManager.Instance.HeroLevelParent.ShowInfo();
}).TakeUntilDestroy(instance).ToReadOnlyReactiveProperty();
NextSetUnlockAt = (from lvl in mainChunk
select GetNextSetUnlockAt(lvl)).TakeUntilDestroy(instance).ToReadOnlyReactiveProperty();
AllSetsUnlocked = (from lvl in mainChunk
select IsAllSetsUnlocked(lvl)).TakeUntilDestroy(instance).ToReadOnlyReactiveProperty();
AllAvailableGearsUnlocked = (from unlockAvailable in (from lvl in mainChunk
select GetMaxSetsToShow(lvl)).CombineLatest(PlayerData.Instance.LifetimeGears, (int maxSets, int unlocks) => maxSets * 3 > unlocks)
select !unlockAvailable).TakeUntilDestroy(instance).ToReadOnlyReactiveProperty();
}
public StopWatchModel()
{
Debug.WriteLine("StopWatchModel ctor");
IsRunning = _isRunning.ToReadOnlyReactiveProperty(eventScheduler: Scheduler.Default);
IsVisibleMillis = _isVisibleMillis;
_timeFormat = IsVisibleMillis
.Select(v => v ? @"mm\:ss\.fff" : @"mm\:ss")
.ToReactiveProperty(raiseEventScheduler: Scheduler.Default);
FormattedTime = _time.CombineLatest(_timeFormat, (time, format) =>
TimeSpan.FromMilliseconds(time).ToString(format))
.ToReadOnlyReactiveProperty(eventScheduler: Scheduler.Default);
FormattedLaps = _laps.CombineLatest(_timeFormat,
(laps, f) => laps.Select((x, i) => TimeSpan.FromMilliseconds(x).ToString(f)))
.ToReadOnlyReactiveProperty(eventScheduler: Scheduler.Default);
FormattedFastestLap = _laps.CombineLatest(_timeFormat, (laps, format) =>
{
var fastest = laps.Count > 0 ? laps.Min() : 0;
return(TimeSpan.FromMilliseconds(fastest).ToString(format));
})
.ToReadOnlyReactiveProperty(eventScheduler: Scheduler.Default);
FormattedWorstLap = _laps.CombineLatest(_timeFormat, (laps, format) =>
{
var worst = laps.Count > 0 ? laps.Max() : 0;
return(TimeSpan.FromMilliseconds(worst).ToString(format));
})
.ToReadOnlyReactiveProperty(eventScheduler: Scheduler.Default);
}
public Instrument(string name, IObservable <Oanda.Price> prices, IObservable <MT4.Command> commands)
{
this.Name = name;
this.Price = prices.ToReadOnlyReactiveProperty();
this.CurrentLine = commands
.Where(c => c.price != null || c.operation == "close")
.Select(c => (c.operation == "close") ? null : c.price)
.ToReadOnlyReactiveProperty()
;
this.ChartLines = commands
.Where(c => c.lines != null || c.operation == "close")
.Scan(new Dictionary <long, MT4.Line[]>(), (a, c) =>
{
var ret = new Dictionary <long, MT4.Line[]>(a);
if (c.operation == "close")
{
ret.Remove(c.chart);
}
else
{
ret[c.chart] = c.lines;
}
return(ret);
})
.Select(d => new ReadOnlyDictionary <long, MT4.Line[]>(d))
.ToReadOnlyReactiveProperty()
;
}
void Awake()
{
this.direction = new ReactiveProperty <Vector3>(Vector3.up);
this.velocity = new ReadOnlyReactiveProperty <Vector3>(this.direction.Select(dir => dir * this.speed));
Observable.EveryUpdate().Subscribe(_ => this.transform.Translate(this.velocity.Value * Time.deltaTime));
}
public AppModel()
{
CubeTransform = InitializeCubeTransform();
FrontHand = LeapManager.FrameArrived
.Select(f => f.Hands.Frontmost)
.Select(h => h?.IsValid == true ? h : null)
.ToReadOnlyReactiveProperty();
InnerProduct = FrontHand
.Select(h => h != null ? h.Direction.Dot(h.PalmNormal) : double.NaN)
.ToReadOnlyReactiveProperty();
EulerAngles_org = FrontHand
.Select(h => h != null ? h.GetEulerAngles_org() : new EulerAngles())
.ToReadOnlyReactiveProperty();
EulerAngles = FrontHand
.Select(h => h != null ? h.GetEulerAngles() : new EulerAngles())
.ToReadOnlyReactiveProperty();
//Rotation = EulerAngles_org
Rotation = EulerAngles
.Select(Rotation3DHelper.ToMatrix3D)
.ToReadOnlyReactiveProperty();
Rotation
.ObserveOn(SynchronizationContext.Current)
.Subscribe(m => matrixTransform.Matrix = m);
}
public NicoAccountIntroductionPageViewModel(HohoemaApp hohoema)
{
_HohoemaApp = hohoema;
IsLoggedIn = _HohoemaApp.ObserveProperty(x => x.IsLoggedIn)
.ToReadOnlyReactiveProperty();
}
public BasicUsageViewModel()
{
Input = new ReactiveProperty <string>("");
Output = Input.Delay(TimeSpan.FromSeconds(1))
.Select(x => x.ToUpper())
.ToReadOnlyReactiveProperty();
}
public CacheVideoViewModel(NicoVideo nicoVideo, PageManager pageManager)
: base(nicoVideo, pageManager, isNgEnabled: false)
{
CacheRequestTime = nicoVideo.ObserveProperty(x => x.CachedAt)
.ToReadOnlyReactiveProperty()
.AddTo(_CompositeDisposable);
}
public HammerTimeRunner()
{
Singleton <PropertyManager> .Instance.AddRootContext(this);
SceneLoader instance = SceneLoader.Instance;
ReactiveProperty <int> reactiveProperty = (from dur in PlayerData.Instance.BoostersEffect[5]
select(int) dur + PersistentSingleton <GameSettings> .Instance.GoldenHammerInitialDuration).TakeUntilDestroy(instance).ToReactiveProperty();
ReactiveProperty <int> right = reactiveProperty.CombineLatest(PlayerData.Instance.HammerTimeBonusDuration, (int dura, int bonus) => dura + bonus).TakeUntilDestroy(instance).ToReactiveProperty();
TickerService.MasterTicks.Subscribe(delegate(long ticks)
{
if (PlayerData.Instance.HammerTimeElapsedTime.Value < 1728000000000L)
{
PlayerData.Instance.HammerTimeElapsedTime.Value += ticks;
}
}).AddTo(instance);
UniRx.IObservable <int> source = PlayerData.Instance.HammerTimeElapsedTime.CombineLatest(right, (long ticks, int dur) => dur - (int)(ticks / 10000000));
Active = (from secs in source
select secs > 0).TakeUntilDestroy(instance).ToReactiveProperty();
DurationLeft = (from seconds in source
select TextUtils.FormatSecondsShort(seconds)).TakeUntilDestroy(instance).ToReadOnlyReactiveProperty();
DurationString = (from dur in reactiveProperty
select PersistentSingleton <LocalizationService> .Instance.Text("Attribute.Duration") + ": " + BoosterCollectionRunner.FormatSecondsForBoosters(dur)).TakeUntilDestroy(instance).ToReadOnlyReactiveProperty();
HammerTimeEnded = (from act in Active
select act && (HammerTimeActive = true) into sit
select(!sit && HammerTimeActive) ? true : false).TakeUntilDestroy(instance).ToReactiveProperty();
(from elapsed in PlayerData.Instance.HammerTimeElapsedTime
where elapsed < 0
select elapsed).CombineLatest(right, (long cheat, int dur) => dur).Subscribe(delegate(int dur)
{
PlayerData.Instance.HammerTimeElapsedTime.Value = dur;
}).AddTo(instance);
}
public LobbyModel()
{
Rooms = new ReactiveProperty <List <Type.Room> >(new List <Type.Room>());
JoinedRoom = new ReactiveProperty <Type.JoinedRoom>();
HasJoinedIntoRoom = JoinedRoom.Select(r => r != null).ToReadOnlyReactiveProperty();
}
public override async void OnNavigatedTo(NavigatedToEventArgs e, Dictionary <string, object> viewModelState)
{
base.OnNavigatedTo(e, viewModelState);
await this.Model.SetSelectedShopByIdAsync(e.Parameter as string);
this.Disposable = new CompositeDisposable();
this.Name = this.Model
.ObserveProperty(x => x.SelectedShop)
.Select(x => x?.name)
.ToReadOnlyReactiveProperty()
.AddTo(this.Disposable);
this.Kana = this.Model
.ObserveProperty(x => x.SelectedShop)
.Select(x => x?.name_kana)
.ToReadOnlyReactiveProperty()
.AddTo(this.Disposable);
this.Image = this.Model
.ObserveProperty(x => x.SelectedShop)
.Select(x => x?.photo?.pc?.l)
.ToReadOnlyReactiveProperty()
.AddTo(this.Disposable);
}
public QuickImportOption(string _name){
option_name = _name;
dropdown_option = new Dropdown.OptionData();
rx_display_text = LanguageController.controller.rx_get_filename_label(_name);
sub = rx_display_text.Subscribe(t=>{
dropdown_option.text = t;
});
}
void Start() {
if (slider != null){
rx_value = slider.OnValueChangedAsObservable().Select<float, float>(
clamp_value).ToReadOnlyReactiveProperty<float>(clamp_value(slider.value));
rx_value.Subscribe(
value => {
if (icon != null)
icon.color = StrawberryColor.color_gradient.Evaluate(value);
}
);
}
}
void init_visible(){
if (obs_visible == null){
init_status();
init_parent();
obs_visible = obs_parent.SelectMany((parent)=>{
if (parent == null)
return Observable.Return<bool>(true);
parent.init_visible();
return parent.obs_visible;
}).CombineLatest(obs_status, (bool p_visible, VisibilityStatus stat)=>{
if (stat == VisibilityStatus.AlwaysVisible) return true;
if (stat == VisibilityStatus.NeverVisible) return false;
return p_visible;
}).ToReadOnlyReactiveProperty();
obs_visible.DistinctUntilChanged().Subscribe(update);
};
}
void Start(){
rx_ripeness = rx_strawberry.Select(berry=>berry.ripeness).ToReadOnlyReactiveProperty<float>();
rx_weight = rx_strawberry.Select(berry=>berry.weight).ToReadOnlyReactiveProperty<float>();
rx_strawberry.Subscribe((berry) => {
if (berry != null && win != null){
vis.visible = true;
color_icon.color = StrawberryColor.get_color(berry.ripeness);
weight_text.text = berry.weight.ToString("0.00");
ScoreTarget ripeness = win.ripeness;
ScoreTarget berry_weight = win.berry_size;
//Status Icon
if (ripeness.is_accept(berry.ripeness)){
if (berry_weight.is_accept(berry.weight)){
status_icon.sprite = sprites["Accepted"];
} else {
status_icon.sprite = sprites["Undersize"];
}
} else {
if (ripeness.is_over(berry.ripeness)){
status_icon.sprite = sprites["Overripe"];
} else {
status_icon.sprite = sprites["Underripe"];
}
}
//Score Views
float flat_score = win.evaluate_strawberry_flat(berry);
float range_score = win.evaluate_strawberry_range(berry);
float total_score = win.evaluate_strawberry(berry);
ScoreDetailedForm.format_score_text(flat_score_text, flat_score);
ScoreDetailedForm.format_score_text(range_score_text, range_score);
ScoreDetailedForm.format_score_text(total_score_text, total_score);
} else {
//Hide the view if we don't have all the necessary data.
vis.visible = false;
}
});
}
public AppModel()
{
// JPEG ファイルは DPI が異なる場合があります (既定では 96 だが、72 などもある)。
// Image コントロールに直接読み込ませると、DPI によりサイズが変化してしまいます。
ImageUrl
.Subscribe(u =>
{
var image = new BitmapImage(new Uri(u));
// ダウンロードの要否で分岐します。
if (image.IsDownloading)
image.DownloadCompleted += (o, e) => BitmapImage.Value = image;
else
BitmapImage.Value = image;
});
ImageUrl
.Subscribe(_ => DetectAsync());
IsImageEmpty = ImageUrl
.Select(u => u == null)
.ToReadOnlyReactiveProperty(true);
}
public TodoItemViewModel(TodoItem todoItem)
{
this.Model = todoItem;
this.Title = this.Model
.ToReactivePropertyAsSynchronized(x => x.Title)
.SetValidateAttribute(() => this.Title);
this.Completed = this.Model
.ToReactivePropertyAsSynchronized(x => x.Completed);
this.ForegroundBrush = this.Model
.ObserveProperty(x => x.Completed)
.Select(x => x ? new SolidColorBrush(Colors.DarkGray) : new SolidColorBrush(Colors.Black))
.Select(x => (Brush)x)
.ToReadOnlyReactiveProperty();
this.HasErrors = Observable.CombineLatest(
this.Title.ObserveHasErrors,
this.Completed.ObserveHasErrors)
.Select(x => x.Any(y => y))
.ToReadOnlyReactiveProperty();
}
void Awake () {
rx_score.Subscribe((s)=>{
if (s != null){
date_time.text = s.time.date_recorded_local().ToString();
score_text.text = s.final_score().ToString("0.00");
}
});
rx_player_name = rx_score.SelectMany(s=>{
if (s == null)
return Observable.Never<String>();
return s.rx_player_name.AsObservable();
}).CombineLatest(LanguageController.controller.rx_load_text("score_default_name"), (name, default_name)=>{
if (IsNullOrWhiteSpace(name))
return default_name;
return name;
}).ToReadOnlyReactiveProperty<string>();
rx_player_name.Subscribe(t=>{
if (player_name != null)
player_name.text = t;
});
}
void Start(){
if (ui_texts.Count == 0)
ui_texts.AddRange(GetComponents<Text>());
if (mesh_texts.Count == 0)
mesh_texts.AddRange(GetComponents<TextMesh>());
//Stopgap solution until I can get dependency injection working.
if (controller == null){
controller = LanguageController.controller;
}
rx_value = controller.rx_get_language_label(rx_language);
sub = rx_value.Subscribe((t)=>{
foreach(Text ui in ui_texts){
if (ui != null){
ui.text = t;
}
}
foreach(TextMesh mesh in mesh_texts){
if (mesh != null){
mesh.text = t;
}
}
});
}
void Start(){
if (ui_texts.Count == 0)
ui_texts.AddRange(GetComponents<Text>());
if (mesh_texts.Count == 0)
mesh_texts.AddRange(GetComponents<TextMesh>());
//Stopgap solution until I can get dependency injection working.
if (controller == null){
controller = LanguageController.controller;
}
rx_value = controller.rx_load_text(rx_key);
subscription = rx_value.Subscribe((t)=>{
string full_text = prefix + t + suffix;
foreach(Text ui in ui_texts){
if (ui != null){
ui.text = full_text;
}
}
foreach(TextMesh mesh in mesh_texts){
if (mesh != null){
mesh.text = full_text;
}
}
});
}
public AppModel()
{
OcrLines = OcrResults
.Select(ocr => ocr == null ? "" : string.Join("\r\n", ToLines(ocr)))
.ToReadOnlyReactiveProperty();
}
public MainViewModel()
{
var powerDistribution = ((App)App.Current).PowerDistribution;
var powerDistributionLogger = ((App) Application.Current).PowerDistributionLogger;
var viewSettings = ((App) Application.Current).ViewSettings;
// View Settings
this.PlotForeground = viewSettings
.ObserveProperty(self => self.PlotStyle).Select(style => style.ObserveProperty(self => self.PlotForeground))
.Switch()
.Select(color => new SolidColorBrush(color))
.ToReadOnlyReactiveProperty()
.AddTo(this.disposables);
this.PlotBackground = viewSettings
.ObserveProperty(self => self.PlotStyle).Select(style => style.ObserveProperty(self => self.PlotBackground))
.Switch()
.Select(color => new SolidColorBrush(color))
.ToReadOnlyReactiveProperty()
.AddTo(this.disposables);
this.CurrentSensors = powerDistribution.Sensors.ToReadOnlyReactiveCollection(sensor => new CurrentSensorViewModel(sensor)).AddTo(this.disposables);
this.TotalCurrent = powerDistribution.ObserveProperty(self => self.TotalCurrent).ToReadOnlyReactiveProperty(mode:ReactivePropertyMode.RaiseLatestValueOnSubscribe)
.AddTo(this.disposables);
this.Capacity = powerDistribution.ObserveProperty(self => self.Capacity).ToReadOnlyReactiveProperty().AddTo(this.disposables);
this.Usage = Observable.CombineLatest(
this.TotalCurrent,
this.Capacity,
(totalCurrent, capacity) => capacity > 0 ? totalCurrent / capacity : 0)
.ToReadOnlyReactiveProperty()
.AddTo(this.disposables);
this.AlertState = Observable.CombineLatest(
powerDistribution.ObserveProperty(self => self.IsWarningCondition),
powerDistribution.ObserveProperty(self => self.IsCriticalCondition),
(isWarning, isCritical) => isCritical ? ErrorAlertState : (isWarning ? WarningAlertState : NormalAlertState))
.ToReadOnlyReactiveProperty()
.AddTo(this.disposables);
this.CurrentPlotType = new ReactiveProperty<PlotType>().AddTo(this.disposables);
this.IsLive = this.CurrentPlotType.Select(type => type == PlotType.Live).ToReadOnlyReactiveProperty().AddTo(this.disposables);
this.IsCustom = this.CurrentPlotType.Select(type => type == PlotType.Custom).ToReadOnlyReactiveProperty().AddTo(this.disposables);
this.IsHistroy = this.IsLive.Select(value => !value).ToReadOnlyReactiveProperty().AddTo(this.disposables);
this.CurrentPlotModel = new OxyPlot.PlotModel()
{
Axes =
{
new OxyPlot.Axes.LinearAxis() { Unit = "A", Position = OxyPlot.Axes.AxisPosition.Left, Minimum = 0 },
new OxyPlot.Axes.DateTimeAxis() { Unit = "Time", Position = OxyPlot.Axes.AxisPosition.Bottom },
},
};
// Change plot model colors.
viewSettings
.ObserveProperty(self => self.PlotStyle).Select(style => style.ObserveProperty(self => self.PlotForeground))
.Switch()
.Subscribe(color_ =>
{
var color = color_.ToOxyColor();
this.CurrentPlotModel.TextColor = color;
this.CurrentPlotModel.PlotAreaBorderColor = color;
foreach (var axis in this.CurrentPlotModel.Axes)
{
axis.MajorGridlineColor = color;
axis.MinorGridlineColor = color;
axis.TextColor = color;
axis.AxislineColor = color;
axis.TicklineColor = color;
}
})
.AddTo(this.disposables);
var totalCurrentSeries = new OxyPlot.Series.LineSeries()
{
Title = "Total Current",
};
// Change plot series color.
viewSettings
.ObserveProperty(self => self.PlotStyle).Select(style => style.ObserveProperty(self => self.SeriesColor))
.Switch()
.Subscribe(color => totalCurrentSeries.Color = color.ToOxyColor())
.AddTo(this.disposables);
this.CurrentPlotModel.Series.Add(totalCurrentSeries);
var currentHistory = this.TotalCurrent
.Select(Value => new { Value, TimeStamp = DateTime.Now })
.ToObservationHistory(Observable.Empty<Unit>(), pair => (DateTime.Now - pair.TimeStamp) >= TimeSpan.FromSeconds(60))
.AddTo(this.disposables);
var livePlotSource = currentHistory.HistoryChanged
.Select(_ =>
{
var history = currentHistory.GetHistory();
return history.Select(pair => new OxyPlot.DataPoint() {X = OxyPlot.Axes.DateTimeAxis.ToDouble(pair.TimeStamp), Y = pair.Value});
});
var historicPlotPeriods = HistoricPlotTypeConditions
.Select(condition => this.CurrentPlotType
.Where(plotType => plotType == condition.PlotType)
.Select(_ => { var now_ = DateTimeOffset.Now; return new { From = condition.CalculateFrom(now_), To = condition.CalculateTo(now_)}; })
)
.ToArray();
var now = DateTimeOffset.Now;
var today = now.Subtract(now.TimeOfDay);
this.PlotFromDate = new ReactiveProperty<DateTimeOffset>(today).AddTo(this.disposables);
this.PlotToDate = new ReactiveProperty<DateTimeOffset>(today).AddTo(this.disposables);
this.PlotFromTime = new ReactiveProperty<TimeSpan>(now.TimeOfDay).AddTo(this.disposables);
this.PlotToTime = new ReactiveProperty<TimeSpan>(now.TimeOfDay).AddTo(this.disposables);
this.UpdatePlotPeriodCommand = new ReactiveCommand().AddTo(this.disposables);
var customPlotPeriod = this.UpdatePlotPeriodCommand
.Select(_ => new {From = this.PlotFromDate.Value.Add(this.PlotFromTime.Value), To = this.PlotToDate.Value.Add(this.PlotToTime.Value)});
var recordedPlotSource = Observable
.Merge(historicPlotPeriods.Concat(new[] {customPlotPeriod}))
.Select(period => powerDistributionLogger.GetPowerDistrubutionByPeriod(period.From, period.To))
.Select(dataPoints => dataPoints.Select(pair => new OxyPlot.DataPoint() {X = OxyPlot.Axes.DateTimeAxis.ToDouble(pair.TimeStamp.LocalDateTime), Y = pair.Consumption}));
var hasDataPointsSubject = new Subject<bool>().AddTo(this.disposables);
var accumulatedCurrentSubject = new Subject<float>().AddTo(this.disposables);
this.AccumulatedCurrent = accumulatedCurrentSubject.ToReadOnlyReactiveProperty().AddTo(this.disposables);
this.IsLive
.Select(isLive => isLive ? livePlotSource : recordedPlotSource)
.Switch()
.ObserveOnUIDispatcher()
.Do(dataPointsEnumerable =>
{
var dataPoints = dataPointsEnumerable.ToArray();
accumulatedCurrentSubject.OnNext(
(float)dataPoints.Pairwise().Sum(dataPoint =>
(dataPoint.OldItem.Y + dataPoint.NewItem.Y) * (OxyPlot.Axes.DateTimeAxis.ToDateTime(dataPoint.NewItem.X) - OxyPlot.Axes.DateTimeAxis.ToDateTime(dataPoint.OldItem.X)).TotalSeconds )
/ 3600.0f);
hasDataPointsSubject.OnNext(dataPoints.Length > 0);
totalCurrentSeries.Points.Clear();
totalCurrentSeries.Points.AddRange(dataPoints);
})
.Do(_ => this.CurrentPlotModel.InvalidatePlot(true))
.Subscribe()
.AddTo(this.disposables);
this.HasDataPoints = hasDataPointsSubject.ToReadOnlyReactiveProperty().AddTo(this.disposables);
}
public DevicePageViewModel(UnconnectedImbleDevice unconnectedDevice)
{
this.Device = Observable.FromAsync(token => unconnectedDevice.Connect(token))
.CatchIgnore((Exception e) => { })
.ToReadOnlyReactiveProperty()
.AddTo(this.disposables);
this.IsConnected = this.Device.Select(device => device != null).ToReadOnlyReactiveProperty().AddTo(this.disposables);
this.DeviceStatus = this.Device
.Where(device => device != null)
.Select(device => device.ObserveProperty(self => self.Status))
.Switch()
.Do(value => Debug.WriteLine(value))
.ObserveOnUIDispatcher()
.ToReadOnlyReactiveProperty()
.AddTo(this.disposables);
this.ReceivedMessage = this.Device
.Where(device => device != null)
.Select(device => Observable.FromEventPattern<DataArrivedEventArgs>(handler => device.DataArrived += handler, handler => device.DataArrived -= handler))
.Switch()
.Select(args => new ReceivedMessageViewModel(args.EventArgs.Data, args.EventArgs.Timestamp))
.OnErrorRetry()
.ToReadOnlyReactiveProperty()
.AddTo(this.disposables);
var notBusyNotifier = new BooleanNotifier(false);
this.Name = new ReactiveProperty<string>("Fuga")
.SetValidateNotifyError(value => value != null && Encoding.UTF8.GetByteCount(value) < 12 ? null : "Input short message")
.AddTo(this.disposables);
this.CanSendCommand = Observable.CombineLatest(
this.DeviceStatus.Select(status => status == ImbleDeviceStatus.Running),
this.Name.ObserveHasErrors,
notBusyNotifier.Do(value => Debug.WriteLine(value)),
(isRunning, hasErrors, notBusy) => isRunning && !hasErrors && notBusy)
.ToReadOnlyReactiveProperty().AddTo(this.disposables);
notBusyNotifier.TurnOn();
this.SendCommand = this.CanSendCommand.ToReactiveCommand().AddTo(this.disposables);
this.SendCommand
.Do(_ => notBusyNotifier.TurnOff())
.Select(_ =>
{
var data = Encoding.UTF8.GetBytes(this.Name.Value);
return Observable.FromAsync(token =>
{
using (var timeoutTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(5)))
using (var linkedTokenSource = CancellationTokenSource.CreateLinkedTokenSource(token, timeoutTokenSource.Token))
{
return this.Device.Value.SendAsync(data, 0, data.Length, linkedTokenSource.Token);
}
})
.Finally(() => notBusyNotifier.TurnOn());
})
.Switch()
.OnErrorRetry((Exception e) => Debug.WriteLine(e))
.Subscribe()
.AddTo(this.disposables);
}
void Start () {
if (component != null)
score = component.score_data;
if (win == null)
win = GameSettingsComponent.working_rules.win_condition;
if (id_text != null || id_text_3d != null){
rx_id_text = LanguageController.controller.rx_load_text("basket_single")
.CombineLatest(rx_score.SelectMany(rx_score.SelectMany(s=>s.rx_id)), (text, id)=>{
return text+" #"+id.ToString();
}).ToReadOnlyReactiveProperty<string>();
rx_id_text.Subscribe((text)=>{
if (id_text != null)
id_text.text = text;
if (id_text_3d != null)
id_text_3d.text = text;
});
}
if (count != null || count_3d != null){
rx_count_text = rx_score
.SelectMany(s=>s.rx_count)
.Select(value=>value.ToString())
.ToReadOnlyReactiveProperty<string>();
rx_count_text.Subscribe((text)=>{
if (count != null)
count.text = text;
if (count_3d != null)
count_3d.text = text;
});
}
if (weight != null || weight_3d != null){
rx_weight_text = rx_score
.SelectMany(s=>s.rx_weight)
.Select(value=>value.ToString("0.00"))
.ToReadOnlyReactiveProperty<string>();
rx_weight_text.Subscribe((text)=>{
if (weight != null)
weight.text = text;
if (weight_3d != null)
weight_3d.text = text;
});
}
condition = rx_score.SelectMany(s=>{
return s.rx_weight.CombineLatest(s.rx_overflow, (w,overflow)=>{
return new UniRx.Tuple<float,bool>(w,overflow);
});
}).CombineLatest (rx_win, (tuple, wc) => {
float w = tuple.Item1;
bool overflow = tuple.Item2;
if (overflow){
return BasketCondition.Overflow;
}
if (wc.basket_weight.is_accept(w)){
return BasketCondition.Accepted;
} else {
if (wc.basket_weight.is_over(w)){
return BasketCondition.Overweight;
} else {
return BasketCondition.Underweight;
}
}
}).ToReadOnlyReactiveProperty<BasketCondition>();
rx_with_win = rx_score.CombineLatest(rx_win, (s, w)=>{
return new UniRx.Tuple<BasketSingleScore, GameSettings.WinCondition>(s,w);
});
rx_with_win.Subscribe((tuple)=>{
if (flat_score_text != null){
ScoreDetailedForm.format_score_text(flat_score_text, tuple.Item2.evaluate_basket_flat(tuple.Item1));
}
if (range_score_text != null){
ScoreDetailedForm.format_score_text(range_score_text, tuple.Item2.evaluate_basket_range(tuple.Item1));
}
if (total_score_text != null){
ScoreDetailedForm.format_score_text(total_score_text, tuple.Item2.evaluate_basket(tuple.Item1));
}
});
rx_tooltip_text = condition.Select(c=>language_keys[c]).ToReadOnlyReactiveProperty<string>();
rx_tooltip_text.Subscribe((key)=>{
if (tooltip != null){
tooltip.key = key;
}
});
rx_sprite = condition.Select(c=>sprites[c]).ToReadOnlyReactiveProperty<Sprite>();
rx_sprite.Subscribe ((sprite) => {
if (icon != null)
icon.sprite = sprite;
if (icon_3d != null)
icon_3d.sprite = sprite;
});
if (opacity != null){
opacity.opacity = off_opacity;
}
}
