public object GetValue(string valueName)
{
if (rxCurrentSnapShot.ContainsKey(valueName))
{
return(rxCurrentSnapShot[valueName]);
}
else
{
Debug.LogError("WARNING: you are trying to browse to a unknown value-name:" + valueName + "! Possible values :" + rxCurrentSnapShot.Keys.Aggregate((i, j) => i + " " + j));
return(null);
}
}
public Dictionary <int, T> Regist(Dictionary <int, T> records)
{
var refRecords = new Dictionary <int, T>();
foreach (var record in records)
{
if (!cacheRecords.ContainsKey(record.Key))
{
cacheRecords[record.Key] = record.Value;
}
refRecords[record.Key] = cacheRecords[record.Key];
}
return(refRecords);
}
public override MemoryBrowser GetBrowser(string id)
{
if (browsers.ContainsKey(id))
{
return(browsers[id]);
}
else
{
UnityEngine.Debug.LogError("Tried to access unknown MemoryBrowser with id:" + id);
return(null);
}
}
public void TestAddingAndRemoving()
{
// New dictionary
ReactiveDictionary <string, int> dict = new ReactiveDictionary <string, int>();
Assert.IsFalse(dict.TryGetValue("A", out int _));
Assert.AreEqual(0, dict.Count);
// Add {A, 1}
dict["A"] = 1;
Assert.IsTrue(dict.TryGetValue("A", out int value));
Assert.AreEqual(1, value);
Assert.AreEqual(1, dict.Count);
Assert.IsTrue(dict.SequenceEqual(new[]
{
new KeyValuePair <string, int>("A", 1)
}));
Assert.IsTrue(dict.Keys.SequenceEqual(new[] { "A" }));
Assert.IsTrue(dict.Values.SequenceEqual(new[] { 1 }));
// Add {B, 1}
dict.Add("B", 2);
Assert.AreEqual(2, dict["B"]);
Assert.AreEqual(2, dict.Count);
// Remove A
Assert.IsTrue(dict.Remove("A"));
Assert.IsFalse(dict.TryGetValue("A", out int _));
Assert.AreEqual(1, dict.Count);
Assert.IsTrue(dict.ContainsKey("B"));
Assert.IsFalse(dict.ContainsKey("A"));
Assert.IsFalse(dict.ContainsKey("Z"));
// Clear
dict.Clear();
Assert.AreEqual(0, dict.Count);
Assert.IsTrue(dict.SequenceEqual(new KeyValuePair <string, int> [0]));
}
public void SelectTeam(int clientId, int lane, int teamIdx)
{
if (!PlayerSequences.ContainsKey(lane))
{
PlayerSequences.Add(lane, new PlayerSquenceReactiveProperty());
GameObject actor = Instantiate(Teams[teamIdx].actor, Vector3.zero,
Quaternion.identity, Players[lane].transform);
RuntimeAnimatorController animatorController = Teams[teamIdx].isTightEnd ? TightEndController : WideController;
Players[lane]
.Initialize(lane, actor, IdleController, animatorController, Teams[teamIdx].actorHeight, PlayerSequences[lane]);
}
}
public static ManagedReactiveDictionary <TKey, TElement> ToManagedReactiveDictionary <TSource, TKey, TElement>(
this IObservable <IEnumerable <TSource> > source,
Func <TSource, TKey> keySelector,
Func <TSource, TElement> elementFactory,
Action <TElement> elementDisposer)
{
var dict = new ReactiveDictionary <TKey, TElement>();
var newDict = new Dictionary <TKey, TSource>();
var keysToRemove = new List <TKey>();
var subscription = source
.Subscribe(items =>
{
foreach (var item in items)
{
newDict.Add(keySelector.Invoke(item), item);
}
foreach (var kvp in dict)
{
if (!newDict.ContainsKey(kvp.Key))
{
keysToRemove.Add(kvp.Key);
}
}
foreach (var key in keysToRemove)
{
var element = dict[key];
dict.Remove(key);
elementDisposer.Invoke(element);
}
foreach (var kvp in newDict)
{
if (!dict.ContainsKey(kvp.Key))
{
dict.Add(kvp.Key, elementFactory.Invoke(kvp.Value));
}
}
newDict.Clear();
keysToRemove.Clear();
});
return(new ManagedReactiveDictionary <TKey, TElement>(dict,
StableCompositeDisposable.Create(dict, subscription)));
}
public EasyWriter(string path)
{
FilePath = path;
#if UNITY_EDITOR
var directoryName = Path.GetDirectoryName(path);
if (!Directory.Exists(directoryName))
{
Directory.CreateDirectory(directoryName);
}
#endif
if (dict == null)
{
dict = new ReactiveDictionary <string, ReactiveWriter>();
}
if (!dict.ContainsKey(path))
{
DeserializeAsync <EasyDictionary <string, EasyObject> >(path).Subscribe(o =>
{
dict.Add(path, new ReactiveWriter(path, o));
});
}
}
private BubbleViewModel GetBubble(Vector2Int gridPos)
{
return(_bubbleViewModels.ContainsKey(gridPos) ? _bubbleViewModels[gridPos] : null);
}
public override void OnEnable()
{
base.OnEnable();
ApplyChanges();
DebugCanvas.OnAdd().Subscribe(entity =>
{
var debugCanvas = entity.GetComponent <DebugCanvas>();
var canvas = entity.GetComponent <Canvas>();
var canvasScaler = entity.GetComponent <CanvasScaler>();
canvas.renderMode = RenderMode.ScreenSpaceOverlay;
canvas.sortingOrder = SortingOrder;
canvasScaler.matchWidthOrHeight = 1;
canvasScaler.uiScaleMode = CanvasScaler.ScaleMode.ScaleWithScreenSize;
DebugView.OnAdd().Subscribe(viewEntity =>
{
View = viewEntity.GetComponent <DebugView>();
View.EscButton.OnPointerClickAsObservable().Select(_ => false)
.Merge(Setting.ShowOnUGUI.DistinctUntilChanged())
.Subscribe(b =>
{
View.DebugPanel.gameObject.SetActive(b);
}).AddTo(this.Disposer).AddTo(debugCanvas.Disposer).AddTo(View.Disposer);
Console.RegisterCommand("Debug", "Show debug console message on UGui.", "Debug [On/Off]", (args) =>
{
bool result = args.Length == 0 ? true : args.Any(m =>
{
string cmd = m.Trim().ToLower();
return(cmd == "on" || cmd == "true");
});
View.DebugPanel.gameObject.SetActive(result);
return(string.Format("Debug message show on UGui is {0}", result == true ? "On" : "Off"));
});
View.ClearButton.OnPointerClickAsObservable().Select(_ => true)
.Merge(ClearCommand.OnClearAsObservable())
.Subscribe(_ =>
{
while (View.Logs.Count > 0)
{
GameObject.Destroy(View.Logs[0].GetComponent <ViewComponent>().Transforms[0].gameObject);
View.Logs.RemoveAt(0);
}
}).AddTo(this.Disposer).AddTo(debugCanvas.Disposer).AddTo(View.Disposer);
View.CollapseToggle.OnPointerClickAsObservable().Subscribe(_ =>
{
Setting.DebugView.Collapse.Value = View.CollapseToggle.isOn;
}).AddTo(this.Disposer).AddTo(debugCanvas.Disposer).AddTo(View.Disposer);
View.LogToggle.OnPointerClickAsObservable().Subscribe(_ =>
{
Setting.DebugView.Log.Value = View.LogToggle.isOn;
}).AddTo(this.Disposer).AddTo(debugCanvas.Disposer).AddTo(View.Disposer);
View.WarningToggle.OnPointerClickAsObservable().Subscribe(_ =>
{
Setting.DebugView.Warning.Value = View.WarningToggle.isOn;
}).AddTo(this.Disposer).AddTo(debugCanvas.Disposer).AddTo(View.Disposer);
View.ErrorToggle.OnPointerClickAsObservable().Subscribe(_ =>
{
Setting.DebugView.Error.Value = View.ErrorToggle.isOn;
}).AddTo(this.Disposer).AddTo(debugCanvas.Disposer).AddTo(View.Disposer);
var onCollapse = Setting.DebugView.Collapse.DistinctUntilChanged();
var onLog = Setting.DebugView.Log.DistinctUntilChanged();
var onWarning = Setting.DebugView.Warning.DistinctUntilChanged();
var onError = Setting.DebugView.Error.DistinctUntilChanged();
var onAdd = View.Logs.ObserveAdd().Select(_ => true);
var onRemove = View.Logs.ObserveRemove().Select(_ => true);
onCollapse.Merge(onLog).Merge(onWarning).Merge(onError).Merge(onAdd).Merge(onRemove).Subscribe(_ =>
{
Debugger.History.Clear();
var list = new ReactiveDictionary <string, DebugLog>();
for (int i = 0; i < View.Logs.Count; i++)
{
var view = View.Logs[i].GetComponent <ViewComponent>();
var log = View.Logs[i].GetComponent <DebugLog>();
if (i % 2 == 0)
{
log.MessageBackground.color = MBGColor0;
log.CountBackground.color = CBGColor0;
}
else
{
log.MessageBackground.color = MBGColor1;
log.CountBackground.color = CBGColor1;
}
if (Setting.DebugView.Collapse.Value)
{
if (list.ContainsKey(log.Message.Value))
{
view.Transforms[0].gameObject.SetActive(false);
var t = list[log.Message.Value];
t.Count.Value++;
list[log.Message.Value] = t;
}
else
{
view.Transforms[0].gameObject.SetActive(true);
log.Count.Value = 1;
list.Add(log.Message.Value, log);
}
}
else
{
view.Transforms[0].gameObject.SetActive(true);
log.Count.Value = 1;
}
if (log.LogType == LogType.Log && !Setting.DebugView.Log.Value)
{
view.Transforms[0].gameObject.SetActive(false);
}
else if (log.LogType == LogType.Warning && !Setting.DebugView.Warning.Value)
{
view.Transforms[0].gameObject.SetActive(false);
}
else if (log.LogType == LogType.Error && !Setting.DebugView.Error.Value)
{
view.Transforms[0].gameObject.SetActive(false);
}
if (view.Transforms[0].gameObject.activeSelf)
{
string str;
if (log.LogType == LogType.Warning)
{
str = string.Format(HtmlWarningStyle, log.Message.Value);
}
else if (log.LogType == LogType.Error)
{
str = string.Format(HtmlErrorStyle, log.Message.Value);
}
else
{
str = string.Format(HtmlLogStyle, log.Message.Value);
}
Debugger.History.Add(str);
}
}
var activeLogs = View.Logs.Where(e => e.GetComponent <ViewComponent>().Transforms[0].gameObject.activeSelf).Select(e => e.GetComponent <DebugLog>().LogType);
View.LogText.text = string.Format(LogCount, activeLogs.Where(e => e == LogType.Log).Count());
View.WarningText.text = string.Format(WarningCount, activeLogs.Where(e => e == LogType.Warning).Count());
View.ErrorText.text = string.Format(ErrorCount, activeLogs.Where(e => e == LogType.Error).Count());
View.CollapseToggle.isOn = Setting.DebugView.Collapse.Value;
View.LogToggle.isOn = Setting.DebugView.Log.Value;
View.WarningToggle.isOn = Setting.DebugView.Warning.Value;
View.ErrorToggle.isOn = Setting.DebugView.Error.Value;
}).AddTo(this.Disposer).AddTo(debugCanvas.Disposer).AddTo(View.Disposer);
View.SelectedLog.DistinctUntilChanged().Subscribe(log =>
{
if (log == null)
{
View.StackTraceText.text = Empty;
}
else
{
if (log.LogType == LogType.Warning)
{
View.StackTraceText.text = string.Format(WarningStyle, View.Size, log.Message.Value);
}
else if (log.LogType == LogType.Error)
{
View.StackTraceText.text = string.Format(ErrorStyle, View.Size, log.Message.Value);
}
else
{
View.StackTraceText.text = string.Format(LogStyle, View.Size, log.Message.Value);
}
}
Observable.EveryEndOfFrame().FirstOrDefault().Subscribe(_ =>
{
View.StackTraceScrollbar.value = 1;
}).AddTo(this.Disposer).AddTo(View.Disposer);
}).AddTo(this.Disposer).AddTo(View.Disposer);
View.DebugPanel.gameObject.SetActive(false);
}).AddTo(this.Disposer).AddTo(debugCanvas.Disposer);
}).AddTo(this.Disposer);
DebugLog.OnAdd().Subscribe(entity =>
{
var view = entity.GetComponent <ViewComponent>();
var log = entity.GetComponent <DebugLog>();
log.Message.DistinctUntilChanged().Subscribe(message =>
{
if (log.LogType == LogType.Warning)
{
message = string.Format(WarningStyle, View.Size, message);
}
else if (log.LogType == LogType.Error)
{
message = string.Format(ErrorStyle, View.Size, message);
}
else
{
message = string.Format(LogStyle, View.Size, message);
}
log.MessageText.text = message;
}).AddTo(this.Disposer).AddTo(log.Disposer);
log.Count.DistinctUntilChanged().Subscribe(count =>
{
log.CountText.text = count.ToString();
}).AddTo(this.Disposer).AddTo(log.Disposer);
view.Transforms[0].OnPointerClickAsObservable().Subscribe(_ =>
{
View.SelectedLog.Value = log;
}).AddTo(this.Disposer).AddTo(View.Disposer).AddTo(log.Disposer);
}).AddTo(this.Disposer);
Debugger.RegisterPreMatchingLayer(OnPreMatchingLayerInEditor);
Application.logMessageReceived += HandleLog;
}