public Task <Guid> OrderAttack(IBatchOperationHandle batchOperationHandleInterface, Guid sessionId, Guid phaseId, Guid sourceRegion, String sourceRegionEtag, Guid targetRegion, UInt32 numberOfTroops)
{
BatchOperationHandle batchOperationHandle = batchOperationHandleInterface as BatchOperationHandle;
CloudTable commandQueueTable = GetCommandQueueTableForSession(sessionId);
Guid operationId = Guid.NewGuid();
TableOperation operation = TableOperation.Retrieve <CommandQueueTableEntry>(sessionId.ToString(), "Command_" + sourceRegion.ToString() + "_" + targetRegion.ToString());
var orderAttackTask = commandQueueTable.ExecuteAsync(operation)
.ContinueWith(getExistingTask =>
{
TableResult getExistingResult = getExistingTask.Result;
if (getExistingResult.Result != null)
{
// Update existing entry
CommandQueueTableEntry existingCommand = getExistingResult.Result as CommandQueueTableEntry;
existingCommand.OperationId = operationId;
existingCommand.RawNumberOfTroops += (int)numberOfTroops;
// Kick off update operation
batchOperationHandle.BatchOperation.Replace(existingCommand);
}
else
{
// Create a new table entry
CommandQueueTableEntry newCommand = CommandQueueTableEntry.CreateAttackMessage(operationId, sessionId, phaseId, sourceRegion, sourceRegionEtag, targetRegion, numberOfTroops);
// Kick off the insert operation
batchOperationHandle.BatchOperation.Insert(newCommand);
}
});
batchOperationHandle.AddPrerequisite(orderAttackTask, 1);
return(Task.FromResult(operationId));
}
public void RemoveCommands(IBatchOperationHandle batchOperationHandle, IEnumerable <ICommandQueueMessage> messages)
{
foreach (var message in messages)
{
RemoveCommand(batchOperationHandle, message);
}
}
public void SetAvailableReinforcements(IBatchOperationHandle batchOperationHandle, Guid sessionId, string userId, string currentEtag, uint reinforcements)
{
DummySession foundSession = SessionRepository.SessionMap[sessionId];
DummyBatchOperationHandle batchOperation = batchOperationHandle as DummyBatchOperationHandle;
if (foundSession != null)
{
DummyNationData foundPlayer = foundSession.Players.Find(player => player.UserId == userId);
if (foundPlayer != null)
{
batchOperation.QueuedOperations.Add(() =>
{
foundPlayer.AvailableReinforcements = reinforcements;
});
}
else
{
throw new InvalidOperationException("Called MarkPlayerCompletedPhase with a non-existent user id");
}
}
else
{
throw new InvalidOperationException("Called JoinSession with a non-existent GUID");
}
}
public void AddArmyToCombat(IBatchOperationHandle batchOperationHandleInterface, ICombat combat, IEnumerable <ICombatArmy> armies)
{
DummyCombat dummyCombat = combat as DummyCombat;
foreach (ICombatArmy army in armies)
{
dummyCombat.SetupAddArmy(army.OriginRegionId, army.OwnerUserId, army.ArmyMode, army.NumberOfTroops);
}
}
public void RemoveCommands(IBatchOperationHandle batchOperationHandle, IEnumerable <ICommandQueueMessage> commands)
{
lock (batchOperationHandle)
{
foreach (var command in commands)
{
RemoveCommand(batchOperationHandle, command);
}
}
}
public void RemoveCommand(IBatchOperationHandle batchOperationHandle, ICommandQueueMessage command)
{
lock (batchOperationHandle)
{
TableBatchOperation batchOperation = (batchOperationHandle as BatchOperationHandle).BatchOperation;
CommandQueueTableEntry commandQueueEntry = command as CommandQueueTableEntry;
commandQueueEntry.IsValid();
batchOperation.Delete(commandQueueEntry);
}
}
public void RemoveCommand(IBatchOperationHandle batchOperationHandle, ICommandQueueMessage message)
{
DummyBatchOperationHandle dummyBatch = batchOperationHandle as DummyBatchOperationHandle;
dummyBatch.QueuedOperations.Add(() =>
{
DummyDeployReinforcementsQueue.RemoveAll(queuedMessage => message.OperationId == queuedMessage.OperationId);
DummyOrderAttackQueue.RemoveAll(queuedMessage => message.OperationId == queuedMessage.OperationId);
DummyRedeployQueue.RemoveAll(queuedMessage => message.OperationId == queuedMessage.OperationId);
});
}
public void AssignRegionOwnership(IBatchOperationHandle batchOperationHandleInterface, Guid sessionId, Dictionary <Guid, OwnershipChange> ownershipChanges)
{
BatchOperationHandle batchOperationHandle = batchOperationHandleInterface as BatchOperationHandle;
// Get the session data table
CloudTable sessionDataTable = SessionRepository.GetTableForSessionData(TableClient, sessionId);
// Fetch all regions (quicker than fetching only what we need, one by one)
var updateRegionOwnershipTask = GetRegions(sessionId)
.ContinueWith(regionTask => { AssignRegionOwnership(batchOperationHandleInterface, regionTask.Result, ownershipChanges); });
batchOperationHandle.AddPrerequisite(updateRegionOwnershipTask, ownershipChanges.Count);
}
public void SetAvailableReinforcements(IBatchOperationHandle batchOperationHandleInterface, Guid sessionId, String userId, String currentEtag, UInt32 reinforcements)
{
BatchOperationHandle batchOperationHandle = batchOperationHandleInterface as BatchOperationHandle;
// Get the session data table
CloudTable sessionDataTable = SessionRepository.GetTableForSessionData(TableClient, sessionId);
// Create a DynamicTableEntity so that we can do a partial update of this table (a merge)
DynamicTableEntity nationEntry = NationTableEntry.CreateDynamicTableEntity(sessionId, userId, currentEtag);
NationTableEntry.SetAvailableReinforcements(nationEntry, reinforcements);
batchOperationHandle.BatchOperation.Merge(nationEntry);
}
private void SetCardInternal(IBatchOperationHandle batchOperationHandleInterface, Guid sessionId, Guid regionId, CardTableEntry.State newState, String newOwnerId, String currentEtag)
{
BatchOperationHandle batchOperationHandle = batchOperationHandleInterface as BatchOperationHandle;
// Get the session data table
CloudTable sessionDataTable = SessionRepository.GetTableForSessionData(TableClient, sessionId);
// Create a DynamicTableEntity so that we can do a partial update of this table (a merge)
DynamicTableEntity cardEntry = CardTableEntry.CreateDynamicTableEntity(sessionId, regionId, currentEtag);
CardTableEntry.SetOwner(cardEntry, newState, newOwnerId);
batchOperationHandle.BatchOperation.Merge(cardEntry);
}
public void CommitTroopsToPhase(IBatchOperationHandle batchOperationHandleInterface, IRegionData sourceRegion, UInt32 troopsToCommit)
{
BatchOperationHandle batchOperationHandle = batchOperationHandleInterface as BatchOperationHandle;
RegionTableEntry region = sourceRegion as RegionTableEntry;
if (region != null && region.TroopCount > region.TroopsCommittedToPhase + troopsToCommit)
{
region.StoredTroopsCommittedToPhase += (int)troopsToCommit;
batchOperationHandle.BatchOperation.Replace(region);
}
else
{
throw new InvalidOperationException();
}
}
public void AddCombat(IBatchOperationHandle batchOperationHandleInterface, Guid sessionId, UInt32 round, IEnumerable <Tuple <CombatType, IEnumerable <ICombatArmy> > > armies)
{
BatchOperationHandle batchOperationHandle = batchOperationHandleInterface as BatchOperationHandle;
// Insert armies
List <Guid> createdCombatIds = new List <Guid>();
foreach (var armyEntry in armies)
{
Guid combatId = Guid.NewGuid();
CombatTableEntry entry = new CombatTableEntry(sessionId, round, combatId, armyEntry.Item1);
entry.SetCombatArmy(armyEntry.Item2);
batchOperationHandle.BatchOperation.Insert(entry);
createdCombatIds.Add(combatId);
}
}
public void CreateRegion(IBatchOperationHandle batchOperationHandleInterface, Guid sessionId, Guid regionId, Guid continentId, String name, IEnumerable <Guid> connectedRegions, UInt32 cardValue)
{
DummyBatchOperationHandle batchOperationHandle = batchOperationHandleInterface as DummyBatchOperationHandle;
batchOperationHandle.QueuedOperations.Add(() =>
{
RegionData[regionId] = new DummyRegionData(sessionId, regionId, continentId, String.Empty, cardValue);
foreach (Guid connectedRegion in connectedRegions)
{
RegionData[regionId].ConnectedRegionIds.Add(connectedRegion);
}
});
batchOperationHandle.QueuedOperations.Add(() =>
{
CardData[regionId] = new DummyCardData(regionId, cardValue);
});
}
public void CommitTroopsToPhase(IBatchOperationHandle batchOperationHandleInterface, IRegionData sourceRegion, UInt32 troopsToCommit)
{
DummyBatchOperationHandle batchOperationHandle = batchOperationHandleInterface as DummyBatchOperationHandle;
DummyRegionData region = sourceRegion as DummyRegionData;
if (region != null && region.TroopCount > region.TroopsCommittedToPhase + troopsToCommit)
{
batchOperationHandle.QueuedOperations.Add(() =>
{
region.TroopsCommittedToPhase += troopsToCommit;
});
}
else
{
throw new InvalidOperationException("Invalid arguments passed");
}
}
public void AddArmyToCombat(IBatchOperationHandle batchOperationHandleInterface, ICombat combat, IEnumerable <ICombatArmy> armies)
{
BatchOperationHandle batchOperationHandle = batchOperationHandleInterface as BatchOperationHandle;
CombatTableEntry combatEntry = combat as CombatTableEntry;
combatEntry.IsValid();
List <ICombatArmy> existingArmies = combat.InvolvedArmies.ToList();
foreach (var army in armies)
{
existingArmies.Add(new CombatArmy(army.OriginRegionId, army.OwnerUserId, army.ArmyMode, army.NumberOfTroops));
}
combatEntry.SetCombatArmy(existingArmies);
batchOperationHandle.BatchOperation.Replace(combatEntry);
}
public Task ResetDiscardedCards(IBatchOperationHandle batchOperationHandle, Guid sessionId)
{
DummyBatchOperationHandle batchOperation = batchOperationHandle as DummyBatchOperationHandle;
List <ICardData> results = new List <ICardData>();
foreach (DummyCardData card in RegionRepository.CardData.Values)
{
if (card.OwnerId == DummyCardData.UsedCard)
{
batchOperation.QueuedOperations.Add(() =>
{
card.OwnerId = DummyCardData.UnownedCard;
});
results.Add(card);
}
}
return(Task.FromResult(0));
}
public void CreateRegion(IBatchOperationHandle batchOperationHandleInterface, Guid sessionId, Guid regionId, Guid continentId, String name, IEnumerable <Guid> connectedRegions, UInt32 cardValue)
{
BatchOperationHandle batchOperationHandle = batchOperationHandleInterface as BatchOperationHandle;
// Create a new table entry
RegionTableEntry newRegion = new RegionTableEntry(sessionId, regionId, continentId, name, cardValue);
newRegion.IsValid();
newRegion.SetConnectedRegions(connectedRegions);
batchOperationHandle.BatchOperation.Insert(newRegion);
// Create a new card for this region
CardTableEntry newCard = new CardTableEntry(sessionId, regionId);
newCard.IsValid();
newCard.ValueRaw = (Int32)cardValue;
batchOperationHandle.BatchOperation.Insert(newCard);
}
public void AddCombat(IBatchOperationHandle batchOperationHandleInterface, Guid sessionId, UInt32 round, IEnumerable <Tuple <CombatType, IEnumerable <ICombatArmy> > > armies)
{
List <Guid> createdCombatIds = new List <Guid>();
foreach (var combatData in armies)
{
Guid combatId = Guid.NewGuid();
DummyCombat combat = new DummyCombat(combatId, combatData.Item1);
createdCombatIds.Add(combatId);
foreach (ICombatArmy army in combatData.Item2)
{
combat.SetupAddArmy(army.OriginRegionId, army.OwnerUserId, army.ArmyMode, army.NumberOfTroops);
}
DummyBatchOperationHandle batchOperationHandle = batchOperationHandleInterface as DummyBatchOperationHandle;
batchOperationHandle.QueuedOperations.Add(() =>
{
// Add to lookup
AddToCombatLookup(combat);
// Add to typed storage
switch (combat.ResolutionType)
{
case CombatType.BorderClash:
BorderClashes[combatId] = combat;
break;
case CombatType.MassInvasion:
MassInvasions[combatId] = combat;
break;
case CombatType.Invasion:
Invasions[combatId] = combat;
break;
case CombatType.SpoilsOfWar:
SpoilsOfWar[combatId] = combat;
break;
}
});
}
}
public Task <Guid> OrderAttack(IBatchOperationHandle batchOperationHandle, Guid sessionId, Guid phaseId, Guid sourceRegion, String sourceRegionEtag, Guid targetRegion, UInt32 numberOfTroops)
{
DummyBatchOperationHandle batchOperation = batchOperationHandle as DummyBatchOperationHandle;
Guid operationId = Guid.NewGuid();
batchOperation.QueuedOperations.Add(() =>
{
DummyOrderAttackQueue.Add(new DummyOrderAttack
{
OperationId = operationId,
PhaseId = phaseId,
SourceRegion = sourceRegion,
SourceRegionEtag = sourceRegionEtag,
TargetRegion = targetRegion,
NumberOfTroops = numberOfTroops
});
});
return(Task.FromResult(operationId));
}
public async Task ResetDiscardedCards(IBatchOperationHandle batchOperationHandleInterface, Guid sessionId)
{
// Get the session data table
CloudTable sessionDataTable = SessionRepository.GetTableForSessionData(TableClient, sessionId);
var rowKeyCondition = TableQuery.CombineFilters(
TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.GreaterThanOrEqual, "Card_"),
TableOperators.And,
TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.LessThan, "Card`")
);
var ownerStateCondition = TableQuery.CombineFilters(
rowKeyCondition,
TableOperators.And,
TableQuery.GenerateFilterConditionForInt("OwnerStateRaw", QueryComparisons.Equal, (Int32)CardTableEntry.State.Discarded)
);
List <ICardData> results = new List <ICardData>();
TableQuery <CardTableEntry> query = new TableQuery <CardTableEntry>()
.Where(TableQuery.CombineFilters(
TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, sessionId.ToString()),
TableOperators.And,
ownerStateCondition
));
// Initialize the continuation token to null to start from the beginning of the table.
TableContinuationToken continuationToken = null;
// Loop until the continuation token comes back as null
do
{
var queryResults = await sessionDataTable.ExecuteQuerySegmentedAsync(query, continuationToken);
continuationToken = queryResults.ContinuationToken;
results.AddRange(queryResults.Results);
}while (continuationToken != null);
foreach (CardTableEntry entry in results)
{
entry.IsValid();
SetCardInternal(batchOperationHandleInterface, sessionId, entry.RegionId, CardTableEntry.State.Unowned, String.Empty, entry.ETag);
}
}
public void AssignRegionOwnership(IBatchOperationHandle batchOperationHandleInterface, IEnumerable <IRegionData> regions, Dictionary <Guid, OwnershipChange> ownershipChanges)
{
BatchOperationHandle batchOperationHandle = batchOperationHandleInterface as BatchOperationHandle;
// Get NationTableEntry for every player that needs updating
var updateOperations = from ownershipChange in ownershipChanges
join region in regions.Cast <RegionTableEntry>() on ownershipChange.Key equals region.RegionId
select new { Region = region, NewOwner = ownershipChange.Value.UserId, NewTroopCount = (Int32)ownershipChange.Value.TroopCount };
// Modify entries as required
foreach (var operation in updateOperations)
{
RegionTableEntry regionEntry = operation.Region;
regionEntry.IsValid();
regionEntry.OwnerId = operation.NewOwner;
regionEntry.StoredTroopCount = operation.NewTroopCount;
regionEntry.StoredTroopsCommittedToPhase = 0;
batchOperationHandle.BatchOperation.Replace(regionEntry);
}
}
public void SetCardOwner(IBatchOperationHandle batchOperationHandle, Guid sessionId, Guid regionId, String userId, String currentEtag)
{
DummySession foundSession = SessionRepository.SessionMap[sessionId];
if (foundSession != null)
{
DummyNationData foundPlayer = foundSession.Players.Find(player => player.UserId == userId);
if (foundPlayer != null)
{
SetCardOwnerInternal(batchOperationHandle, sessionId, regionId, userId, currentEtag);
}
else
{
throw new InvalidOperationException("Called SetCardOwner with a non-existent user id");
}
}
else
{
throw new InvalidOperationException("Called SetCardOwner with a non-existent session id");
}
}
public async Task <Guid> PostAttack(Guid sessionId, Guid regionId, uint numberOfTroops, Guid targetRegionId)
{
IRegionData sourceRegion = await RegionRepository.GetRegionOrThrow(sessionId, regionId)
.IsRegionOwnerOrThrow(User.Identity.GetUserId());
ISession session = await SessionRepository.GetSessionOrThrow(sourceRegion)
.IsUserIdJoinedOrThrow(NationRepository, User.Identity.GetUserId())
.IsPhaseTypeOrThrow(SessionPhase.CombatOrders);
IRegionData targetRegion = await RegionRepository.GetRegionOrThrow(session.GameId, targetRegionId)
.IsNotRegionOwnerOrThrow(User.Identity.GetUserId())
.IsRegionConnectedOrThrow(sourceRegion.RegionId);
if (sourceRegion.TroopCount <= (sourceRegion.TroopsCommittedToPhase + numberOfTroops))
{
throw new HttpResponseException(new HttpResponseMessage {
StatusCode = HttpStatusCode.BadRequest, ReasonPhrase = "You do not have that many troops available to attack with"
});
}
else if (numberOfTroops <= 0)
{
throw new HttpResponseException(new HttpResponseMessage {
StatusCode = HttpStatusCode.BadRequest, ReasonPhrase = "You can not attack with less than 1 troop"
});
}
else
{
Guid orderGuid;
using (IBatchOperationHandle batchOperation = SessionRepository.StartBatchOperation(session.GameId))
{
var queueAttackTask = CommandQueue.OrderAttack(batchOperation, session.GameId, session.PhaseId, sourceRegion.RegionId, sourceRegion.CurrentEtag, targetRegion.RegionId, numberOfTroops);
RegionRepository.CommitTroopsToPhase(batchOperation, sourceRegion, numberOfTroops);
await batchOperation.CommitBatch();
orderGuid = await queueAttackTask;
}
return(orderGuid);
}
}
public void AssignRegionOwnership(IBatchOperationHandle batchOperationHandleInterface, IEnumerable <IRegionData> regions, Dictionary <Guid, OwnershipChange> ownershipChanges)
{
DummyBatchOperationHandle batchOperationHandle = batchOperationHandleInterface as DummyBatchOperationHandle;
foreach (var change in ownershipChanges)
{
if (RegionData.ContainsKey(change.Key))
{
DummyRegionData regionData = RegionData[change.Key];
batchOperationHandle.QueuedOperations.Add(() =>
{
regionData.OwnerId = change.Value.UserId;
regionData.TroopCount = change.Value.TroopCount;
regionData.TroopsCommittedToPhase = 0;
regionData.GenerateNewEtag();
});
}
else
{
throw new InvalidOperationException("Invalid region id specified");
}
}
}
public void SetCardOwnerInternal(IBatchOperationHandle batchOperationHandle, Guid sessionId, Guid regionId, String userId, String currentEtag)
{
DummySession foundSession = SessionRepository.SessionMap[sessionId];
if (foundSession != null)
{
if (RegionRepository.CardData.ContainsKey(regionId))
{
DummyBatchOperationHandle batchOperation = batchOperationHandle as DummyBatchOperationHandle;
batchOperation.QueuedOperations.Add(() =>
{
RegionRepository.CardData[regionId].OwnerId = userId;
});
}
else
{
throw new InvalidOperationException("Called SetCardOwner with a non-existent region id");
}
}
else
{
throw new InvalidOperationException("Called SetCardOwner with a non-existent session id");
}
}
public void AssignRegionOwnership(IBatchOperationHandle batchOperationHandleInterface, Guid sessionId, Dictionary <Guid, OwnershipChange> ownershipChanges)
{
IEnumerable <IRegionData> regions = null;
AssignRegionOwnership(batchOperationHandleInterface, regions, ownershipChanges);
}
public void SetCardOwner(IBatchOperationHandle batchOperationHandleInterface, Guid sessionId, Guid regionId, string userId, string currentEtag)
{
SetCardInternal(batchOperationHandleInterface, sessionId, regionId, CardTableEntry.State.Owned, userId, currentEtag);
}
public async Task PostCards(Guid sessionId, IEnumerable <Guid> cards)
{
ISession session = await SessionRepository.GetSessionOrThrow(sessionId)
.IsUserIdJoinedOrThrow(NationRepository, User.Identity.GetUserId())
.IsPhaseTypeOrThrow(SessionPhase.Reinforcements);
Task <INationData> nationDataTask = NationRepository.GetNationOrThrow(sessionId, User.Identity.GetUserId());
Task <IEnumerable <ICardData> > playerCardsTask = NationRepository.GetCards(sessionId, User.Identity.GetUserId());
if (cards == null)
{
throw new HttpResponseException(new HttpResponseMessage {
StatusCode = HttpStatusCode.BadRequest, ReasonPhrase = "Invalid card(s) specified"
});
}
HashSet <Guid> cardRegionIds = new HashSet <Guid>();
foreach (Guid cardRegionId in cards)
{
if (cardRegionIds.Contains(cardRegionId))
{
throw new HttpResponseException(new HttpResponseMessage {
StatusCode = HttpStatusCode.BadRequest, ReasonPhrase = "Duplicate card(s) specified"
});
}
else if (cardRegionIds.Count >= 3)
{
throw new HttpResponseException(new HttpResponseMessage {
StatusCode = HttpStatusCode.BadRequest, ReasonPhrase = "Too many card(s) specified"
});
}
else
{
cardRegionIds.Add(cardRegionId);
}
}
if (cardRegionIds.Count != 3)
{
throw new HttpResponseException(new HttpResponseMessage {
StatusCode = HttpStatusCode.BadRequest, ReasonPhrase = "Too few card(s) specified"
});
}
using (IBatchOperationHandle batchOperation = SessionRepository.StartBatchOperation(sessionId))
{
IEnumerable <ICardData> playerCards = await playerCardsTask;
HashSet <UInt32> seenValues = new HashSet <UInt32>();
foreach (ICardData card in playerCards)
{
if (cardRegionIds.Contains(card.RegionId))
{
NationRepository.SetCardDiscarded(batchOperation, sessionId, card.RegionId, card.CurrentEtag);
seenValues.Add(card.Value);
}
}
UInt32 additionalReinforcements = 0;
if (seenValues.Count == 1)
{
additionalReinforcements = seenValues.First();
}
else if (seenValues.Count == 3)
{
additionalReinforcements = 9;
}
else
{
await batchOperation.Abort();
throw new HttpResponseException(new HttpResponseMessage {
StatusCode = HttpStatusCode.BadRequest, ReasonPhrase = "Invalid combination of card(s) specified"
});
}
INationData nation = await nationDataTask;
NationRepository.SetAvailableReinforcements(batchOperation, sessionId, nation.UserId, nation.CurrentEtag, nation.AvailableReinforcements + additionalReinforcements);
await batchOperation.CommitBatch();
}
}
public void SetCardDiscarded(IBatchOperationHandle batchOperation, Guid sessionId, Guid regionId, string currentEtag)
{
SetCardOwnerInternal(batchOperation, sessionId, regionId, DummyCardData.UsedCard, currentEtag);
}
public void SetCardDiscarded(IBatchOperationHandle batchOperationHandleInterface, Guid sessionId, Guid regionId, string currentEtag)
{
SetCardInternal(batchOperationHandleInterface, sessionId, regionId, CardTableEntry.State.Discarded, String.Empty, currentEtag);
}
