protected override void OnBattleUnLoad()
{
base.OnBattleUnLoad();
Targets.Clear();
UnitsCDUpdater.Clear();
TargetUnits.Clear();
}
public async Task <Exception> ValidateAsync(IProgress <ProgressEventArgs> progress)
{
Targets.Select(x => {
try
{
x.Dispose();
}
catch { }
return(x);
});
Targets.Clear();
if (Sources.Count == 0)
{
throw new InvalidOperationException("At least one source needs to be defined.");
}
try
{
foreach (var source in Sources)
{
if (source.Checked) //EBORJA
{
await source.PopulateTargets(); //Clear and populate
foreach (var target in source.Targets)
{
target.DeploymentStatusMessage = "";
//await target.TryConnect(CancellationToken.None);
Targets.Add(target);
}
}
}
if (Targets == null || Targets.Count == 0)
{
throw new InvalidOperationException("Cannot start deployment without target.");
}
foreach (var scriptFile in ScriptFiles)
{
if (!scriptFile.IsValid)
{
throw new SqlScriptFileException(scriptFile.ScriptErrors);
}
}
}
catch (Exception ex)
{
Status = DeploymentStatus.Error;
progress?.Report(new ProgressEventArgs(ex));
return(ex);
}
await Task.Delay(100);
progress?.Report(new ProgressEventArgs("Deployment validated!"));
return(null);
}
public void Clear()
{
Targets.Clear();
Proteins.Clear();
RegressionResults = null;
ProcessedState = ProcessingState.NotProcessed;
m_featureCount = 0;
}
protected override void Attack()
{
foreach (var target in Targets)
{
target.enemyHealth.GiveDamage(damage);
}
Targets.Clear();
}
public void Clear()
{
_jumpTable.Clear();
_dynamicTable.Clear();
Targets.Clear();
Dependants.Clear();
Owners.Clear();
}
protected override void Attack()
{
Enemy[] enemies = EnemyInRangeChecker.GetAllEnemiesInRangeFromLocation(Targets[0].gameObject.transform.position, 1);
foreach (var target in enemies)
{
target.enemyHealth.TakeDamage(damage);
}
Targets.Clear();
}
/// <summary>
/// Clears all npcs of the map
/// </summary>
private void ClearNPCS()
{
foreach (Target t in Targets)
{
t.Destroy();
}
Targets.Clear();
NPC.Npcs.Clear();
NPC.HostileNpcs.Clear();
}
protected void btnSendMessage_Click(object sender, EventArgs e)
{
editor.FixContent(RadEditorExtensions.Options.All);
if (String.IsNullOrEmpty(editor.Text) || (Targets.Count == 0))
{
ShowPopup("Debe seleccionar uno o más destinatarios y escribir un mensaje");
}
else if (!cbIntranet.Checked && !cbEmail.Checked && !cbSMS.Checked)
{
ShowPopup("Debe seleccionar uno o más medios de notificación");
}
else
{
List <int> notifications = new List <int>();
if (cbIntranet.Checked)
{
notifications.Add((int)SSOMessageNotification.Intranet);
}
if (cbEmail.Checked)
{
notifications.Add((int)SSOMessageNotification.Email);
}
if (cbSMS.Checked)
{
notifications.Add((int)SSOMessageNotification.SMS);
}
var result = DataContext.sp_SSO_QueueMessage(true, tbSubject.Text, editor.Content, dpExpiresOn.SelectedDate, int.Parse(cbType.SelectedValue), String.Join(",", notifications), String.Join(",", Targets), true, true);
var errors = from r in result.ToList() where r.errorType != 0 select r;
if (errors.Count() == 0)
{
ClosePopup(true);
}
else
{
grid.DataSource = errors;
grid.DataBind();
// Prepara la UI para reintentar el envío
pnlResultados.Visible = true;
pnlEnviar.Visible = false;
var users = (from r in errors select new { r.userId, r.userFullname }).Distinct();
Targets.Clear();
foreach (var user in users)
{
Targets.Add(new ListItem()
{
Name = user.userFullname, TargetType = SSOMessageTarget.User, Target = user.userId.Value
});
}
}
}
}
public void EndTurn()
{
foreach (var Targets in myTargets.Values)
{
Targets.Clear();
}
foreach (var TurnNumber in this.myTurnNumber.Values)
{
TurnNumber.Decrement();
}
}
public override void Parse()
{
Project project = CreateProject();
Targets.Clear();
Properties.Clear();
ParseDefaultTargets(project);
ParseInitialTargets(project);
ParseTargets(project);
ParseProperties(project);
}
internal void CleanUp()
{
RegisterMyGridEvents(false);
foreach (var grid in SubGrids)
{
if (grid == MyGrid)
{
continue;
}
RemSubGrids.Add(grid);
}
AddSubGrids.Clear();
SubGridChanges();
SubGrids.Clear();
Obstructions.Clear();
TargetAis.Clear();
EntitiesInRange.Clear();
Batteries.Clear();
Targets.Clear();
SortedTargets.Clear();
BlockGroups.Clear();
Weapons.Clear();
WeaponsIdx.Clear();
WeaponBase.Clear();
AmmoInventories.Clear();
Inventories.Clear();
LiveProjectile.Clear();
DeadProjectiles.Clear();
ControllingPlayers.Clear();
SourceCount = 0;
BlockCount = 0;
MyOwner = 0;
PointDefense = false;
FadeOut = false;
SupressMouseShoot = false;
OverPowered = false;
UpdatePowerSources = false;
AvailablePowerChanged = false;
PowerIncrease = false;
RequestedPowerChanged = false;
RequestIncrease = false;
DbReady = false;
Focus.Clean();
MyShieldTmp = null;
MyShield = null;
MyPlanetTmp = null;
MyPlanet = null;
TerminalSystem = null;
LastWeaponTerminal = null;
LastTerminal = null;
PowerDistributor = null;
}
public void Reset()
{
Creatures.Clear();
Targets.Clear();
DamageDone.Clear();
DamageTaken.Clear();
Deads.Clear();
CombatCreatureGuid.Reset();
CombatDamageDoneGuid.Reset();
CombatDamageTakenGuid.Reset();
CombatDeadGuid.Reset();
}
private async void UpdateFiles()
{
Targets?.Clear();
IsLoading = true;
await Task.Factory.StartNew(() =>
{
var targets = FileSelection.Files?.Generate()
.Select(f => renameFactory.Create(f));
Targets = new BindableCollection <RenameTargetViewModel>(targets ?? new List <RenameTargetViewModel>());
}, CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default);
IsLoading = false;
}
public async Task PopulateTargets()
{
Targets.Clear();
if (Type == SourceType.Direct)
{
var target = new TargetDatabase(Targets.Count + 1, Name, ConnectionString, ProviderName, CommandTimeout);
Targets.Add(target);
}
else if (Type == SourceType.DataSource)
{
try
{
var result = await this.TryConnect(CancellationToken.None);
if (result)
{
var databases = await this.Context.ExecuteAsync("SELECT * FROM sys.databases");
if (databases != null)
{
foreach (var db in databases)
{
string name = db.name as string;
if (name == null)
{
return;
}
if (!string.IsNullOrEmpty(NameFilter) && !name.Contains(NameFilter))
{
continue;
}
var target = new TargetDatabase(Targets.Count + 1, Name, ConnectionString, ProviderName, CommandTimeout, name);
Targets.Add(target);
}
}
}
}
finally
{
if (Context != null)
{
Context.FinishConnection();
}
}
}
else
{
//throw new InvalidOperationException("Source Type should be Direct or DataSource.");
}
}
private void FillDefaultTargets()
{
Targets.Clear();
foreach (TargetPlatform platform in Enum.GetValues(typeof(TargetPlatform)))
{
Targets.Add(new Target(
name: Enum.GetName(typeof(TargetPlatform), platform),
projectPath: GetDefaultProjectSolutionPath(platform),
cleanBeforeBuild: false,
platform: platform,
configuration: BuildConfiguration.Release
));
}
}
private void ChooseTarget_Click(object sender, RoutedEventArgs e)
{
if (!String.IsNullOrEmpty(TargetTextBox.Text))
{
MainTarget = TargetTextBox.Text;
}
Targets.Clear();
Targets.Push(MainTarget);
Logger.Info("Главная цель: " + MainTarget);
CurrentAnswer.Key = Rules.FirstOrDefault(x => x.Target.Key == MainTarget).Properties.First().Key;
Targets.Push(CurrentAnswer.Key);
Logger.Info(CurrentAnswer.Key + " помещена в стек целей");
PropertyKeyLabel.Content = Char.ToUpper(CurrentAnswer.Key[0]) + CurrentAnswer.Key.Substring(1) + ":";
}
public async Task ValidateAsync(IProgress <ProgressEventArgs> progress)
{
Targets.Clear();
if (Sources.Count == 0)
{
throw new InvalidOperationException("At least one source needs to be defined.");
}
try
{
foreach (var source in Sources)
{
if (source.Targets.Count == 0)
{
await source.PopulateTargets();
}
foreach (var target in source.Targets)
{
target.DeploymentStatus = "";
Targets.Add(target);
}
}
foreach (var scriptFile in ScriptFiles)
{
foreach (var script in scriptFile.Scripts)
{
var errors = script.Validate();
script.IsValid = errors == null || (errors != null && errors.Count > 0);
}
progress.Report(new ProgressEventArgs(scriptFile));
}
}
catch (Exception ex)
{
progress.Report(new ProgressEventArgs(ex));
}
await Task.Delay(100);
progress.Report(new ProgressEventArgs("Deployment validated!"));
if (Targets == null || Targets.Count == 0)
{
throw new InvalidOperationException("Cannot start deployment without target.");
}
return;
}
internal void Select(TEntityAction entityAction)
{
entityAction.ThrowNull();
Targets.Clear();
var gadgets = new Collection <TActionComponent> ();
TActionConverter.Collection(TCategory.Target, gadgets, entityAction);
foreach (var component in gadgets)
{
Targets.Add(component.Models.GadgetTargetModel);
}
}
public void Clear()
{
IsUpdate = false;
VoiceType = PlayerInformation.Info.PType;
BehType = BehaviorType.None;
Targets.Clear();
Damages.Clear();
Abnormals.Clear();
IsHit.Clear();
//IsDeath.Clear();
KillList.Clear();
Effects.Clear();
Sounds.Clear();
Voices.Clear();
Messages.Clear();
}
public void Parse()
{
Targets.Clear();
SetCommands.Clear();
allCommands.Clear();
blocks.Clear();
Children.Clear();
projectName = "";
contentFile = new TextFile(file);
foreach (Match m in ReadNextCommand())
{
try {
ParseCommand(m);
} catch (Exception ex) {
throw new Exception(string.Format("Exception: {0}\nFile: {1}", ex.Message, file));
}
}
VariableManager = new CMakeVariableManager(this);
foreach (CMakeCommand command in targetCommands)
{
CMakeTarget target = new CMakeTarget(command, this);
if (!target.IsAliasOrImported)
{
Targets.Add(string.Format("{0}:{1}", target.Name, command.Offset), target);
target.PrintTarget();
}
}
targetCommands.Clear();
foreach (CMakeFileFormat f in Children.Values)
{
targets = targets.Concat(f.Targets).ToDictionary(x => x.Key, x => x.Value);
}
if (blocks.Count > 0)
{
CMakeCommand c = blocks.Pop();
throw new Exception(string.Format("Unmatched block command '{0}' in file '{1}' offset '{2}'.", c.Name, file, c.Offset));
}
LoggingService.LogDebug("CMake file '{0}' is Loaded.", file);
}
public override void Loop(MovingObject pShip)
{
InputStates.Clear();
if ((TargetShip.Position - pShip.Position).Length > 16) // chase the player ship if it gets too far
{
Targets.Clear();
Targets.Add(TargetShip.Position);
}
else if (Targets.Count == 0) // face the same way as the player ship once you reach it
{
InputStates.Left = Methods.AngleDifference(pShip.Angle, TargetShip.Angle) < -15;
InputStates.Right = Methods.AngleDifference(pShip.Angle, TargetShip.Angle) > 15;
}
InputStates.Add(MoveToNextTarget(pShip));
InputStates.DetectPresses();
}
private void SelectTargets()
{
Targets.Clear();
foreach (var segmentData in Tool.Data.SegmentEndDatas)
{
if (segmentData.IsUntouchable)
{
continue;
}
if (!IsSelectedSide)
{
Targets.Add(segmentData[SideType.Left]);
Targets.Add(segmentData[SideType.Right]);
}
else if (segmentData != SelectedSide.Data && Tool.Data.Style.SupportShift.IsSet(SupportOption.Individually))
{
Targets.Add(segmentData[SelectedSide.Type.Invert()]);
}
}
if (IsSelectedSide)
{
if (Tool.Data.Style.SupportShift.IsSet(SupportOption.Individually))
{
if (SingletonManager <Manager> .Instance.GetSegmentData(SelectedSide.Data.Id, !SelectedSide.Data.IsStartNode) is SegmentEndData data)
{
Targets.Add(data[SelectedSide.Type.Invert()]);
}
}
else if (!Tool.Data.IsJunction)
{
foreach (var segmentEnd in Tool.Data.SegmentEndDatas)
{
if (SingletonManager <Manager> .Instance.GetSegmentData(segmentEnd.Id, !segmentEnd.IsStartNode) is SegmentEndData otherData)
{
Targets.Add(otherData[segmentEnd == SelectedSide.Data ? SelectedSide.Type.Invert() : SelectedSide.Type]);
}
}
}
}
}
public override void Parse()
{
Project project = CreateProject();
XmlDocument doc = project.Document;
Targets.Clear();
Properties.Clear();
Description = string.Empty;
Name = project.ProjectName != String.Empty ? project.ProjectName : _file.Name;
_defaultTargetName = project.DefaultTargetName;
ParseDescription(doc);
ParseBaseDir(project);
ParseTargets(doc);
ParseProperties(project, doc);
ParseNonPropertyProperties(project, doc);
FollowIncludes(project, doc);
}
public void ClearIfNeeded()
{
if (_jumpTable.Count == 0 && _dynamicTable.Count == 0 &&
Targets.Count == 0 && Dependants.Count == 0 && Owners.Count == 0)
{
return;
}
_jumpTable.Clear();
_jumpTable.TrimExcess();
_dynamicTable.Clear();
_dynamicTable.TrimExcess();
Targets.Clear();
Targets.TrimExcess();
Dependants.Clear();
Dependants.TrimExcess();
Owners.Clear();
Owners.TrimExcess();
}
public bool LoadFromFile(string path)
{
var polling = m_polling.IsRunning;
m_polling.Stop();
Data data = null;
try
{
using (var reader = new StreamReader(path))
{
var json = reader.ReadToEnd();
data = JsonConvert.DeserializeObject <Data>(json);
}
}
catch (Exception)
{
return(false);
}
if (data == null)
{
return(false);
}
TargetRootPath = data.TargetRootPath;
Targets.Clear();
foreach (var target in data.CopyTargets)
{
var newTarget = new CopyTarget()
{
SrcFilePath = target.Src, DstFilePath = target.Dst
};
newTarget.RefreshTimestamp();
Targets.Add(newTarget);
}
if (polling)
{
m_polling.Start();
}
return(true);
}
private void gridTransferPool_DataBindingComplete(object sender, DataGridViewBindingCompleteEventArgs e)
{
if (Targets.Count > 0)
{
LogManager.Instance.Message($"==> {GetTargetedProjectInfo()}");
if (OnTargeted != null)
{
OnTargeted.Invoke(sender, e);
}
}
else
{
if (OnDeTargeted != null)
{
OnDeTargeted.Invoke(sender, e);
}
}
Targets.Clear();
}
void RevalidateAllTargets()
{
// clear original target set
Targets.Clear();
// find all SpellTargetCollections to revalidate
var uniqueTargets = new HashSet <SpellTargetCollection>();
foreach (var handler in Handlers)
{
uniqueTargets.Add(handler.Targets);
}
// remove from each collection
foreach (var targets in uniqueTargets)
{
// revalidate and then re-add to unique target set
targets.RevalidateAll();
Targets.AddRange(targets);
}
}
public void Initialize(JumpTable jumpTable)
{
Targets.Clear();
foreach (ulong guestAddress in jumpTable.Targets.Keys)
{
Targets.Add(guestAddress);
}
Dependants.Clear();
foreach (var kv in jumpTable.Dependants)
{
Dependants.Add(kv.Key, new List <int>(kv.Value));
}
Owners.Clear();
foreach (var kv in jumpTable.Owners)
{
Owners.Add(kv.Key, new List <int>(kv.Value));
}
}
private void ClearData()
{
HostItems.Clear();
Targets.Clear();
}
private void ClearTargetsCommand()
{
Targets.Clear();
}
