public Task ModifyThreatListAsync(ThreatList threatList, IEnumerable <string> threatSha256HashPrefixes, IEnumerable <int> threatIndices, CancellationToken cancellationToken)
{
this.ThrowIfDisposed();
Guard.ThrowIf(nameof(threatSha256HashPrefixes), threatSha256HashPrefixes).Null();
Guard.ThrowIf(nameof(threatIndices), threatIndices).Null();
lock (this._lock) {
var newSha256HashPrefixes = new List <string>();
this._threats.TryGetValue(threatList.Descriptor, out var threats);
if (threats != null)
{
// ...
//
// Filtering the threat threat requires it to be presorted.
var newIndices = Enumerable.Range(0, threats.Count).Except(threatIndices);
foreach (var newIndex in newIndices)
{
var threat = threats[newIndex];
newSha256HashPrefixes.Add(threat);
}
}
// ...
//
// We need to sort the threat list so that it can later be searched.
newSha256HashPrefixes.AddRange(threatSha256HashPrefixes);
newSha256HashPrefixes.Sort();
this._threatLists[threatList.Descriptor] = threatList;
this._threats[threatList.Descriptor] = newSha256HashPrefixes;
return(Task.CompletedTask);
}
}
public ThreatList investigate(int[,] board,
Coordinate move,
int attacker,
bool create)
{
this.board = board;
this.attacker = attacker;
this.create = create;
bool reset = false;
if (board[move.X, move.Y] == attacker * -1)
{
throw new Exception();
}
if (board[move.X, move.Y] != attacker)
{
board[move.X, move.Y] = attacker;
reset = true;
}
ThreatList res = SearchBoards(move);
if (reset == true)
{
board[move.X, move.Y] = 0;
}
return(res);
}
/// <summary>
/// Store a Threat List Asynchronously.
/// </summary>
/// <param name="threatList">
/// A <see cref="ThreatList" /> to store.
/// </param>
/// <param name="threatSha256HashPrefixes">
/// A collection of SHA256 hash prefixes, formatted as hexadecimal encoded strings, identifying the threats
/// associated with <paramref name="threatList" /> and should be stored.
/// </param>
/// <param name="cancellationToken">
/// A cancellation token to cancel the asynchronous operation with.
/// </param>
/// <returns>
/// A task representing the asynchronous operation.
/// </returns>
/// <exception cref="Gee.External.Browsing.Databases.BrowsingDatabaseException">
/// Thrown if a database error occurs.
/// </exception>
/// <exception cref="System.ArgumentNullException">
/// Thrown if <paramref name="threatList" /> is a null reference, or if
/// <paramref name="threatSha256HashPrefixes" /> is a null reference.
/// </exception>
/// <exception cref="System.ObjectDisposedException">
/// Thrown if the object is disposed.
/// </exception>
/// <exception cref="System.OperationCanceledException">
/// Thrown if the asynchronous operation is cancelled.
/// </exception>
public async Task StoreThreatListAsync(ThreatList threatList, IEnumerable <string> threatSha256HashPrefixes, CancellationToken cancellationToken)
{
this.ThrowIfDisposed();
try {
var storeThreatListTask = this._database.StoreThreatListAsync(threatList, threatSha256HashPrefixes, cancellationToken);
await storeThreatListTask.ConfigureAwait(false);
}
catch (ArgumentNullException) {
throw;
}
catch (BrowsingDatabaseException) {
throw;
}
catch (ObjectDisposedException) {
this.Dispose();
throw;
}
catch (OperationCanceledException) {
throw;
}
catch (Exception ex) {
const string detailMessage = "A threat list could not be stored.";
throw new BrowsingDatabaseException(detailMessage, ex);
}
}
public static void Main()
{
int[,] board = new int[, ] {
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
};
board = Flip(board);
ThreatSearcher searcher = new ThreatSearcher();
ThreatList threats = searcher.investigate(board, new Coordinate(0, 13), 1);
foreach (Threat t in threats)
{
Console.WriteLine(t.ToString());
}
}
/** Add threats from from into into if they are not contained yet.
*
* @returns ArrayList<Threat> List of the added threats.
*/
private ThreatList Merge(ThreatList into, ThreatList from)
{
ThreatList res = new ThreatList();
foreach (Threat t in from)
{
// check for every t if it is already in into-list
bool alreadyin = false;
foreach (Threat ct in into)
{
alreadyin = true;
if (ct.category == t.category && ct.fields.Count == t.fields.Count)
{
for (int i = 0; i < ct.fields.Count; ++i)
{
alreadyin = alreadyin &&
((((Coordinate)(ct.fields[i])).X == ((Coordinate)(t.fields[i])).X) &&
(((Coordinate)(ct.fields[i])).Y == ((Coordinate)(t.fields[i])).Y));
}
}
else
{
alreadyin = false;
}
}
if (alreadyin == false)
{
into.Add(t);
res.Add(t);
}
}
return(res);
}
/// <summary>
/// Set Retrieved Threat List.
/// </summary>
/// <param name="value">
/// The <see cref="ThreatList" /> retrieved from the Google Safe Browsing API.
/// </param>
/// <returns>
/// This threat list update result builder.
/// </returns>
/// <exception cref="System.ArgumentNullException">
/// Thrown if <paramref name="value" /> is a null reference.
/// </exception>
public ThreatListUpdateResultBuilder SetRetrievedThreatList(ThreatList value)
{
Guard.ThrowIf(nameof(value), value).Null();
this.RetrievedThreatList = value;
return(this);
}
/// <summary>
/// Create a Threat List Synchronization Completed Event Arguments.
/// </summary>
/// <param name="synchronizedThreatList">
/// The <see cref="ThreatList" /> that was synchronized successfully.
/// </param>
/// <param name="synchronizationStartDate">
/// The date, in Coordinated Universal Time (UTC), the synchronization operation for
/// <paramref name="synchronizedThreatList" /> started. If the date is not expressed in UTC, it is
/// converted to it.
/// </param>
/// <param name="synchronizationCompletionDate">
/// The date, in Coordinated Universal Time (UTC), the synchronization operation for
/// <paramref name="synchronizedThreatList" /> completed. If the date is not expressed in UTC, it is
/// converted to it.
/// </param>
/// <exception cref="System.ArgumentNullException">
/// Thrown if <paramref name="synchronizedThreatList" /> is a null reference.
/// </exception>
internal ThreatListSynchronizationCompletedEventArgs(ThreatList synchronizedThreatList, DateTime synchronizationStartDate, DateTime synchronizationCompletionDate)
{
Guard.ThrowIf(nameof(synchronizedThreatList), synchronizedThreatList).Null();
this.SynchronizationCompletionDate = synchronizationCompletionDate;
this.SynchronizationStartDate = synchronizationStartDate;
this.SynchronizedThreatList = synchronizedThreatList;
}
public override object Clone()
{
ThreatList tl = new ThreatList ();
for (int n = 0 ; n < Count ; ++n)
tl.Add (((Threat) this[n]).Clone ());
return (tl);
}
public Task StoreThreatListAsync(ThreatList threatList, IEnumerable <string> threatSha256HashPrefixes, CancellationToken cancellationToken)
{
this.ThrowIfDisposed();
Func <Task> resiliencyPolicyAction = () => this._database.StoreThreatListAsync(threatList, threatSha256HashPrefixes, cancellationToken);
var executeResiliencyPolicyTask = this.ExecuteResiliencyPolicyAsync(resiliencyPolicyAction);
return(executeResiliencyPolicyTask);
}
/// <summary>
/// Create a Threat List Synchronization Failed Event Arguments.
/// </summary>
/// <param name="skippedThreatList">
/// The <see cref="ThreatList" /> that failed to synchronize and was skipped.
/// </param>
/// <param name="synchronizationStartDate">
/// The date, in Coordinated Universal Time (UTC), the synchronization operation for
/// <paramref name="skippedThreatList" /> started. If the date is not expressed in UTC, it is converted to
/// it.
/// </param>
/// <param name="synchronizationFailureDate">
/// The date, in Coordinated Universal Time (UTC), the synchronization operation for
/// <paramref name="skippedThreatList" /> failed. If the date is not expressed in UTC, it is converted to
/// it.
/// </param>
/// <param name="synchronizationException">
/// The exception that was thrown when the synchronization operation for
/// <paramref name="skippedThreatList"/> failed.
/// </param>
/// <exception cref="System.ArgumentNullException">
/// Thrown if <paramref name="skippedThreatList" /> is a null reference, or if
/// <paramref name="synchronizationException" /> is a null reference.
/// </exception>
internal ThreatListSynchronizationFailedEventArgs(ThreatList skippedThreatList, DateTime synchronizationStartDate, DateTime synchronizationFailureDate, Exception synchronizationException)
{
Guard.ThrowIf(nameof(skippedThreatList), skippedThreatList).Null();
Guard.ThrowIf(nameof(synchronizationException), synchronizationException).Null();
this.SkippedThreatList = skippedThreatList;
this.SynchronizationException = synchronizationException;
this.SynchronizationFailureDate = synchronizationFailureDate.ToUniversalTime();
this.SynchronizationStartDate = synchronizationStartDate.ToUniversalTime();
}
/// <summary>
/// Store a Threat List Asynchronously.
/// </summary>
/// <param name="this">
/// A <see cref="IManagedBrowsingDatabase" />.
/// </param>
/// <param name="threatList">
/// A <see cref="ThreatList" /> to store.
/// </param>
/// <param name="threatSha256HashPrefixes">
/// A collection of SHA256 hash prefixes, formatted as hexadecimal encoded strings, identifying the threats
/// associated with <paramref name="threatList" /> and should be stored.
/// </param>
/// <exception cref="Gee.External.Browsing.Databases.BrowsingDatabaseException">
/// Thrown if a database error occurs.
/// </exception>
/// <exception cref="System.ArgumentNullException">
/// Thrown if <paramref name="this" /> is a null reference, or if <paramref name="threatList" /> is a null
/// reference, or if <paramref name="threatSha256HashPrefixes" /> is a null reference.
/// </exception>
/// <exception cref="System.ObjectDisposedException">
/// Thrown if <paramref name="this" /> is disposed.
/// </exception>
public static Task StoreThreatListAsync(this IManagedBrowsingDatabase @this, ThreatList threatList, IEnumerable <string> threatSha256HashPrefixes)
{
Guard.ThrowIf(nameof(@this), @this).Null();
// ...
//
// Throws an exception if the operation fails.
var storeThreatListTask = @this.StoreThreatListAsync(threatList, threatSha256HashPrefixes, CancellationToken.None);
return(storeThreatListTask);
}
/// <summary>
/// Store a Threat List Asynchronously.
/// </summary>
/// <param name="threatList">
/// A <see cref="ThreatList" /> to store.
/// </param>
/// <param name="threatSha256HashPrefixes">
/// A collection of SHA256 hash prefixes, formatted as hexadecimal encoded strings, identifying the threats
/// associated with <paramref name="threatList" /> and should be stored.
/// </param>
/// <param name="cancellationToken">
/// A cancellation token to cancel the asynchronous operation with.
/// </param>
/// <returns>
/// A task representing the asynchronous operation.
/// </returns>
/// <exception cref="Gee.External.Browsing.Databases.BrowsingDatabaseException">
/// Thrown if a database error occurs.
/// </exception>
/// <exception cref="System.ArgumentNullException">
/// Thrown if <paramref name="threatList" /> is a null reference, or if
/// <paramref name="threatSha256HashPrefixes" /> is a null reference.
/// </exception>
/// <exception cref="System.ObjectDisposedException">
/// Thrown if the object is disposed.
/// </exception>
/// <exception cref="System.OperationCanceledException">
/// Thrown if the asynchronous operation is cancelled.
/// </exception>
public virtual Task StoreThreatListAsync(ThreatList threatList, IEnumerable <string> threatSha256HashPrefixes, CancellationToken cancellationToken)
{
this.ThrowIfDisposed();
// ...
//
// Throws an exception if the operation fails.
var storeThreatListTask = this._database.StoreThreatListAsync(threatList, threatSha256HashPrefixes, cancellationToken);
return(storeThreatListTask);
}
public override object Clone()
{
ThreatList tl = new ThreatList();
for (int n = 0; n < Count; ++n)
{
tl.Add(((Threat)this[n]).Clone());
}
return(tl);
}
public InterestingFieldAgent(ThreatSearcher searcher, int size)
{
interestingfields = new bool[size, size];
this.size = size;
ownthreatlist = new ThreatList();
oppthreatlist = new ThreatList();
ownremovedthreatlist = new ThreatList();
oppremovedthreatlist = new ThreatList();
ownaddedthreatlist = new ThreatList();
oppaddedthreatlist = new ThreatList();
this.searcher = searcher;
}
public InterestingFieldAgent(ThreatSearcher searcher, int size)
{
interestingfields = new bool[size, size];
this.size = size;
ownthreatlist = new ThreatList();
oppthreatlist = new ThreatList();
ownremovedthreatlist = new ThreatList();
oppremovedthreatlist = new ThreatList();
ownaddedthreatlist = new ThreatList();
oppaddedthreatlist = new ThreatList();
this.searcher = searcher;
}
/// <summary>
/// Create a Base JSON Database.
/// </summary>
/// <param name="databaseFilePath">
/// An absolute file path to a database file. If the file does not exist, it will be created.
/// </param>
/// <exception cref="System.ArgumentNullException">
/// Thrown if <paramref name="databaseFilePath" /> is a null reference.
/// </exception>
private protected BaseJsonBrowsingDatabase(string databaseFilePath)
{
this._database = new MemoryBrowsingDatabase();
this._disposed = false;
this.DatabaseFileManager = new JsonFileManager(databaseFilePath);
this.DatabaseFilePath = databaseFilePath;
// ...
//
// ...
LoadDatabase(this);
// <summary>
// Load Database.
// </summary>
void LoadDatabase(BaseJsonBrowsingDatabase @this)
{
try {
// ...
//
// Throws an exception if the operation fails.
var cFileModel = @this.DatabaseFileManager.Read();
if (cFileModel.ThreatLists != null)
{
foreach (var cThreatListModel in cFileModel.ThreatLists)
{
var cPlatformType = cThreatListModel.PlatformType;
var cThreatEntryType = cThreatListModel.ThreatEntryType;
var cThreatType = cThreatListModel.ThreatType;
var cThreatList = ThreatList.Build()
.SetDescriptor(cThreatType, cPlatformType, cThreatEntryType)
.SetRetrieveDate(cThreatListModel.RetrieveDate)
.SetState(cThreatListModel.State)
.SetWaitToDate(cThreatListModel.WaitToDate)
.Build();
// ...
//
// Throws an exception if the operation fails.
var cThreatSha256HashPrefixes = cThreatListModel.ThreatSha256HashPrefixes;
var cStoreThreatListTask = @this._database.StoreThreatListAsync(cThreatList, cThreatSha256HashPrefixes);
cStoreThreatListTask.Wait();
}
}
}
catch {
// ...
//
// We don't care if we are unable to load the database.
}
}
}
/// <summary>
/// Set Retrieved Threat List.
/// </summary>
/// <param name="valueAction">
/// An action to create the <see cref="ThreatList" /> retrieved from the Google Safe Browsing API.
/// </param>
/// <returns>
/// This threat list update result builder.
/// </returns>
/// <exception cref="System.ArgumentNullException">
/// Thrown if <paramref name="valueAction" /> is a null reference.
/// </exception>
public ThreatListUpdateResultBuilder SetRetrievedThreatList(Func <ThreatListBuilder, ThreatList> valueAction)
{
Guard.ThrowIf(nameof(valueAction), valueAction).Null();
// ...
//
// Throws an exception if the operation fails.
var threatListBuilder = ThreatList.Build();
var threatList = valueAction(threatListBuilder);
this.SetRetrievedThreatList(threatList);
return(this);
}
public void ReCheckThreatList()
{
for (int i = 0; i < Land.allLand.Count; i++)
{
if (Land.allLand[i].LandUnit != null && Land.allLand[i].LandUnit.Faction != Faction)
{
if (SearchTheartList(Land.allLand[i].LandUnit) == -1)
{
ThreatList temp = new ThreatList();
temp.threatUnit = Land.allLand[i].LandUnit;
temp.threatMount = 0.0f;
aggroList.Add(temp);
}
}
}
}
public void AddThreat(Unit _target, float _value)
{
int temp = SearchTheartList(_target);
if (temp != -1)
{
aggroList[temp].AddThreatValue(_value);
}
else
{
ThreatList tempList = new ThreatList();
tempList.threatUnit = _target;
tempList.threatMount = _value;
aggroList.Add(tempList);
}
}
/// <summary>
/// Store a Threat List Asynchronously.
/// </summary>
/// <param name="threatList">
/// A <see cref="ThreatList" /> to store.
/// </param>
/// <param name="threatSha256HashPrefixes">
/// A collection of SHA256 hash prefixes, formatted as hexadecimal encoded strings, identifying the threats
/// associated with <paramref name="threatList" /> and should be stored.
/// </param>
/// <param name="cancellationToken">
/// A cancellation token to cancel the asynchronous operation with.
/// </param>
/// <returns>
/// A task representing the asynchronous operation.
/// </returns>
/// <exception cref="Gee.External.Browsing.Databases.BrowsingDatabaseException">
/// Thrown if a database error occurs.
/// </exception>
/// <exception cref="System.ArgumentNullException">
/// Thrown if <paramref name="threatList" /> is a null reference, or if
/// <paramref name="threatSha256HashPrefixes" /> is a null reference.
/// </exception>
/// <exception cref="System.ObjectDisposedException">
/// Thrown if the object is disposed.
/// </exception>
/// <exception cref="System.OperationCanceledException">
/// Thrown if the asynchronous operation is cancelled.
/// </exception>
public Task StoreThreatListAsync(ThreatList threatList, IEnumerable <string> threatSha256HashPrefixes, CancellationToken cancellationToken)
{
this.ThrowIfDisposed();
Guard.ThrowIf(nameof(threatList), threatList).Null();
lock (this._lock) {
// ...
//
// We need to sort the threat list so that it can later be searched. Throws an exception if the
// operation fails.
var newSha256HashPrefixes = new List <string>(threatSha256HashPrefixes);
newSha256HashPrefixes.Sort();
this._threatLists[threatList.Descriptor] = threatList;
this._threats[threatList.Descriptor] = newSha256HashPrefixes;
return(Task.CompletedTask);
}
}
public Actor()
{
Abilities = new List<Ability>();
Auras = new List<Aura>();
Equipment = new List<Item>();
Orders = new List<Order>();
IsAlive = true;
BaseStatistics = new Statistics();
CurrentHealth = MaximumHealth;
CurrentMana = MaximumMana;
Diameter = 1.0f;
Targets = new Queue<Actor>();
ThreatList = new ThreatList();
Direction = new Vector2(0, -1);
MovementSpeed = 5f;
}
public static async Task <IReadOnlyCollection <ThreatList> > GetThreatListsAsync(this IUnmanagedBrowsingDatabase @this, IEnumerable <ThreatListDescriptor> threatListDescriptors)
{
Guard.ThrowIf(nameof(@this), @this).Null();
Guard.ThrowIf(nameof(threatListDescriptors), threatListDescriptors).Null();
var threatLists = new List <ThreatList>();
foreach (var threatListDescriptor in threatListDescriptors)
{
// ...
//
// Throws an exception if the operation fails.
var getThreatListTask = @this.GetThreatListAsync(threatListDescriptor);
var threatList = await getThreatListTask.ConfigureAwait(false);
threatList = threatList ?? ThreatList.CreateInvalid(threatListDescriptor);
threatLists.Add(threatList);
}
return(threatLists);
}
/// <summary> /// Get Threat List Updates Asynchronously. /// </summary> /// <param name="this"> /// A <see cref="IBrowsingClient" />. /// </param> /// <param name="threatList"> /// A <see cref="ThreatList" /> to retrieve. /// </param> /// <param name="updateConstraints"> /// The <see cref="ThreatListUpdateConstraints" /> to apply when <paramref name="threatList" /> is /// retrieved. A null reference indicates no <see cref="ThreatListUpdateConstraints" /> should be applied. /// </param> /// <returns> /// A <see cref="ThreatListUpdateResponse" />. /// </returns> /// <exception cref="Gee.External.Browsing.Clients.BrowsingClientException"> /// Thrown if an error communicating with the Google Safe Browsing API occurs. /// </exception> /// <exception cref="System.ArgumentNullException"> /// Thrown if <paramref name="this" /> is a null reference, or if <paramref name="threatList" /> is a /// null reference. /// </exception> /// <exception cref="System.ObjectDisposedException"> /// Thrown if the <paramref name="this" /> is disposed. /// </exception> /// <exception cref="System.TimeoutException"> /// Thrown if communication with the Google Safe Browsing API times out. /// </exception> public static Task <ThreatListUpdateResponse> GetThreatListUpdatesAsync(this IBrowsingClient @this, ThreatList threatList, ThreatListUpdateConstraints updateConstraints) => @this.GetThreatListUpdatesAsync(threatList, updateConstraints, CancellationToken.None);
/// <summary>
/// Get Threat List Updates Asynchronously.
/// </summary>
/// <param name="this">
/// A <see cref="IBrowsingClient" />.
/// </param>
/// <param name="threatList">
/// A <see cref="ThreatList" /> to retrieve.
/// </param>
/// <param name="updateConstraints">
/// The <see cref="ThreatListUpdateConstraints" /> to apply when <paramref name="threatList" /> is
/// retrieved. A null reference indicates no <see cref="ThreatListUpdateConstraints" /> should be applied.
/// </param>
/// <param name="cancellationToken">
/// A cancellation token to cancel the asynchronous operation with.
/// </param>
/// <returns>
/// A <see cref="ThreatListUpdateResponse" />.
/// </returns>
/// <exception cref="Gee.External.Browsing.Clients.BrowsingClientException">
/// Thrown if an error communicating with the Google Safe Browsing API occurs.
/// </exception>
/// <exception cref="System.ArgumentNullException">
/// Thrown if <paramref name="this" /> is a null reference, or if <paramref name="threatList" /> is a
/// null reference.
/// </exception>
/// <exception cref="System.ObjectDisposedException">
/// Thrown if the <paramref name="this" /> is disposed.
/// </exception>
/// <exception cref="System.OperationCanceledException">
/// Thrown if the asynchronous operation is cancelled.
/// </exception>
/// <exception cref="System.TimeoutException">
/// Thrown if communication with the Google Safe Browsing API times out.
/// </exception>
public static Task <ThreatListUpdateResponse> GetThreatListUpdatesAsync(this IBrowsingClient @this, ThreatList threatList, ThreatListUpdateConstraints updateConstraints, CancellationToken cancellationToken)
{
Guard.ThrowIf(nameof(@this), @this).Null();
Guard.ThrowIf(nameof(threatList), threatList).Null();
var threatListUpdateRequestBuilder = ThreatListUpdateRequest.Build();
threatListUpdateRequestBuilder.AddQuery(b => {
b.SetThreatListDescriptor(threatList.Descriptor);
b.SetThreatListState(threatList.State);
b.SetUpdateConstraints(updateConstraints);
return(b.Build());
});
// ...
//
// Throws an exception if the operation fails.
var threatListUpdateRequest = threatListUpdateRequestBuilder.Build();
var getThreatListUpdatesTask = @this.GetThreatListUpdatesAsync(threatListUpdateRequest, cancellationToken);
return(getThreatListUpdatesTask);
}
private async Task SynchronizeDatabaseAsync()
{
var cancellationToken = this._synchronizationTaskCancellationTokenSource.Token;
while (!cancellationToken.IsCancellationRequested)
{
var getThreatListUpdatesTask = GetThreatListUpdatesAsync(this);
var(threatListUpdateResponse, delayToDate) = await getThreatListUpdatesTask.ConfigureAwait(false);
if (threatListUpdateResponse != null)
{
foreach (var threatListUpdateResult in threatListUpdateResponse.Results)
{
var threatListWaitToDate = threatListUpdateResult.RetrievedThreatList.WaitToDate;
if (threatListWaitToDate != null && threatListWaitToDate < delayToDate)
{
delayToDate = threatListWaitToDate.Value;
}
var synchronizeThreatListTask = SynchronizeThreatListAsync(this, threatListUpdateResult);
await synchronizeThreatListTask.ConfigureAwait(false);
}
}
var delayToTask = DelayToAsync(this, delayToDate);
await delayToTask.ConfigureAwait(false);
}
// <summary>
// Delay to a Date Asynchronously.
// </summary>
async Task DelayToAsync(BrowsingDatabaseManager @this, DateTime cDate)
{
try {
var cCancellationToken = @this._synchronizationTaskCancellationTokenSource.Token;
var cDelayToTask = TaskExtension.DelayTo(cDate, cCancellationToken);
await cDelayToTask.ConfigureAwait(false);
}
catch (OperationCanceledException) {
// ...
//
// We don't care if the cancellation token is cancelled.
}
}
// <summary>
// Get Threat List Updates Asynchronously.
// </summary>
async Task <(ThreatListUpdateResponse, DateTime)> GetThreatListUpdatesAsync(BrowsingDatabaseManager @this)
{
var cDelayToDate = DateTime.UtcNow.AddMinutes(30);
try {
IEnumerable <ThreatListDescriptor> cThreatListDescriptors = @this._updateConstraints.Keys;
if (@this._updateConstraints.Count == 0)
{
// ...
//
// If the database synchronizer is not restricted to specific threat lists, we retrieve all
// available threat lists from the Google Safe Browsing API. We don't cache the result in case
// new threat lists are made available between synchronization iterations.
//
// Throws an exception if the operation fails.
var cGetThreatListDescriptorsTask = @this._client.GetThreatListDescriptorsAsync();
cThreatListDescriptors = await cGetThreatListDescriptorsTask.ConfigureAwait(false);
}
// ...
//
// Retrieve the threat lists from the database. Throws an exception if the operation fails.
var cGetThreatListsTask = @this._database.GetThreatListsAsync(cThreatListDescriptors);
var cThreatLists = await cGetThreatListsTask.ConfigureAwait(false);
ThreatListUpdateRequestBuilder cThreatListUpdateRequestBuilder = null;
foreach (var cThreatList in cThreatLists)
{
if (cThreatList.Expired)
{
cThreatListUpdateRequestBuilder = cThreatListUpdateRequestBuilder ?? ThreatListUpdateRequest.Build();
var cThreatListDescriptor = cThreatList.Descriptor;
var cThreatListState = cThreatList.State;
@this._updateConstraints.TryGetValue(cThreatListDescriptor, out var cThreatListUpdateConstraints);
cThreatListUpdateRequestBuilder.AddQuery(b => {
b.SetThreatListDescriptor(cThreatListDescriptor);
b.SetThreatListState(cThreatListState);
b.SetUpdateConstraints(cThreatListUpdateConstraints);
return(b.Build());
});
}
else
{
if (cThreatList.WaitToDate != null && cThreatList.WaitToDate < cDelayToDate)
{
// ...
//
// If the current threat list's wait to date is earlier than the previous threat
// list's wait to date, take the current the threat list's wait to date instead.
cDelayToDate = cThreatList.WaitToDate.Value;
}
}
}
ThreatListUpdateResponse cThreatListUpdateResponse = null;
if (cThreatListUpdateRequestBuilder != null)
{
// ...
//
// Throws an exception if the operation fails.
var cThreatListUpdateRequest = cThreatListUpdateRequestBuilder.Build();
var cGetThreatListUpdatesTask = @this._client.GetThreatListUpdatesAsync(cThreatListUpdateRequest);
cThreatListUpdateResponse = await cGetThreatListUpdatesTask.ConfigureAwait(false);
}
return(cThreatListUpdateResponse, cDelayToDate);
}
catch {
return(null, cDelayToDate);
}
}
// <summary>
// Synchronize Threat List Asynchronously.
// </summary>
async Task SynchronizeThreatListAsync(BrowsingDatabaseManager @this, ThreatListUpdateResult cThreatListUpdateResult)
{
var cSynchronizationStartDate = DateTime.UtcNow;
var cThreatList = cThreatListUpdateResult.RetrievedThreatList;
try {
var cSha256HashPrefixes = cThreatListUpdateResult.ThreatsToAdd;
if (cThreatListUpdateResult.IsFullUpdate)
{
// ...
//
// Throws an exception if the operation fails.
var cModifyThreatListTask = @this._database.StoreThreatListAsync(cThreatList, cSha256HashPrefixes);
await cModifyThreatListTask.ConfigureAwait(false);
}
else if (cThreatListUpdateResult.IsPartialUpdate)
{
// ...
//
// Throws an exception if the operation fails.
var cIndices = cThreatListUpdateResult.ThreatsToRemove;
var cModifyThreatListTask = @this._database.ModifyThreatListAsync(cThreatList, cSha256HashPrefixes, cIndices);
await cModifyThreatListTask.ConfigureAwait(false);
}
// ...
//
// Throws an exception if the operation fails.
var cComputeThreatListChecksumTask = @this._database.ComputeThreatListChecksumAsync(cThreatList.Descriptor);
var cThreatListChecksum = await cComputeThreatListChecksumTask.ConfigureAwait(false);
if (cThreatListChecksum != cThreatListUpdateResult.RetrievedThreatListChecksum)
{
// ...
//
// Throws an exception if the operation fails.
cThreatList = ThreatList.CreateInvalid(cThreatList.Descriptor);
var cUpdateConstraints = cThreatListUpdateResult.Query.UpdateConstraints;
var cGetThreatListUpdatesTask = @this._client.GetThreatListUpdatesAsync(cThreatList, cUpdateConstraints);
var cThreatListUpdateRequest = await cGetThreatListUpdatesTask.ConfigureAwait(false);
cThreatListUpdateResult = cThreatListUpdateRequest.Results.First();
cSha256HashPrefixes = cThreatListUpdateResult.ThreatsToAdd;
if (cThreatListUpdateResult.IsFullUpdate)
{
// ...
//
// Throws an exception if the operation fails.
cThreatList = cThreatListUpdateResult.RetrievedThreatList;
var cModifyThreatListTask = @this._database.StoreThreatListAsync(cThreatList, cSha256HashPrefixes);
await cModifyThreatListTask.ConfigureAwait(false);
}
}
// ...
//
// Invoke threat list synchronization completed event.
var cSynchronizationCompletionDate = DateTime.UtcNow;
@this.OnThreatListSynchronizationCompleted(new ThreatListSynchronizationCompletedEventArgs(
cThreatList,
cSynchronizationStartDate,
cSynchronizationCompletionDate
));
}
catch (Exception cEx) {
// ...
//
// Invoke threat list synchronization failed event.
var cSynchronizationFailureDate = DateTime.UtcNow;
@this.OnThreatListSynchronizationFailed(new ThreatListSynchronizationFailedEventArgs(
cThreatList,
cSynchronizationStartDate,
cSynchronizationFailureDate,
cEx
));
}
}
}
public void UpdateThreatLists(int[,] board, Coordinate move, int attacker)
{
// 0. Initialized the removelists
ownremovedthreatlist = new ThreatList();
oppremovedthreatlist = new ThreatList();
ownaddedthreatlist = new ThreatList();
oppaddedthreatlist = new ThreatList();
// 1. Remove blocked threats from both lists.
ThreatList lookup = new ThreatList();
foreach (Threat t in oppthreatlist)
{
foreach (Coordinate c in t.fields)
{
if (c.X == move.X && c.Y == move.Y)
{
oppremovedthreatlist.Add(t);
lookup.Add(t.cause);
}
}
}
foreach (Threat t in oppremovedthreatlist)
{
oppthreatlist.Remove(t);
}
foreach (Threat t in ownthreatlist)
{
foreach (Coordinate c in t.fields)
{
if (c.X == move.X && c.Y == move.Y)
{
ownremovedthreatlist.Add(t);
lookup.Add(t.cause);
}
}
}
foreach (Threat t in ownremovedthreatlist)
{
ownthreatlist.Remove(t);
}
//Lookup if "causes" still cause threats
foreach (Coordinate c in lookup)
{
if (board[c.X, c.Y] == 1)
{
ThreatList curthreats = searcher.investigate(board, c, 1);
ownaddedthreatlist = Merge(ownthreatlist, curthreats);
}
if (board[c.X, c.Y] == -1)
{
ThreatList curthreats = searcher.investigate(board, c, -1);
oppaddedthreatlist = Merge(oppthreatlist, curthreats);
}
}
if (attacker == 1)
{
// We are attacking
// 2. Add our threats we build to our list
ThreatList curthreats = searcher.investigate(board, move, attacker, true);
Merge(ownaddedthreatlist, Merge(ownthreatlist, curthreats));
}
else
{
// The opponent is attacking
// 2. Add his threats to his list
ThreatList curthreats = searcher.investigate(board, move, attacker, true);
Merge(oppaddedthreatlist, Merge(oppthreatlist, curthreats));
}
}
private ThreatList SearchBoards(Coordinate node)
{
ThreatList res = new ThreatList ();
int turn = attacker;
Item tmpval;
int digit1 = 0;
int digit2 = 0;
int digit3 = 0;
int digit4 = 0;
for (int j = 8; j >= 0; --j)
{
if (j + node.X - 4 >= 0 && j + node.X - 4 < board.GetLength(0))
{
digit1 += board[node.X + j - 4, node.Y] * turn + 1;
// Console.WriteLine("Grabbing {0}/{1}", node.move.x + j - 4, node.move.y);
}
else digit1 += 3;
if (j + node.Y - 4 >= 0 && j + node.Y - 4 < board.GetLength(1))
{
digit2 += board[node.X, node.Y + j - 4] * turn + 1;
// Console.WriteLine("Grabbing {0}/{1}", node.move.x , node.move.y + j -4);
}
else digit2 += 3;
if (node.X + j - 4 >= 0 && node.X + j - 4 < board.GetLength(0) &&
node.Y + j - 4 >= 0 && node.Y + j - 4 < board.GetLength(1) )
{
digit3 += board[node.X + j - 4, node.Y + j - 4] * turn + 1;
// Console.WriteLine("Grabbing {0}/{1}", node.move.x + j - 4, node.move.y + j - 4);
}
else digit3 += 3;
if (node.X - j + 4 >= 0 && node.X - j + 4 < board.GetLength(0) &&
node.Y + j - 4 >= 0 && node.Y + j - 4 < board.GetLength(1) )
{
digit4 += board[node.X - j + 4, node.Y + j - 4] * turn + 1;
// Console.WriteLine("Grabbing {0}/{1}", node.move.x - j + 4, node.move.y + j - 4);
}
else digit4 += 3;
if (j != 0)
{
digit1 <<= 2;
digit2 <<= 2;
digit3 <<= 2;
digit4 <<= 2;
}
}
tmpval = table[digit1];
if (tmpval != null && (tmpval.create == false || create == true))
{
//Console.WriteLine("horz category: {0}", tmpval.category);
ArrayList moves = new ArrayList();
foreach(int field in tmpval.fields)
{
moves.Add(new Coordinate(node.X + tmpval.offset + field, node.Y));
}
Threat t = new Threat(node, tmpval.category, moves, tmpval.create);
res.Add(t);
}
tmpval = table[digit2];
if (tmpval != null && (tmpval.create == false || create == true))
{
//Console.WriteLine("vert category: {0}", tmpval.category);
//Console.WriteLine("Node: {0}", node);
//Console.WriteLine("offset: {0}", tmpval.offset);
ArrayList moves = new ArrayList();
foreach(int field in tmpval.fields)
{
//Coordinate tmp = new Coordinate(node.X , node.Y + tmpval.offset + field);
//Console.WriteLine("adding move: {0}", tmp);
moves.Add(new Coordinate(node.X, node.Y + tmpval.offset + field));
}
Threat t = new Threat(node, tmpval.category, moves, tmpval.create);
res.Add(t);
}
tmpval = table[digit3];
if (tmpval != null && (tmpval.create == false || create == true))
{
//Console.WriteLine("diag 1 category: {0}", tmpval.category);
ArrayList moves = new ArrayList();
foreach(int field in tmpval.fields)
{
moves.Add(new Coordinate(node.X + tmpval.offset + field, node.Y + tmpval.offset + field));
}
Threat t = new Threat(node, tmpval.category, moves, tmpval.create);
res.Add(t);
}
tmpval = table[digit4];
if (tmpval != null && (tmpval.create == false || create == true))
{
//Console.WriteLine("diag 2 category: {0}", tmpval.category);
//Console.WriteLine("Node: {0}", node);
//Console.WriteLine("offset: {0}", tmpval.offset);
ArrayList moves = new ArrayList();
foreach(int field in tmpval.fields)
{
//Coordinate tmp = new Coordinate(node.X -(tmpval.offset + field), node.Y + tmpval.offset + field);
//Console.WriteLine("adding move: {0}", tmp);
moves.Add(new Coordinate(node.X -(tmpval.offset + field), node.Y + tmpval.offset + field));
}
Threat t = new Threat(node, tmpval.category, moves, tmpval.create);
res.Add(t);
}
return res;
}
/** Add threats from from into into if they are not contained yet.
*
* @returns ArrayList<Threat> List of the added threats.
*/
private ThreatList Merge(ThreatList into, ThreatList from)
{
ThreatList res = new ThreatList ();
foreach (Threat t in from)
{
// check for every t if it is already in into-list
bool alreadyin = false;
foreach (Threat ct in into)
{
alreadyin = true;
if (ct.category == t.category && ct.fields.Count == t.fields.Count)
{
for (int i = 0; i < ct.fields.Count; ++i)
{
alreadyin = alreadyin &&
( ( ((Coordinate)(ct.fields[i])).X == ((Coordinate)(t.fields[i])).X ) &&
( ((Coordinate)(ct.fields[i])).Y == ((Coordinate)(t.fields[i])).Y ) );
}
}
else alreadyin = false;
}
if (alreadyin == false) {
into.Add(t);
res.Add(t);
}
}
return res;
}
public void UpdateThreatLists(int[,] board, Coordinate move, int attacker)
{
// 0. Initialized the removelists
ownremovedthreatlist = new ThreatList();
oppremovedthreatlist = new ThreatList();
ownaddedthreatlist = new ThreatList();
oppaddedthreatlist = new ThreatList();
// 1. Remove blocked threats from both lists.
ThreatList lookup = new ThreatList();
foreach (Threat t in oppthreatlist) {
foreach (Coordinate c in t.fields) {
if (c.X == move.X && c.Y == move.Y) {
oppremovedthreatlist.Add(t);
lookup.Add(t.cause);
}
}
}
foreach (Threat t in oppremovedthreatlist) oppthreatlist.Remove(t);
foreach (Threat t in ownthreatlist) {
foreach (Coordinate c in t.fields) {
if (c.X == move.X && c.Y == move.Y) {
ownremovedthreatlist.Add(t);
lookup.Add(t.cause);
}
}
}
foreach (Threat t in ownremovedthreatlist) ownthreatlist.Remove(t);
//Lookup if "causes" still cause threats
foreach (Coordinate c in lookup)
{
if (board[c.X, c.Y] == 1)
{
ThreatList curthreats = searcher.investigate(board, c, 1);
ownaddedthreatlist = Merge(ownthreatlist, curthreats);
}
if (board[c.X, c.Y] == -1)
{
ThreatList curthreats = searcher.investigate(board, c, -1);
oppaddedthreatlist = Merge(oppthreatlist, curthreats);
}
}
if (attacker == 1)
{
// We are attacking
// 2. Add our threats we build to our list
ThreatList curthreats = searcher.investigate(board, move, attacker, true);
Merge(ownaddedthreatlist, Merge(ownthreatlist, curthreats));
}
else
{
// The opponent is attacking
// 2. Add his threats to his list
ThreatList curthreats = searcher.investigate(board, move, attacker, true);
Merge(oppaddedthreatlist, Merge(oppthreatlist, curthreats));
}
}
/// <summary>
/// Synchronize Database File Asynchronously.
/// </summary>
/// <returns>
/// A task representing the asynchronous operation.
/// </returns>
private async Task SyncDatabaseFileAsync()
{
var cancellationToken = this._syncTaskCancellationTokenSource.Token;
while (!cancellationToken.IsCancellationRequested)
{
try {
// ...
//
// Throws an exception if the operation fails.
var fileModel = this.DatabaseFileManager.Read();
if (fileModel.ThreatLists != null)
{
foreach (var threatListModel in fileModel.ThreatLists)
{
var platformType = threatListModel.PlatformType;
var threatEntryType = threatListModel.ThreatEntryType;
var threatType = threatListModel.ThreatType;
var threatList = ThreatList.Build()
.SetDescriptor(threatType, platformType, threatEntryType)
.SetRetrieveDate(threatListModel.RetrieveDate)
.SetState(threatListModel.State)
.SetWaitToDate(threatListModel.WaitToDate)
.Build();
// ...
//
// Throws an exception if the operation fails.
var threatSha256HashPrefixes = threatListModel.ThreatSha256HashPrefixes;
var storeThreatListTask = this.StoreThreatListAsync(threatList, threatSha256HashPrefixes, cancellationToken);
await storeThreatListTask.ConfigureAwait(false);
}
}
}
catch {
// ...
//
// We don't care if we failed to synchronize the database file. We'll try again on the next
// iteration.
}
finally {
var delayTask = DelayAsync(this);
await delayTask.ConfigureAwait(false);
}
}
// <summary>
// Delay Asynchronously.
// </summary>
async Task DelayAsync(UnmanagedJsonBrowsingDatabase @this)
{
try {
var cCancellationToken = @this._syncTaskCancellationTokenSource.Token;
var cDelayTask = Task.Delay(UnmanagedJsonBrowsingDatabase.SyncInterval, cCancellationToken);
await cDelayTask.ConfigureAwait(false);
}
catch (OperationCanceledException) {
// ...
//
// We don't care if the cancellation token is cancelled.
}
}
}
private ThreatList SearchBoards(Coordinate node)
{
ThreatList res = new ThreatList();
int turn = attacker;
Item tmpval;
int digit1 = 0;
int digit2 = 0;
int digit3 = 0;
int digit4 = 0;
for (int j = 8; j >= 0; --j)
{
if (j + node.X - 4 >= 0 && j + node.X - 4 < board.GetLength(0))
{
digit1 += board[node.X + j - 4, node.Y] * turn + 1;
// Console.WriteLine("Grabbing {0}/{1}", node.move.x + j - 4, node.move.y);
}
else
{
digit1 += 3;
}
if (j + node.Y - 4 >= 0 && j + node.Y - 4 < board.GetLength(1))
{
digit2 += board[node.X, node.Y + j - 4] * turn + 1;
// Console.WriteLine("Grabbing {0}/{1}", node.move.x , node.move.y + j -4);
}
else
{
digit2 += 3;
}
if (node.X + j - 4 >= 0 && node.X + j - 4 < board.GetLength(0) &&
node.Y + j - 4 >= 0 && node.Y + j - 4 < board.GetLength(1))
{
digit3 += board[node.X + j - 4, node.Y + j - 4] * turn + 1;
// Console.WriteLine("Grabbing {0}/{1}", node.move.x + j - 4, node.move.y + j - 4);
}
else
{
digit3 += 3;
}
if (node.X - j + 4 >= 0 && node.X - j + 4 < board.GetLength(0) &&
node.Y + j - 4 >= 0 && node.Y + j - 4 < board.GetLength(1))
{
digit4 += board[node.X - j + 4, node.Y + j - 4] * turn + 1;
// Console.WriteLine("Grabbing {0}/{1}", node.move.x - j + 4, node.move.y + j - 4);
}
else
{
digit4 += 3;
}
if (j != 0)
{
digit1 <<= 2;
digit2 <<= 2;
digit3 <<= 2;
digit4 <<= 2;
}
}
tmpval = table[digit1];
if (tmpval != null && (tmpval.create == false || create == true))
{
//Console.WriteLine("horz category: {0}", tmpval.category);
ArrayList moves = new ArrayList();
foreach (int field in tmpval.fields)
{
moves.Add(new Coordinate(node.X + tmpval.offset + field, node.Y));
}
Threat t = new Threat(node, tmpval.category, moves, tmpval.create);
res.Add(t);
}
tmpval = table[digit2];
if (tmpval != null && (tmpval.create == false || create == true))
{
//Console.WriteLine("vert category: {0}", tmpval.category);
//Console.WriteLine("Node: {0}", node);
//Console.WriteLine("offset: {0}", tmpval.offset);
ArrayList moves = new ArrayList();
foreach (int field in tmpval.fields)
{
//Coordinate tmp = new Coordinate(node.X , node.Y + tmpval.offset + field);
//Console.WriteLine("adding move: {0}", tmp);
moves.Add(new Coordinate(node.X, node.Y + tmpval.offset + field));
}
Threat t = new Threat(node, tmpval.category, moves, tmpval.create);
res.Add(t);
}
tmpval = table[digit3];
if (tmpval != null && (tmpval.create == false || create == true))
{
//Console.WriteLine("diag 1 category: {0}", tmpval.category);
ArrayList moves = new ArrayList();
foreach (int field in tmpval.fields)
{
moves.Add(new Coordinate(node.X + tmpval.offset + field, node.Y + tmpval.offset + field));
}
Threat t = new Threat(node, tmpval.category, moves, tmpval.create);
res.Add(t);
}
tmpval = table[digit4];
if (tmpval != null && (tmpval.create == false || create == true))
{
//Console.WriteLine("diag 2 category: {0}", tmpval.category);
//Console.WriteLine("Node: {0}", node);
//Console.WriteLine("offset: {0}", tmpval.offset);
ArrayList moves = new ArrayList();
foreach (int field in tmpval.fields)
{
//Coordinate tmp = new Coordinate(node.X -(tmpval.offset + field), node.Y + tmpval.offset + field);
//Console.WriteLine("adding move: {0}", tmp);
moves.Add(new Coordinate(node.X - (tmpval.offset + field), node.Y + tmpval.offset + field));
}
Threat t = new Threat(node, tmpval.category, moves, tmpval.create);
res.Add(t);
}
return(res);
}
