public virtual bool Remove(Drawable drawable, bool dispose = true)
{
if (drawable == null)
{
return(false);
}
if (AddTarget != this)
{
return(AddTarget.Remove(drawable, dispose));
}
bool result = children.Remove(drawable);
drawable.Parent = null;
if (dispose && drawable.IsDisposable)
{
drawable.Dispose();
}
else
{
drawable.Invalidate();
}
return(result);
}
public void AddTarget(AddTarget rpc)
{
if (_targets.Find(t => t.target.networkID == rpc.targetID) == null)
{
_targets.Add(new TargetDamagePair((AliveEntity)NetworkProgramUnity.currentInstance.signallersByID[rpc.targetID], 0));
_targets.Sort();
}
}
public void AddTarget(AliveEntity target)
{
if (isServer)
{
var rpc = new AddTarget(target.networkID);
AddTarget(rpc);
Send(rpc);
}
}
public virtual Drawable Add(Drawable drawable)
{
if (drawable == null)
{
return(null);
}
if (AddTarget == this || AddTarget == drawable)
{
return(AddTopLevel(drawable));
}
return(AddTarget.Add(drawable));
}
public virtual void Clear(bool dispose = true)
{
if (AddTarget != null && AddTarget != this)
{
AddTarget.Clear(dispose);
return;
}
foreach (Drawable t in children)
{
if (dispose)
{
t.Dispose();
}
t.Parent = null;
}
children.Clear();
Invalidate(Invalidation.Position | Invalidation.SizeInParentSpace);
}
public override Task <SumValue> Add(AddTarget target, ServerCallContext context)
{
return(Task.FromResult(new SumValue {
Sum = target.V1 + target.V2
}));
}
partial void InitializeAutoCombat()
{
var game = Locator.Current.GetService <GameModel>();
SearchBehavior = AutoCombatSearchBehavior.SearchAndDestroy;
NearbyMonsters = new ReactiveList <string>();
TargetList = new ReactiveList <string>();
TargetList.CountChanged.Subscribe(_ => TargetList.Sort());
var canRefreshNearbyMonsters = game.WhenAnyValue(x => x.Status, x => x == GameStatus.LoggedIn);
RefreshNearbyMonsters = ReactiveCommand.CreateAsyncTask(canRefreshNearbyMonsters, async _ =>
{
var names = await Task.Run(() =>
{
return(new NpcContainer(game.Game).GetItems()
.Where(x => x.NpcType.Value == NpcType.Monster)
.Select(x => x.Name.Value.Value)
.Distinct());
});
return(names);
});
RefreshNearbyMonsters.Subscribe(results =>
{
NearbyMonsters.Clear();
foreach (var item in results)
{
NearbyMonsters.Add(item);
}
});
AddTarget = ReactiveCommand.Create();
AddTarget.Subscribe(x =>
{
var name = (string)x;
if (!TargetList.Contains(name))
{
TargetList.Add(name);
}
});
var canClearTargetList = TargetList.CountChanged.Select(x => x != 0);
ClearTargetList = ReactiveCommand.Create(canClearTargetList);
ClearTargetList.Subscribe(_ => TargetList.Clear());
RemoveTarget = ReactiveCommand.Create();
RemoveTarget.Subscribe(name => TargetList.Remove((string)name));
#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
var dialogService = Locator.Current.GetService <IDialogService>();
var canExportTargetList = TargetList.CountChanged.Select(x => x != 0);
ExportTargetList = ReactiveCommand.CreateAsyncTask(canExportTargetList, async _ =>
{
var dialog = new SaveFileDialog()
{
Filter = TargetListFileFormat
};
if (dialog.ShowDialog() == false)
{
return;
}
var serializer = new XmlSerializer(typeof(List <string>));
using (var stream = dialog.OpenFile())
serializer.Serialize(stream, TargetList.ToList());
});
ExportTargetList.ThrownExceptions.Subscribe(async e => await dialogService.DisplayExceptionAsyncOn <SettingViewModel>(e));
ImportTargetList = ReactiveCommand.CreateAsyncTask(async _ =>
{
var dialog = new OpenFileDialog()
{
Filter = TargetListFileFormat
};
if (dialog.ShowDialog() == false)
{
return;
}
if (TargetList.Any())
{
var result = await dialogService.ShowMessageDialogAsyncOn <SettingViewModel>("Confirmation",
"Do you wish to merge the current list with this list?",
"Merge them",
"Keep new list",
"Cancel, keep current list");
switch (result)
{
case DialogResult.Affirmative:
break;
case DialogResult.Negative:
TargetList.Clear();
break;
case DialogResult.FirstAuxiliary:
return;
}
}
var serializer = new XmlSerializer(typeof(List <string>));
using (var stream = dialog.OpenFile())
{
var list = serializer.Deserialize(stream) as List <string>;
foreach (var item in list)
{
if (!TargetList.Contains(item))
{
TargetList.Add(item);
}
}
}
});
ImportTargetList.ThrownExceptions.Subscribe(async e => await dialogService.DisplayExceptionAsyncOn <SettingViewModel>(e));
#pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
}
