public static async Task CreateAdversaryAsync(GameServiceClient client)
{
var adversary = new Adversary();
adversary.Name = ConsoleUtility.GetUserInput("Adversary Name: ");
adversary.GamePackageId = await GamePackageUtility.SelectGamePackageId(client);
adversary.AbilityIds.AddRange(await AbilityUtility.SelectAbilityIds(client));
if (!ConsoleUtility.ShouldContinue($"Creating Adversary: '{adversary.Name}', in gamePackage '{adversary.GamePackageId}' with abilities [{adversary.AbilityIds.Select(x => x.ToString()).Join(", ")}]"))
{
await CreateAdversaryAsync(client);
return;
}
var createRequest = new CreateAdversariesRequest();
createRequest.Adversaries.Add(adversary);
var createReply = await client.CreateAdversariesAsync(createRequest);
if (createReply.Status.Code != 200)
{
ConsoleUtility.WriteLine($"Failed to create adversary: {createReply.Status.Message}");
}
else
{
ConsoleUtility.WriteLine($"Adversary '{createReply.Adversaries.First().Name}' was created with Id '{createReply.Adversaries.First().Id}'");
}
}
public Game(
IBoardRepository boardRepository,
IInvaderCardSender invaderCardSender,
IInvaderDeckFactory invaderDeckFactory,
Adversary adversary)
{
_boardRepository = boardRepository;
_invaderCardSender = invaderCardSender;
_invaderDeckFactory = invaderDeckFactory;
_adversary = adversary;
_invaderDeckOrder = (_adversary as IAffectsInvaderDeckOrder)?.InvaderDeckOrder ?? "111222233333";
}
protected internal virtual void PageCachePostConstruct(PageCacheConfig overriddenConfig)
{
if (SelectConfig(BaseConfig.inconsistentReads, overriddenConfig.InconsistentReads, true))
{
AtomicBoolean controller = SelectConfig(BaseConfig.nextReadIsInconsistent, overriddenConfig.NextReadIsInconsistent, null);
Adversary adversary = controller != null ? new AtomicBooleanInconsistentReadAdversary(controller) : new RandomInconsistentReadAdversary();
PageCache = new AdversarialPageCache(PageCache, adversary);
}
if (SelectConfig(BaseConfig.accessChecks, overriddenConfig.AccessChecks, false))
{
PageCache = new AccessCheckingPageCache(PageCache);
}
}
public void IncRowVersion_HappyDays_SendsCorrectSqlToProvider()
{
var factory = GetProviderFactory();
var provider = new StubSqlProvider();
using (mocks.Record())
{
factory.CreateProvider("somestring");
LastCall.Return(provider).IgnoreArguments();
}
Adversary.ForTable("Person").IdentifiedBy("IdPerson", 1).IncRowVersion("Version");
Assert.AreEqual("UPDATE Person SET Version = Version + 1 WHERE IdPerson = 1", provider.GetExecutedQuery(0));
}
private static async ValueTask <IReadOnlyList <Adversary> > CreateAdversaries(GameServiceClient client, IReadOnlyList <GamePackage> packages, IReadOnlyList <Ability> abilities)
{
ConsoleUtility.WriteLine("Creating adversaries");
List <Adversary> result = (await AdversaryUtility.GetAdversariesAsync(client, null)).ToList();
if (result.Any())
{
return(result);
}
foreach (var file in Directory.EnumerateFiles(@"C:\Users\Ryan\SkyDrive\code\LegendaryGameStarter\LegendaryGameModel2\GameSets", s_fileMask))
{
var doc = XDocument.Load(file);
var name = doc.Element("Set").Attribute("Name").Value;
var activeGamePackage = packages.FirstOrDefault(x => x.Name == name);
if (activeGamePackage == null)
{
ConsoleUtility.WriteLine($"Failed to find matching game package for {file}");
}
foreach (var adversaryElement in doc.Element("Set").Element("Cards").Elements("Card").Where(x => x?.Attribute("Area").Value == "Adversary"))
{
var request = new CreateAdversariesRequest();
request.CreateOptions.Add(CreateOptions.ErrorOnDuplicates);
var adversary = new Adversary();
adversary.Name = adversaryElement.Attribute("Name").Value;
adversary.GamePackageId = activeGamePackage.Id;
adversary.AbilityIds.AddRange(GetMatchingItems(adversaryElement.Attribute("Abilities")?.Value, name => abilities.First(x => x.Name == name)).Select(x => x.Id));
request.Adversaries.Add(adversary);
var reply = await client.CreateAdversariesAsync(request);
if (reply.Status.Code != 200)
{
ConsoleUtility.WriteLine($"Failed to create '{adversary.Name}': {reply.Status.Message}");
}
result.AddRange(reply.Adversaries);
}
ConsoleUtility.WriteLine($"Completed: {name}");
}
return(result);
}
public void IncRowVersion_HappyDays_IncreasesVersionInDatabase()
{
int id = NextId();
int rowVersion = 1;
DataBoy.ForTable("Person")
.Row("IdPerson", id)
.D("FirstName", "Petter")
.D("LastName", "Hansen")
.D("Version", rowVersion)
.Commit();
Adversary.ForTable("Person").IdentifiedBy("IdPerson", id).IncRowVersion("Version");
DbAssert.ForTable("Person").WithColumnValuePair("IdPerson", id).AreEqual("Version", rowVersion + 1);
}
private static void InitializeAdversary(IReadOnlyList <Adversary> adversaries, int selection)
{
_adversary = adversaries[selection - 1];
_logger.Information($"Selected adversary: {_adversary.DisplayName}");
_logger.Warning("Select level (1-6):");
var line = Console.ReadLine();
if (int.TryParse(line, out var level) && level >= 1 && level <= 6)
{
_adversary.Initialize(level);
}
else
{
_adversary.Initialize(1);
}
_adversary.ShowMessageRequested += p => _logger.Warning(p);
}
internal SensibleAdversarialFileSystemAbstraction(Adversary adversary, FileSystemAbstraction @delegate) : base(adversary, @delegate)
{
this.Adversary = adversary;
this.Delegate = @delegate;
}
public AdversarialOutputStreamAnonymousInnerClass(SensibleAdversarialFileSystemAbstraction outerInstance, Stream outputStream, Adversary adversary) : base(outputStream, adversary)
{
this.outerInstance = outerInstance;
this._outputStream = outputStream;
}
public AdversarialReader(Reader reader, Adversary adversary)
{
this._reader = reader;
this._adversary = adversary;
}
public AdversarialFileWatcher(FileWatcher fileWatcher, Adversary adversary)
{
this._fileWatcher = fileWatcher;
this._adversary = adversary;
}
private AdversarialFileChannel(StoreFileChannel channel, Adversary adversary) : base(channel)
{
this.@delegate = channel;
this._adversary = adversary;
}
public AdversarialPageCache(PageCache @delegate, Adversary adversary)
{
this.@delegate = Objects.requireNonNull(@delegate);
this._adversary = Objects.requireNonNull(adversary);
}
public AdversarialWriter(Writer writer, Adversary adversary)
{
this._writer = writer;
this._adversary = adversary;
}
public static StoreFileChannel Wrap(StoreFileChannel channel, Adversary adversary)
{
return(new AdversarialFileChannel(channel, adversary));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @SafeVarargs public StackTraceElementGuardedAdversary(Adversary delegate, System.Predicate<StackTraceElement>... checks)
public StackTraceElementGuardedAdversary(Adversary @delegate, params System.Predicate <StackTraceElement>[] checks)
{
this.@delegate = @delegate;
this._checks = checks;
_enabled = true;
}
public AdversarialInputStream(Stream inputStream, Adversary adversary)
{
this._inputStream = inputStream;
this._adversary = adversary;
}
public ClassGuardedAdversary(Adversary @delegate, params Type[] victimClassSet) : base(@delegate, new PredicateAnonymousInnerClass(victimClassSet))
{
}
public AdversarialOutputStream(Stream outputStream, Adversary adversary)
{
this._outputStream = outputStream;
this._adversary = adversary;
}
public MethodGuardedAdversary(Adversary @delegate, params System.Reflection.MethodInfo[] victimMethodSet) : base(@delegate, new PredicateAnonymousInnerClass(victimMethodSet))
{
}
internal AdversarialReadPageCursor(PageCursor @delegate, Adversary adversary) : base(@delegate)
{
this._state = new State(Objects.requireNonNull(adversary));
}
internal State(Adversary adversary)
{
this.Adversary = adversary;
InconsistentReadHistory = new List <object>(32);
}
/// <summary>
/// Specifies victims as arbitrary <seealso cref="StackTraceElement"/> <seealso cref="Predicate"/>.
/// </summary>
/// <param name="delegate"> <seealso cref="Adversary"/> to delegate calls to. </param>
/// <param name="victims"> arbitrary <seealso cref="Predicate"/> for <seealso cref="StackTraceElement"/> in the executing
/// thread and if any of the elements in the current stack trace matches then failure is injected. </param>
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @SafeVarargs public ClassGuardedAdversary(Adversary delegate, System.Predicate<StackTraceElement>... victims)
public ClassGuardedAdversary(Adversary @delegate, params System.Predicate <StackTraceElement>[] victims) : base(@delegate, victims)
{
}
internal AdversarialWritePageCursor(PageCursor @delegate, Adversary adversary) : base(@delegate)
{
this._adversary = Objects.requireNonNull(adversary);
}
