public void Reinitialize()
{
//TODO: Change to runner extension
Runner = BehaviorTreeFile.LoadFromJSON(this);
if (spliceNewIntoTree)
{
SpliceIntoRunner();
}
TreeElementUtility.TreeToList(Runner, treeList);
var treeQuery = treeList.AsEnumerable();
TreeSubject = new Subject <BehaviorTreeElement>();
TreeSubject.Subscribe(xr =>
{
var logEntry = new BehaviorLogEntry(
loggerName: BehaviorLogger.Name,
logType: LogType.Log,
timestamp: DateTime.Now,
message: "Ticked!",
behaviorID: xr.ID,
newState: xr.CurrentState,
ticknum: xr.NumberOfTicksReceived.Value,
context: this,
state: xr);
BehaviorLogger.Raw(logEntry);
Debug.Log("xr debug initialize");
}).AddTo(this);
initialized = true;
}
public static BitmapImage CreateImage([CanBeNull] byte[] bytes)
{
if (bytes == null)
{
return(null);
}
try
{
using (var ms = new MemoryStream(bytes))
{
var bitmap = new BitmapImage();
bitmap.BeginInit();
bitmap.CacheOption = BitmapCacheOption.OnLoad;
bitmap.CreateOptions = BitmapCreateOptions.None;
bitmap.StreamSource = ms;
bitmap.EndInit();
bitmap.Freeze();
return(bitmap);
}
}
catch (Exception ex)
{
BehaviorLogger.Log("Image util",
"Fail to load image: " + Environment.NewLine + ex);
return(null);
}
}
private static void InitializeSubsystemsAfterSettingsLoaded()
{
// Logger subsystem initialize
BehaviorLogger.Initialize();
// set parameters for accessing twitter.
Networking.Initialize();
// load key assigns
KeyAssignManager.Initialize();
// load cache manager
CacheStore.Initialize();
}
public void Reinitialize()
{
//TODO: Change to runner extension
Runner = BehaviorTreeFile.LoadFromJSON(this);
if (spliceNewIntoTree)
{
SpliceIntoRunner();
}
List <BehaviorTreeElement> treeList = new List <BehaviorTreeElement>();
TreeElementUtility.TreeToList(Runner, treeList);
var treeQuery = from el in treeList
select el;
TreeStream =
treeQuery
.ToObservable()
.Do(xr =>
{
xr.ObserveEveryValueChanged(x => x.NumberOfTicksReceived)
.Do(x =>
{
var logEntry = new BehaviorLogEntry(
loggerName: BehaviorLogger.Name,
logType: LogType.Log,
timestamp: DateTime.Now,
message: "Ticked!",
behaviorID: xr.ID,
newState: xr.CurrentState,
ticknum: xr.NumberOfTicksReceived.Value,
context: this,
state: xr);
BehaviorLogger.Raw(logEntry);
})
.Subscribe()
.AddTo(this);
});
TreeStream.Subscribe().AddTo(this);
initialized = true;
}
private void AddTrackKeywordCore(string[] tracks)
{
lock (this._trackLocker)
{
foreach (var track in tracks)
{
if (this._trackReferenceCount.ContainsKey(track))
{
this._trackReferenceCount[track]++;
return;
}
BehaviorLogger.Log("TRACK", "add query: " + track);
System.Diagnostics.Debug.WriteLine("◎ track add: " + track);
this._trackReferenceCount[track] = 1;
}
var trackList = new List <string>(tracks);
while (trackList.Count > 0)
{
var tracker = this._receiveManager.GetSuitableKeywordTracker();
if (tracker == null)
{
lock (this._danglingLocker)
{
this._danglingKeywords.AddRange(trackList);
}
this.NotifyDangling();
return;
}
var acceptableCount = UserStreamsReceiver.MaxTrackingKeywordCounts - tracker.TrackKeywords.Count();
var acceptables = trackList.Take(acceptableCount).ToArray();
acceptables.ForEach(track => this._trackResolver[track] = tracker.UserId);
tracker.TrackKeywords = tracker.TrackKeywords.Concat(acceptables).ToArray();
trackList = trackList.Skip(acceptableCount).ToList();
}
}
}
private void RemoveTrackKeywordCore(string track)
{
lock (this._trackLocker)
{
if (!this._trackReferenceCount.ContainsKey(track) || --this._trackReferenceCount[track] > 0)
{
return;
}
this._trackReferenceCount.Remove(track);
if (this._trackResolver.ContainsKey(track))
{
BehaviorLogger.Log("TRACK", "remove query: " + track);
var id = this._trackResolver[track];
this._trackResolver.Remove(track);
var tracker = this._receiveManager.GetKeywordTrackerFromId(id);
tracker.TrackKeywords = tracker.TrackKeywords.Except(new[] { track });
return;
}
}
lock (this._danglingLocker)
{
this._danglingKeywords.Remove(track);
}
}
private void Log(string log)
{
Debug.WriteLine("*USERSTREAMS* " + _account.UnreliableScreenName + ": " + log);
BehaviorLogger.Log("STRM", _account.UnreliableScreenName + ": " + log);
}
private IStreamHandler InitializeHandler()
{
var handler = StreamHandler.Create(StatusInbox.Enqueue,
ex =>
{
BehaviorLogger.Log("U/S", _account.UnreliableScreenName + ":" + ex.ToString());
BackstageModel.RegisterEvent(new StreamDecodeFailedEvent(_account.UnreliableScreenName, ex));
});
handler.AddHandler <StreamDelete>(d => StatusInbox.EnqueueRemoval(d.Id));
handler.AddHandler <StreamDisconnect>(
d => BackstageModel.RegisterEvent(new UserStreamsDisconnectedEvent(_account, d.Reason)));
handler.AddHandler <StreamLimit>(
limit => NotificationService.NotifyLimitationInfoGot(_account, (int)limit.UndeliveredCount));
handler.AddHandler <StreamStatusEvent>(s =>
{
switch (s.Event)
{
case StatusEvents.Unknown:
BackstageModel.RegisterEvent(new UnknownEvent(s.Source, s.RawEvent));
break;
case StatusEvents.Favorite:
NotificationService.NotifyFavorited(s.Source, s.TargetObject);
break;
case StatusEvents.Unfavorite:
NotificationService.NotifyUnfavorited(s.Source, s.TargetObject);
break;
case StatusEvents.FavoriteRetweet:
NotificationService.NotifyFavorited(s.Source, s.TargetObject);
break;
case StatusEvents.RetweetRetweet:
NotificationService.NotifyRetweeted(s.Source, s.TargetObject.RetweetedOriginal, s.TargetObject);
break;
case StatusEvents.Quote:
// do nothing
break;
default:
throw new ArgumentOutOfRangeException();
}
if (s.TargetObject != null)
{
StatusInbox.Enqueue(s.TargetObject);
}
});
handler.AddHandler <StreamUserEvent>(async item =>
{
var active = item.Source.Id == _account.Id;
var passive = item.Target.Id == _account.Id;
var reldata = _account.RelationData;
switch (item.Event)
{
case UserEvents.Unknown:
BackstageModel.RegisterEvent(new UnknownEvent(item.Source, item.RawEvent));
break;
case UserEvents.Follow:
if (active)
{
await reldata.Followings.SetAsync(item.Target.Id, true).ConfigureAwait(false);
}
if (passive)
{
await reldata.Followers.SetAsync(item.Source.Id, true).ConfigureAwait(false);
}
NotificationService.NotifyFollowed(item.Source, item.Target);
break;
case UserEvents.Unfollow:
if (active)
{
await reldata.Followings.SetAsync(item.Target.Id, false).ConfigureAwait(false);
}
if (passive)
{
await reldata.Followers.SetAsync(item.Source.Id, false).ConfigureAwait(false);
}
NotificationService.NotifyUnfollowed(item.Source, item.Target);
break;
case UserEvents.Block:
if (active)
{
await reldata.Followings.SetAsync(item.Target.Id, false).ConfigureAwait(false);
await reldata.Followers.SetAsync(item.Target.Id, false).ConfigureAwait(false);
await reldata.Blockings.SetAsync(item.Target.Id, true).ConfigureAwait(false);
}
if (passive)
{
await reldata.Followers.SetAsync(item.Target.Id, false).ConfigureAwait(false);
}
NotificationService.NotifyBlocked(item.Source, item.Target);
break;
case UserEvents.Unblock:
if (active)
{
await reldata.Blockings.SetAsync(item.Target.Id, false).ConfigureAwait(false);
}
NotificationService.NotifyUnblocked(item.Source, item.Target);
break;
case UserEvents.UserUpdate:
NotificationService.NotifyUserUpdated(item.Source);
break;
case UserEvents.Mute:
if (active)
{
await reldata.Mutes.SetAsync(item.Target.Id, true).ConfigureAwait(false);
}
NotificationService.NotifyBlocked(item.Source, item.Target);
break;
case UserEvents.UnMute:
if (active)
{
await reldata.Mutes.SetAsync(item.Target.Id, false).ConfigureAwait(false);
}
NotificationService.NotifyUnblocked(item.Source, item.Target);
break;
default:
throw new ArgumentOutOfRangeException();
}
});
return(handler);
}
