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); }