public static async Task CreateMastermindAsync(GameServiceClient client)
{
var mastermind = new Mastermind();
mastermind.Name = ConsoleUtility.GetUserInput("Mastermind Name: ");
mastermind.GamePackageId = await GamePackageUtility.SelectGamePackageId(client);
mastermind.AbilityIds.AddRange(await AbilityUtility.SelectAbilityIds(client));
mastermind.HasEpicSide = ConsoleUtility.GetUserInputBool("Has Epic side?");
mastermind.CardRequirements.AddRange(await CardRequirementUtility.GetCardRequirements(client, mastermind.GamePackageId, true));
if (!ConsoleUtility.ShouldContinue($"Creating Mastermind: {mastermind}"))
{
await CreateMastermindAsync(client);
return;
}
var createRequest = new CreateMastermindsRequest();
createRequest.Masterminds.Add(mastermind);
var createReply = await client.CreateMastermindsAsync(createRequest);
if (createReply.Status.Code != 200)
{
ConsoleUtility.WriteLine($"Failed to create mastermind: {createReply.Status.Message}");
}
else
{
ConsoleUtility.WriteLine($"Mastermind '{createReply.Masterminds.First().Name}' was created with Id '{createReply.Masterminds.First().Id}'");
}
}
private static async ValueTask <IReadOnlyList <Mastermind> > CreateMasterminds(GameServiceClient client, IReadOnlyList <Ability> abilities, IReadOnlyList <GamePackage> packages)
{
ConsoleUtility.WriteLine("Creating masterminds");
List <Mastermind> result = (await MastermindUtility.GetMastermindsAsync(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 mastermindElement in doc.Element("Set").Element("Cards").Elements("Card").Where(x => x?.Attribute("Area").Value == "Mastermind"))
{
var request = new CreateMastermindsRequest();
request.CreateOptions.Add(CreateOptions.ErrorOnDuplicates);
var mastermind = new Mastermind();
mastermind.Name = mastermindElement.Attribute("Name").Value;
mastermind.GamePackageId = activeGamePackage.Id;
mastermind.AbilityIds.AddRange(GetMatchingItems(mastermindElement.Attribute("Abilities")?.Value, name => abilities.First(x => x.Name == name)).Select(x => x.Id));
mastermind.CardRequirements.AddRange(GetCardRequirements(client, mastermindElement, activeGamePackage.Id));
mastermind.HasEpicSide = (mastermindElement.Attribute("HasEpicSide")?.Value.ToLower() ?? "false") == "true";
request.Masterminds.Add(mastermind);
var reply = await client.CreateMastermindsAsync(request);
if (reply.Status.Code != 200)
{
ConsoleUtility.WriteLine($"Failed to create '{mastermind.Name}': {reply.Status.Message}");
}
result.AddRange(reply.Masterminds);
}
ConsoleUtility.WriteLine($"Completed: {name}");
}
return(result);
}
public static async Task <CreateMastermindsReply> CreateMastermindsAsync(CreateMastermindsRequest request, ServerCallContext context)
{
using var db = new LegendaryDatabase();
var connector = DbConnector.Create(db.Connection, new DbConnectorSettings {
AutoOpen = true, LazyOpen = true
});
var reply = new CreateMastermindsReply {
Status = new Status {
Code = 200
}
};
List <int> newMastermindIds = new List <int>();
var cardSetTypeInfo = await CardRequirementUtility.GetInsertCardTypeValue(CardSetType.CardSetMastermind, connector);
foreach (var mastermind in request.Masterminds)
{
// Validate the GamePackageId
var packageRequest = new GetGamePackagesRequest();
packageRequest.GamePackageIds.Add(mastermind.GamePackageId);
packageRequest.Fields.Add(GamePackageField.Id);
var packageReply = await GamePackageUtility.GetGamePackagesAsync(packageRequest, context);
if (packageReply.Status.Code != 200)
{
reply.Status = packageReply.Status;
return(reply);
}
// Validate the AbilityIds
var abilitiesRequest = new GetAbilitiesRequest();
abilitiesRequest.AbilityIds.AddRange(mastermind.AbilityIds);
abilitiesRequest.AbilityFields.Add(AbilityField.Id);
var abilitiesReply = await AbilityUtility.GetAbilitiesAsync(abilitiesRequest, context);
if (abilitiesReply.Status.Code != 200)
{
reply.Status = abilitiesReply.Status;
return(reply);
}
// Verify that this mastermind doesn't already exist
var mastermindRequest = new GetMastermindsRequest();
mastermindRequest.Name = mastermind.Name;
mastermindRequest.Fields.AddRange(new[] { MastermindField.MastermindId, MastermindField.MastermindName, MastermindField.MastermindGamePackageId });
mastermindRequest.NameMatchStyle = NameMatchStyle.MixedCase;
var mastermindReply = await GetMastermindsAsync(mastermindRequest, context);
if (mastermindReply.Status.Code == 200 && mastermindReply.Masterminds.Any())
{
var matchingMastermind = mastermindReply.Masterminds.First();
reply.Status = new Status {
Code = 400, Message = $"Mastermind {matchingMastermind.Id} with name '{matchingMastermind.Name}' was found in game package '{matchingMastermind.GamePackageId}'"
};
return(reply);
}
// Create the mastermind
var newMastermindId = ((int)(await connector.Command($@"
insert
into {DatabaseDefinition.DefaultTableName}
({DatabaseDefinition.ColumnName[MastermindField.MastermindName]}, {DatabaseDefinition.ColumnName[MastermindField.MastermindEpicInformation]})
values (@MastermindName, @HasEpicSide);
select last_insert_id();" ,
("MastermindName", mastermind.Name),
("HasEpicSide", mastermind.HasEpicSide))
.QuerySingleAsync <ulong>()));
// Add to game package
await connector.Command(
$@"
insert
into {TableNames.GamePackageMasterminds}
({DatabaseDefinition.ColumnName[MastermindField.MastermindId]}, {GamePackageUtility.DatabaseDefinition.ColumnName[GamePackageField.Id]})
values (@MastermindId, @GamePackageId);" ,
("MastermindId", newMastermindId),
("GamePackageId", mastermind.GamePackageId))
.ExecuteAsync();
// Link abilities
foreach (var abilityId in mastermind.AbilityIds)
{
await connector.Command(
$@"
insert
into {TableNames.MastermindAbilities}
({DatabaseDefinition.ColumnName[MastermindField.MastermindId]}, {AbilityUtility.DatabaseDefinition.ColumnName[AbilityField.Id]})
values (@MastermindId, @AbilityId);" ,
("MastermindId", newMastermindId),
("AbilityId", abilityId))
.ExecuteAsync();
}
// Add card requirements
foreach (var requirement in mastermind.CardRequirements)
{
var cardRequirementId = await CardRequirementUtility.AddCardRequirement(requirement);
await connector.Command(
$@"
insert
into {TableNames.MatchedCardRequirements}
({CardRequirementUtility.DatabaseDefinition.ColumnName[CardRequirement.OwnerIdFieldNumber]}, {CardRequirementUtility.DatabaseDefinition.ColumnName[CardRequirement.CardRequirementIdFieldNumber]}, NumberOfPlayers, {cardSetTypeInfo.Name})
values (@OwnerId, @CardRequirementId, @NumberOfPlayers, @{cardSetTypeInfo.Name});" ,
("OwnerId", newMastermindId),
("CardRequirementId", cardRequirementId),
("NumberOfPlayers", requirement.PlayerCount),
(cardSetTypeInfo.Name, cardSetTypeInfo.Value))
.ExecuteAsync();
}
newMastermindIds.Add(newMastermindId);
}
// Get all of the created masterminds
var finalRequest = new GetMastermindsRequest();
finalRequest.MastermindIds.AddRange(newMastermindIds);
var finalReply = await GetMastermindsAsync(finalRequest, context);
reply.Status = finalReply.Status;
reply.Masterminds.AddRange(finalReply.Masterminds);
return(reply);
}
public override async Task <CreateMastermindsReply> CreateMasterminds(CreateMastermindsRequest request, ServerCallContext context)
{
return(await MastermindUtility.CreateMastermindsAsync(request, context));
}
