public void MoveCard(string gamePin, MoveCardModel moveCardModel)
{
Status status = GameManager.MoveCard(gamePin, moveCardModel);
if (status == Status.Success)
{
Clients.Group(gamePin).MoveCard(moveCardModel);
//Delete source pile if it is empty and a run pile
Pile oldPile = GameManager.GetGameState(gamePin).Single((pile) => pile.PileNo == moveCardModel.SourcePileNo);
if (oldPile.GetCards().Count() == 0 && oldPile.PileType == PileType.Run)
{
DeleteEmptyRunPile(gamePin, oldPile);
}
}
else
{
//TODO: Pile version issues...
IEnumerable <Pile> piles = GameManager.GetGameState(gamePin);
Clients.Caller.StartGame(piles);
//MoveRejected(moveCardModel.TargetPileVersionNo, moveCardModel.TargetPileNo, moveCardModel.TargetIndex,
// moveCardModel.SourcePileVersionNo, moveCardModel.SourcePileNo, moveCardModel.SourceIndex);
}
}
public void MoveCardShouldUpdateVersionNumberOfSourcePileAndTargetPileTest()
{
//Arrange
GameManager.AddPlayerToGame(GamePin, NickNamePlayerOne, ConnIdPlayerOne);
GameManager.StartGame(GamePin, ConnIdPlayerOne);
IEnumerable <Pile> piles = GameManager.GetGameState(GamePin);
Pile deck = piles.First((pile) => pile.PileType == PileType.Deck);
Pile BoHand = piles.First((pile) => pile.PileType == PileType.Hand);
int sourcePileVersionNo = deck.VersionNo;
int sourcePileNo = deck.PileNo;
int sourceIndex = deck.GetCards().Count() - 1;
int targetPileVersionNo = BoHand.VersionNo;
int targetPileNo = BoHand.PileNo;
int targetIndex = 0;
MoveCardModel moveCardModel = new MoveCardModel(sourcePileVersionNo, sourcePileNo, sourceIndex, targetPileVersionNo, targetPileNo, targetIndex);
Card deckCard0 = deck.GetCards().ElementAt(sourceIndex);
//Act
GameManager.MoveCard(GamePin, moveCardModel);
//Assert
Assert.AreEqual(1, deck.VersionNo);
Assert.AreEqual(1, BoHand.VersionNo);
Assert.AreEqual(deck.VersionNo, moveCardModel.SourcePileVersionNo);
Assert.AreEqual(BoHand.VersionNo, moveCardModel.TargetPileVersionNo);
CollectionAssert.DoesNotContain(deck.GetCards().ToList(), deckCard0);
Assert.AreEqual(deckCard0, BoHand.GetCards().ElementAt(0));
}
public ReturnModel MoveCardToLane([FromBody] MoveCardModel model, string accessToken)
{
var account = _readOnlyRepository.First <Account>(account1 => account1.Token == accessToken);
ReturnModel remodel = new ReturnModel();
if (account != null)
{
if (account.VerifyToken(account))
{
var card = _readOnlyRepository.GetById <Cards>(model.Id);
Cards card1 = new Cards();
card1.Text = card.Text;
card1.Description = card.Description;
var line = _readOnlyRepository.GetById <Lines>(model.IdLineTo);
line.AddCard(card1);
var archivedCard = _writeOnlyRepository.Archive(card);
var updateLine = _writeOnlyRepository.Update(line);
Activity activity = new Activity();
activity.Text = account.FirstName + " Movio la card " + card.Text + " a la line: " + line.Title;
account.AddActivities(activity);
var accountUpdate = _writeOnlyRepository.Update(account);
return(remodel.ConfigureModel("Successfull", "Se movio correctamente la card", remodel));
}
return(remodel.ConfigureModel("Error", "Su session ya expiro", remodel));
}
return(remodel.ConfigureModel("Error", "No se pudo acceder a su cuenta", remodel));
}
public async Task <IActionResult> MoveCard([FromBody] MoveCardModel command)
{
await _boardService.MoveAsync(command.CardId, command.ColumnId);
return(Ok(new
{
Moved = true
}));
}
public void MoveCardToLastIndexSamePileTest()
{
//Arrange
string gamePin = GameManager.CreateNewGame("testName");
GameRoom GameRoom = GameManager.GetGameRoomWithPin(gamePin);
string connId = "connId";
GameManager.AddPlayerToGame(gamePin, "Bo", connId);
GameManager.StartGame(gamePin, connId);
int sourcePileVersionNo = 0,
sourcePileNo = 0,
sourceIndex = 0,
targetPileVersionNo = 0,
targetPileNo = 1,
targetIndex = 0;
MoveCardModel moveCardModel = new MoveCardModel(sourcePileVersionNo, sourcePileNo, sourceIndex, targetPileVersionNo, targetPileNo, targetIndex);
GameManager.MoveCard(gamePin, moveCardModel);
GameManager.MoveCard(gamePin, moveCardModel);
GameManager.MoveCard(gamePin, moveCardModel);
moveCardModel.SourcePileNo = 1;
moveCardModel.TargetIndex = 2;
IEnumerable <Pile> piles = GameManager.GetGameState(gamePin);
//Act
Card boHandCard0 = piles.ElementAt(1).GetCards().ElementAt(0);
Card boHandCard1 = piles.ElementAt(1).GetCards().ElementAt(1);
Card boHandCard2 = piles.ElementAt(1).GetCards().ElementAt(2);
GameManager.MoveCard(gamePin, moveCardModel);
Pile deck = piles.ElementAt(0);
Pile boHand = piles.ElementAt(1);
//Assert
Assert.AreEqual(3, deck.VersionNo);
Assert.AreEqual(4, boHand.VersionNo);
Assert.AreEqual(boHand.VersionNo, moveCardModel.SourcePileVersionNo);
Assert.AreEqual(boHand.VersionNo, moveCardModel.TargetPileVersionNo);
Assert.AreEqual(3, boHand.GetCards().Count());
Assert.AreEqual(boHandCard0, boHand.GetCards().ElementAt(2));
Assert.AreEqual(boHandCard1, boHand.GetCards().ElementAt(0));
Assert.AreEqual(boHandCard2, boHand.GetCards().ElementAt(1));
}
public Status MoveCard(string gamePin, MoveCardModel moveCardModel)
{
Status status = Status.None;
GameRoom gameRoom = GetGameRoomWithPin(gamePin);
if (gameRoom != null)
{
if (gameRoom.MoveCard(moveCardModel))
{
status = Status.Success;
}
else
{
status = Status.InvalidMoveError;
}
}
else
{
status = Status.GameNotFoundError;
}
return(status);
}
private bool validateMove(Pile sourcePile, Pile targetPile, MoveCardModel moveToValidate)
{
bool sourcePileVersionIsValid = moveToValidate.SourcePileVersionNo == sourcePile.VersionNo;
bool targetPileVersionIsValid = moveToValidate.TargetPileVersionNo == targetPile.VersionNo;
bool sourceIndexIsValid = moveToValidate.SourceIndex >= 0 && moveToValidate.SourceIndex <= sourcePile.Cards.Count() - 1;
bool targetIndexIsValid;
if (targetPile != sourcePile)
{
targetIndexIsValid = moveToValidate.TargetIndex >= 0 && moveToValidate.TargetIndex <= targetPile.Cards.Count();
}
else //Source and Target pile are the same
{
targetIndexIsValid = moveToValidate.TargetIndex >= 0 && moveToValidate.TargetIndex <= targetPile.Cards.Count() - 1;
}
#if BREAK_MOVE
return(true);
#else
return(sourcePileVersionIsValid && targetPileVersionIsValid && sourceIndexIsValid && targetIndexIsValid);
#endif
}
public bool MoveCard(MoveCardModel moveCardModel)
{
bool result = false;
Pile sourcePile = Piles.Find(pile => pile.PileNo == moveCardModel.SourcePileNo);
Pile targetPile = Piles.Find(pile => pile.PileNo == moveCardModel.TargetPileNo);
try {
if (Monitor.TryEnter(sourcePile))
{
#if DELAY_MOVE
if (Monitor.TryEnter(ConcurrencyIssueLock))
{
Debug.WriteLine("Paused with move " + moveCardModel.ToString());
Thread.Sleep(5000);
Debug.WriteLine("Continueing paused move...");
Monitor.Exit(ConcurrencyIssueLock);
}
#endif
#if BREAK_MOVE
}
else
{
Debug.WriteLine("Skipping pause for move " + moveCardModel.ToString());
}
{ //To match closing bracket
#endif
if (targetPile != sourcePile)
{
if (Monitor.TryEnter(targetPile) && validateMove(sourcePile, targetPile, moveCardModel))
{
Card cardToMove = sourcePile.RemoveCard(moveCardModel.SourceIndex);
targetPile.AddCard(moveCardModel.TargetIndex, cardToMove);
sourcePile.VersionNo++;
targetPile.VersionNo++;
moveCardModel.SourcePileVersionNo = sourcePile.VersionNo;
moveCardModel.TargetPileVersionNo = targetPile.VersionNo;
result = true;
#if BREAK_MOVE
Debug.WriteLine("Made move " + moveCardModel.ToString());
#endif
}
}
else //Source and Target pile are the same
{
if (validateMove(sourcePile, targetPile, moveCardModel))
{
Card cardToMove = sourcePile.RemoveCard(moveCardModel.SourceIndex);
sourcePile.AddCard(moveCardModel.TargetIndex, cardToMove);
sourcePile.VersionNo++;
moveCardModel.SourcePileVersionNo = sourcePile.VersionNo;
moveCardModel.TargetPileVersionNo = sourcePile.VersionNo;
result = true;
#if BREAK_MOVE
Debug.WriteLine("Made move " + moveCardModel.ToString());
#endif
}
}
}
}
catch (Exception e) {
#if BREAK_MOVE
Debug.WriteLine("Excepiton during move " + moveCardModel.ToString());
#endif
Debug.WriteLine(e.Message);
}
finally {
if (Monitor.IsEntered(sourcePile))
{
Monitor.Exit(sourcePile);
}
if (Monitor.IsEntered(targetPile))
{
Monitor.Exit(targetPile);
}
}
return(result);
}
