public void AttachToStack(CardStack s, Future IsLocalPlayer)
{
var c = this;
if (c.CurrentStack != null)
{
c.CurrentStack.Cards.Remove(c);
}
c.PreviousStack = c.CurrentStack;
c.CurrentStack = s;
s.Cards.Add(c);
if (this.Moved != null)
this.Moved();
// if the IsLocalPlayer is null then we are not meant to raise MovedByLocalPlayer
if (IsLocalPlayer != null)
IsLocalPlayer.Continue(
delegate
{
if (this.MovedByLocalPlayer != null)
this.MovedByLocalPlayer();
}
);
}
void Awake()
{
numberOfPlayer = 4;
currentPlayer = 0;
currentRank = 0;
pauseMenu.SetActive(false);
specialMessage.gameObject.SetActive(false);
guideMsg.gameObject.SetActive(false);
players = new List<Player>();
dealer = GameObject.Find("Dealer").GetComponent<CardStack>();
for (int i = 0; i < numberOfPlayer; i++)
{
string playerObjectString = "Player" + (i + 1).ToString();
Player player = GameObject.Find(playerObjectString).GetComponent<Player>();
player.playerStack = player.GetComponent<CardStack>();
player.isHuman = i == 0 ? true : false;
player.localPlayer = i == 0 ? true : false;
player.isPlayerTurn = false;
player.playerTurn = player.playerIndex = i;
player.PlayerName = playerObjectString;
player.playerStack.cardRemoved += CardStack_cardRemoved;
player.callDoubt += Player_callDoubt;
if (i == 0) { player.RealName = "Neptune"; }
if (i == 1) { player.RealName = "Noire"; }
if (i == 2) { player.RealName = "Blanc"; }
if (i == 3) { player.RealName = "Vert"; }
players.Add(player);
}
}
public void TestNullValues()
{
var stack = new CardStack();
Assert.IsNull(stack.TopCard);
Assert.IsNull(stack.TopSuit);
Assert.IsNull(stack.TopValue);
}
public Card TransferCard(Card card, CardStack newStack)
{
if (HasCard)
{
int position = -1;
for (int i = 0; i < cards.Count; i++)
{
if (card.id == cards[i].id)
{
position = i;
break;
}
}
Card result = cards[position];
if (cardRemoved != null)
{
cardRemoved(this, new CardRemovedEventArgs(result.id, newStack));
}
cards.RemoveAt(position);
return result;
}
return null;
}
private CardStack CreateCardStack()
{
// generate list of cards
var cards = new LinkedList<Card>();
foreach (var color in Enum.GetValues(typeof(CardColor)).OfType<CardColor>())
foreach (var filling in Enum.GetValues(typeof(Filling)).OfType<Filling>())
foreach (var shape in Enum.GetValues(typeof(Shape)).OfType<Shape>())
for (byte shapeIndex = 0; shapeIndex < 3; shapeIndex++)
cards.AddLast(new Card()
{
Color = color,
Filling = filling,
Shape = shape,
ShapeCount = (byte) (shapeIndex + 1)
});
// shake cards
var shakedCards = new CardStack();
Random rnd = new Random(23);
for (int cardsIndex = cards.Count - 1; cardsIndex >= 0; cardsIndex--)
{
var cardIndexToMove = (int)Math.Floor(cardsIndex * rnd.NextDouble());
var cardToMove = cards.Skip(cardIndexToMove).Take(1).Single();
shakedCards.Push(cardToMove);
cards.Remove(cardToMove);
}
return shakedCards;
}
// Use this for initialization
void Start()
{
cardStack = GetComponent<CardStack>();
fetchedCard = new Dictionary<int, GameObject>();
stackLastCount = cardStack.Size;
cardStack.cardRemoved += CardStack_cardRemoved;
// Get the game object's position to put the cards on
startTime = Time.time;
startingPos = transform.position;
scale = new Vector3(1f, 1f, 1f);
if (cardStack.isGameStack)
{
scale = new Vector3(1.25f, 1.25f, 1.25f);
}
else if (cardStack.transform.ToString().Contains("Player1"))
{
scale = new Vector3(1.75f, 1.75f, 1.75f);
}
else
{
scale = new Vector3(0.75f, 0.75f, 0.75f);
}
ShowCards(false);
}
void Awake () {
fetchedCards = new Dictionary<int, CardView> ();
deck = GetComponent<CardStack> ();
ShowCards ();
lastCount = deck.cardCount;
deck.CardRemoved += deck_CardRemoved;
deck.CardAdded += Deck_CardAdded;
}
void Start()
{
fetchedCards = new Dictionary<int, GameObject>();
deck = GetComponent<CardStack>();
ShowCards();
lastCount = deck.CardCount;
deck.CardRemoved += deck_CardRemoved;
}
public void TestTopValue()
{
var card = new PlayingCard(PlayingCard.CardFace.Eight, PlayingCard.CardSuit.Hearts);
var stack = new CardStack();
stack.Push(card);
Assert.AreEqual(8, stack.TopValue);
}
public void MoveAllCardsToStack(CardStack cardStack, bool flat)
{
Stack tempStack = new Stack();
while (!IsEmpty) {
tempStack.Push(Pop());
}
while (tempStack.Count > 0) {
cardStack.Push(tempStack.Pop() as Card, flat);
}
}
public void BuyCard(CardStack cardStack)
{
Card card = cardStack.Peek();
Debug.Log("Attempting to buy card " + card.name);
if (card.Cost <= money && buys > 0)
{
guiManager.ChangeMode(new BuyMode(this));
Debug.Log("Actually buying it.");
rubbishStack.Push(cardStack.Pop());
buys--;
money -= card.Cost;
}
}
public CardMoveToStackEventArgs(
CardModel cardModel,
CardStack cardStack,
Vector3 position,
bool flip,
int indexFrom,
int indexTo)
{
this.cardModel = cardModel;
this.cardStack = cardStack;
this.position = position;
this.flip = flip;
this.indexFrom = indexFrom;
this.indexTo = indexTo;
}
public Player(int initMoney, Client newClient)
{
money = initMoney;
bet = 0;
busted = false;
playerCardStack = new CardStack();
playerClient = newClient;
playerNum = newClient.GetClientNumber();
isPlaying = true;
}
private void Deal()
{
for (int i = 0; i < 4; i++)
{
player.Push(deck.Pop());
botLeft.Push(deck.Pop());
botTop.Push(deck.Pop());
botRight.Push(deck.Pop());
}
player.flipCards(new RangeInt(0, 4), true);
turnMarker.moveToPlayer(0);
currentPlayer = player;
playerClickState = GameState.Ready;
}
public void AddCardToPlay(CardStack cardStack, CardModel cardModel)
{
// TODO: RESTORE THIS
//if (CardGameManager.Current.CardClearsBackground)
// CardGameManager.Instance.BannerImage.gameObject.SetActive(false);
if (NetworkManager.singleton.isNetworkActive)
{
CGSNetManager.Instance.LocalPlayer.MoveCardToServer(cardStack, cardModel);
}
else
{
SetPlayActions(cardStack, cardModel);
}
}
public void Show(CardStack stack)
{
gameObject.SetActive(true);
transform.SetAsLastSibling();
Resize();
if (!EventSystem.current.alreadySelecting)
{
EventSystem.current.SetSelectedGameObject(gameObject);
}
Sync(stack);
contentCardZone.scrollRectContainer.horizontalNormalizedPosition = 0;
}
public void CardStackUnitTest()
{
if (TestInfrastructure.IsActive(TestContext))
{
using (Dictionary dictionary = TestInfrastructure.GetConnection(TestContext))
{
DictionaryTest.FillDictionary(dictionary);
CardStack target = new CardStack(new LearnLogic(MLifterTest.DAL.OpenUserProfileTests.GetUserAdmin, (MLifter.DAL.DataAccessErrorDelegate) delegate { return; }));
target.StackChanged += new EventHandler(CardStack_StackChanged);
cardstackChanged = false;
target.Clear();
Assert.IsTrue(cardstackChanged, "CardStackChanged event did not fire for Clear.");
int cardcount = 0;
int rightcount = 0;
TimeSpan duration = new TimeSpan(0);
foreach (ICard card in dictionary.Cards.Cards)
{
for (int i = 0; i < 100; i++)
{
cardcount++;
bool promoted = GetRandBool();
if (promoted)
{
rightcount++;
}
DateTime asked = DateTime.Now - new TimeSpan(0, 0, random.Next(1000));
DateTime answered = DateTime.Now;
duration += (answered - asked);
AnswerResult result = promoted ? AnswerResult.Correct : AnswerResult.Wrong;
StackCard stackCard = new StackCard(card, result, promoted, EQueryDirection.Question2Answer, LearnModes.Word, asked, answered, Thread.CurrentThread.CurrentCulture, Thread.CurrentThread.CurrentCulture, card.Answer.ToString(), 0, 0, false, dictionary, 0);
cardstackChanged = false;
target.Push(stackCard);
Assert.IsTrue(cardstackChanged, "CardStackChanged event did not fire for Push.");
}
}
Assert.AreEqual(cardcount, target.Count, "Not all cards were added to the stack.");
Assert.AreEqual(duration, target.SessionDuration, "Session duration sum does not match.");
Assert.AreEqual(rightcount, target.RightCount, "RightCount does not match.");
Assert.AreEqual(cardcount - rightcount, target.WrongCount, "WrongCount does not match.");
Assert.IsTrue(rightcount > 0 && target.VisibleStack.Count > 0, "No StackCards in VisibleStack property.");
}
}
}
private static void PrintCardStack(CardStack deck)
{
Console.WriteLine($"STACK: {deck.Orientation} ({deck.Count}) =============");
for (int i = 0; i < deck.Count; i++)
{
Console.Write($"{deck.Contents[i]} ");
if (i % 13 == 12)
{
Console.WriteLine();
}
}
if (deck.Count % 12 != 0)
{
Console.WriteLine();
}
}
/// <summary>
/// Initializes a new War player with the specified initial hand.
/// </summary>
/// <param name="initialHand">Player's initial hand.</param>
public Player(CardStack initialHand)
{
if (initialHand.Orientation != CardStackOrientation.FaceDown)
{
throw new ArgumentException(
"Orientation of player hand must be face down.");
}
if (initialHand.Count != 26)
{
throw new ArgumentException(
"Player hand should contain 26 cards.");
}
Hand = initialHand;
}
/// <summary>
/// Finds a stack that the card could play on. Returns the stack,
/// if no stack found, then returns null.
/// </summary>
/// <param name="card"></param>
/// <returns></returns>
public CardStack FindStack(Card card)
{
CardStack stackFound = null;
foreach (CardStack stack in stacks)
{
if (stack.GetSuit() == card.CardSuit)
{
if ((int)stack.GetTopValue() == (int)card.CardValue - 1)
{
stackFound = stack;
}
}
}
return(stackFound);
}
public Card TransferCard(int position, CardStack newStack)
{
if (HasCard)
{
Card result = cards[position];
if (cardRemoved != null)
{
cardRemoved(this, new CardRemovedEventArgs(result.id, newStack));
}
cards.RemoveAt(position);
return result;
}
return null;
}
/// <summary>
/// creates a new hold em poker game
/// </summary>
/// <param name="userid">id of system user</param>
/// <returns>new holdem game</returns>
public HoldemGame CreateGame(long userid, int bet)
{
HoldemGame game = games[userid] = new HoldemGame
{
PlayerID = userid,
Bet = bet,
Pot = bet,
Deck = CardStack.Fresh(),
Muck = new CardStack(),
Board = new Board(),
PlayerHand = new Board(),
DealerHand = new Board()
};
return(game);
}
public CardPlayer()
{
hand = new CardZone();
discardPile = new CardStack()
{
isDiscardZone = true
};
destroyedPile = new CardStack()
{
isDestroyZone = true
};
drawPile = new CardStack()
{
resuplyFrom = discardPile
};
}
/// <summary>
/// Double le pari et le joueur tire une carte
/// </summary>
public void DoubleDown()
{
Player tempP = GetHuman();
CardStack.PlayerDrawCard(tempP);
tempP.GetGameType <IBlackjackAction>().PlayerStand = true;
if (Bet * 2 > tempP.Money)
{
Bet += tempP.Money;
tempP.Money = 0;
return;
}
CheckBust(tempP.GetGameType <IBlackjackAction>(), GetHuman());
tempP.Money -= Bet;
Bet *= 2;
}
private static PatienceField Move(PatienceField field, CardStack from, CardStack to)
{
if (from == null || to == null)
{
Console.WriteLine("Invalid move: unknown stack");
return field;
}
var cardToMove = from.GetMovableCards().FirstOrDefault(c => to.CanAccept(c, from));
if (cardToMove == null)
{
Console.WriteLine("Invalid move: none of the cards on from can enter destination");
return field;
}
return field.Move(cardToMove, from, to);
}
public Card TransferCard(int position, CardStack newStack)
{
if (HasCard)
{
Card result = cards[position];
if (cardRemoved != null)
{
cardRemoved(this, new CardRemovedEventArgs(result.id, newStack));
}
cards.RemoveAt(position);
return(result);
}
return(null);
}
public GameManager()
{
cardstack = new CardStack ();
cardStatus = new CardStatus ();
CardAxisX = new float[12];
CardAxisY = new float[2];
CardExist = new bool[12,2];
for(int i=0;i<12;i++)
for(int j=0;j<2;j++)
CardExist[i,j] = false;
CardAxisY[0] = -3.75f;
CardAxisY[1] = -5f;
getCardAxisX ();
turing = 0;
takeCard = false;
}
void Awake()
{
numberOfPlayer = 4;
currentPlayer = 0;
currentRank = 0;
pauseMenu.SetActive(false);
specialMessage.gameObject.SetActive(false);
guideMsg.gameObject.SetActive(false);
players = new List <Player>();
dealer = GameObject.Find("Dealer").GetComponent <CardStack>();
for (int i = 0; i < numberOfPlayer; i++)
{
string playerObjectString = "Player" + (i + 1).ToString();
Player player = GameObject.Find(playerObjectString).GetComponent <Player>();
player.playerStack = player.GetComponent <CardStack>();
player.isHuman = i == 0 ? true : false;
player.localPlayer = i == 0 ? true : false;
player.isPlayerTurn = false;
player.playerTurn = player.playerIndex = i;
player.PlayerName = playerObjectString;
player.playerStack.cardRemoved += CardStack_cardRemoved;
player.callDoubt += Player_callDoubt;
if (i == 0)
{
player.RealName = "Neptune";
}
if (i == 1)
{
player.RealName = "Noire";
}
if (i == 2)
{
player.RealName = "Blanc";
}
if (i == 3)
{
player.RealName = "Vert";
}
players.Add(player);
}
}
public void GIVEN_a_card_stack_WHEN_AddRange_is_called_with_a_card_THEN_card_is_added()
{
// Arrange
var fakeCard1 = new FakeCard(1, null);
var fakeCard2 = new FakeCard(2, null);
var fakeCards = new List <ICard> {
fakeCard1, fakeCard2
};
var cardStack = new CardStack();
// Act
cardStack.AddRange(fakeCards);
var result = cardStack.HasCards();
// Assert
Assert.IsTrue(result);
}
void PlayCard()
{
// for bot only
if (transform.parent.ToString().Contains("Player"))
{
CardStack dealer = GameObject.Find("Dealer").GetComponent <CardStack>();
Player player = transform.parent.GetComponent <Player>();
if (player.isPlayerTurn &&
!player.isHuman &&
!player.playerStack.isGameStack)
{
//dealer.Add(player.playerStack.Remove(card));
dealer.Add(player.playerStack.TransferCard(card, dealer));
}
}
}
public void TestSort()
{
Card kingOfDiamonds = new Card(CardSuit.Diamonds, CardRank.King);
Card deuceOfDiamonds = new Card(CardSuit.Diamonds, CardRank.Deuce);
Card fiveOfHearts = new Card(CardSuit.Hearts, CardRank.Five);
Card sixOfSpades = new Card(CardSuit.Spades, CardRank.Six);
CardStack stack =
CardStack.GetEmptyStack(CardStackOrientation.FaceDown);
stack.AddCard(kingOfDiamonds);
stack.AddCard(deuceOfDiamonds);
stack.AddCard(fiveOfHearts);
stack.AddCard(sixOfSpades);
//facedown sort by suit/rank
stack.Sort(Card.COMPARE_SUIT_RANK);
Assert.AreEqual(fiveOfHearts, stack.Contents[0]);
Assert.AreEqual(sixOfSpades, stack.Contents[1]);
Assert.AreEqual(deuceOfDiamonds, stack.Contents[2]);
Assert.AreEqual(kingOfDiamonds, stack.Contents[3]);
//face up sort by suit/rank
stack.Flip();
stack.Sort(Card.COMPARE_SUIT_RANK);
Assert.AreEqual(fiveOfHearts, stack.Contents[0]);
Assert.AreEqual(sixOfSpades, stack.Contents[1]);
Assert.AreEqual(deuceOfDiamonds, stack.Contents[2]);
Assert.AreEqual(kingOfDiamonds, stack.Contents[3]);
//face down sort by rank/suit
stack.Flip();
stack.Sort(Card.COMPARE_RANK_SUIT);
Assert.AreEqual(deuceOfDiamonds, stack.Contents[0]);
Assert.AreEqual(fiveOfHearts, stack.Contents[1]);
Assert.AreEqual(sixOfSpades, stack.Contents[2]);
Assert.AreEqual(kingOfDiamonds, stack.Contents[3]);
//face up sort by rank/suit
stack.Flip();
stack.Sort(Card.COMPARE_RANK_SUIT);
Assert.AreEqual(deuceOfDiamonds, stack.Contents[0]);
Assert.AreEqual(fiveOfHearts, stack.Contents[1]);
Assert.AreEqual(sixOfSpades, stack.Contents[2]);
Assert.AreEqual(kingOfDiamonds, stack.Contents[3]);
}
public void TestCardDeckGetsMaximumFourCards()
{
CardStack stack = new CardStack();
CardDeck deck = new CardDeck();
stack.AddPackage(_package);
stack.AddPackage(_package);
deck.AddCard(stack.CardCollection[0]);
deck.AddCard(stack.CardCollection[1]);
deck.AddCard(stack.CardCollection[2]);
deck.AddCard(stack.CardCollection[3]);
deck.RemoveCard(deck.CardCollection[2]);
deck.AddCard(stack.CardCollection[4]);
Assert.AreEqual(4, deck.CardCollection.Count);
}
void Awake()
{
if ((Type == StackType.Boss && _bossInstance != null) || (Type == StackType.Buff && _buffInstance != null))
{
Destroy(gameObject);
return;
}
if (Type == StackType.Buff)
{
_buffInstance = this;
}
if (Type == StackType.Boss)
{
_bossInstance = this;
}
}
public void Initialize()
{
sourceToModify = new TestCardStack();
sourceToCompare = new TestCardStack();
destinationToModify = new TestCardStack();
destinationToCompare = new TestCardStack();
for (int i = 0; i < stackSize; i++)
{
Card rand1 = RandomCard.GetRandomCard();
Card rand2 = RandomCard.GetRandomCard();
sourceToCompare.CardList.Add(rand1);
sourceToModify.CardList.Add(rand1);
destinationToCompare.CardList.Add(rand2);
destinationToModify.CardList.Add(rand2);
}
}
public void GIVEN_a_card_stack_with_two_cards_WHEN_top_card_is_called_THEN_last_card_added_is_returned()
{
// Arrange
var fakeCard1 = new FakeCard(1, null);
var fakeCard2 = new FakeCard(2, null);
var cardStack = new CardStack();
cardStack.Add(fakeCard1);
cardStack.Add(fakeCard2);
// Act
var result = cardStack.TopCard();
// Assert
Assert.IsNotNull(result);
Assert.AreEqual("Fake2", result.Name);
}
private void PlayersDrawCards()
{
foreach (var player in ListPlayers)
{
player.Hand.Add(CardStack.DrawCard());
player.Hand.Add(CardStack.DrawCard());
}
//if (PlayerRoles[3] > 0) // pas mal sur que ca va planter si playerroles.length <= 3
// // en fait ca sert a quoi? le foreach en haut devrait pogner toute les playerroles
//{
// foreach (var player in ListPlayers)
// {
// player.GetHand().Add(CardStack.DrawCard());
// player.GetHand().Add(CardStack.DrawCard());
// }
//}
}
// TODO: Abstract a lot of this out into a new SolitaireGameBuilder class.
public SolitaireGame()
{
StatusMessages = new List <string>();
deck = new DeckBuilder().BuildDeck(true);
drawStack = new CardStack(true);
drawer = new SolitaireDrawer();
columns = new List <StackColumn>();
// Create 7 stacks of face down cards.
for (int i = 0; i < 7; i++)
{
CardStack stack = new CardStack(false);
StackColumn column = new StackColumn();
column.FaceDownStack = stack;
columns.Add(column);
}
// Distribute the cards across the stacks.
for (int i = 0; i < 7; i++)
{
for (int ii = i; ii < 7; ii++)
{
CardStack stack = columns[ii].FaceDownStack;
Card drawnCard = deck.DrawCard();
stack.Add(drawnCard);
}
}
// Transfer top cards to their own stacks.
for (int i = 0; i < columns.Count; i++)
{
StackColumn column = columns[i];
CardStack faceDownStack = column.FaceDownStack;
CardStack faceUpStack = new CardStack(true);
Card topCard = faceDownStack.DrawCard();
faceUpStack.Add(topCard);
column.FaceUpStack = faceUpStack;
}
TransferCardToDrawStack();
}
private bool canMoveCards(CardStack movingStack, CardStack destStack)
{
Card movingCompareCard, receivingCompareCard;
movingCompareCard = movingStack[movingStack.Count - 1];
if (destStack.Count > 0)
{
receivingCompareCard = destStack[destStack.Count - 1];
bool isAlternatingSuit = movingCompareCard.IsRed != receivingCompareCard.IsRed;
bool isOneValueLower = movingCompareCard.Value == receivingCompareCard.Value - 1;
return(isOneValueLower && isAlternatingSuit);
}
else
{
return(true);
}
}
public void GIVEN_a_card_stack_that_has_cards_WHEN_clear_is_called_THEN_stack_has_no_cards()
{
// Arrange
var fakeCard1 = new FakeCard(1, null);
var fakeCard2 = new FakeCard(2, null);
var fakeCards = new List <ICard> {
fakeCard1, fakeCard2
};
var cardStack = new CardStack();
cardStack.AddRange(fakeCards);
// Act
cardStack.Clear();
var result = cardStack.HasCards();
// Assert
Assert.IsFalse(result);
}
private void Awake()
{
Log("Welcome to Sumoga");
InitPlayer();
// create a world
_world = new World(
new world.Score()
);
// initialize game card stack
var gameCards = card.Utils.LoadCards();
cardStack = new CardStack(gameCards);
var gameItems = inventory.Utils.LoadItems();
shop = new Shop(gameItems);
}
public void Sync(CardStack stack)
{
_cardStack = stack;
nameLabel.text = _cardStack.Name;
contentCardZone.transform.DestroyAllChildren();
var cards = _cardStack.Cards.Reverse().ToList();
var cardModelIndex = cards.Count - 1;
foreach (var unityCard in cards)
{
var cardModel = Instantiate(cardModelPrefab, contentCardZone.transform).GetOrAddComponent <CardModel>();
cardModel.Value = unityCard;
cardModel.Index = cardModelIndex;
cardModelIndex--;
}
countLabel.text = _cardStack.Cards.Count.ToString();
}
// Start is called before the first frame update
void Start()
{
render = gameObject.GetComponent <RenderCard>();
storeCard = new CardStack(true);
cam = GameObject.FindGameObjectWithTag("MainCamera").GetComponent <Camera>();
selectedDeck = null;
prevInteractable = null;
if (onCardPickup == null)
{
onCardPickup = new UnityEvent <Interactable, Card>();
}
if (onCardPlace == null)
{
onCardPlace = new UnityEvent <Interactable, Interactable>();
}
}
public void ResetCardStacks()
{
Clear();
layoutContent.DestroyAllChildren();
CardStacks.Clear();
for (int i = 0; i < CardStackCount; i++)
{
CardStack newCardStack = Instantiate(cardStackPrefab, layoutContent).GetOrAddComponent <CardStack>();
newCardStack.type = CardStackType.Vertical;
newCardStack.scrollRectContainer = scrollRect;
newCardStack.DoesImmediatelyRelease = true;
newCardStack.OnAddCardActions.Add(OnAddCardModel);
newCardStack.OnRemoveCardActions.Add(OnRemoveCardModel);
CardStacks.Add(newCardStack);
newCardStack.GetComponent <VerticalLayoutGroup>().spacing = cardStackPrefab.GetComponent <VerticalLayoutGroup>().spacing
*(CardGameManager.PixelsPerInch * CardGameManager.Current.CardSize.y / PreHeight);
}
layoutContent.sizeDelta = new Vector2(cardStackPrefab.GetComponent <RectTransform>().rect.width *CardStacks.Count,
layoutContent.sizeDelta.y);
}
public GameManager()
{
cardstack = new CardStack();
cardStatus = new CardStatus();
CardAxisX = new float[12];
CardAxisY = new float[2];
CardExist = new bool[12, 2];
for (int i = 0; i < 12; i++)
{
for (int j = 0; j < 2; j++)
{
CardExist[i, j] = false;
}
}
CardAxisY[0] = -3.75f;
CardAxisY[1] = -5f;
getCardAxisX();
turing = 0;
takeCard = false;
}
private void MoveSelectedCardsToStack(ArrayList cardList, CardStack stack)
{
foreach (Card card in cardList)
{
stack.Push(card);
}
ReorderCards();
}
public void doFlyCardsFromStackToStack(CardStack start, CardStack destination, int noCards)
{
if (onFlyCardsFromStackToStack != null)
onFlyCardsFromStackToStack(start, destination, noCards);
}
public SpiderGame(CardInfo.SuitEnum[] level)
{
Width = DefaultWidth;
Height = DefaultHeight;
//this.ClipTo(0, 0, DefaultWidth, DefaultHeight);
var GameOverBox = new TextBox
{
Width = DefaultWidth,
TextAlignment = System.Windows.TextAlignment.Center,
Foreground = Brushes.White,
Background = Brushes.Transparent,
BorderThickness = new Thickness(0),
IsReadOnly = true,
FontSize = 24,
}.MoveTo(0, DefaultHeight / 2).AttachTo(this);
GameOver += delegate
{
GameOverBox.Text = "Congratulations! You Won!";
};
// add autoscroll ?
this.MyDeck.SizeTo(DefaultWidth, DefaultHeight);
this.MyDeck.AttachContainerTo(this);
this.MyDeck.GetRank = e => (int)RankMapping[e];
this.MyDeck.CardCustomBackgroundSource = new Abstractatech.Avalon.Cards.Avalon.Images.spider().Source;
//this.MyDeck.Overlay.Opacity = 0.6;
MyStatus = new StatusControl().AttachContainerTo(this).MoveContainerTo(
(DefaultWidth - StatusControl.Width) / 2,
(DefaultHeight - StatusControl.Height)
);
MyStatus.Container.Hide();
System.Console.WriteLine("--- spider ---");
System.Console.WriteLine("adding card infos... ");
MyDeck.UnusedCards.AddRange(CardInfo.By(2, level));
System.Console.WriteLine("creating stacklists... ");
DealStacks = MyDeck.CreateStackList();
PlayStacks = MyDeck.CreateStackList();
DeadStacks = MyDeck.CreateStackList();
PlayStacks.ListChanged +=
(sender, args) =>
{
if (args.ListChangedType == ListChangedType.ItemAdded)
{
var s = PlayStacks[args.NewIndex];
}
};
DeadStacks.ListChanged +=
(sender, args) =>
{
if (args.ListChangedType == ListChangedType.ItemAdded)
{
var s = DeadStacks[args.NewIndex];
//s.Control.Hide();
s.CardMargin = new Vector { X = 2, Y = 0 };
s.Cards.ListChanged +=
(sender2, args2) =>
{
if (args2.ListChangedType == ListChangedType.ItemAdded)
{
//s[args2.NewIndex].Enabled = false;
}
};
}
};
#region drag rules
MyDeck.ApplyCardRules += delegate(Card c)
{
c.Moved +=
delegate
{
if (c.StackedCards.Length == 0)
{
CheckForGoodSuit(c.CurrentStack);
MyStatus.Moves++;
MyStatus.Score--;
MyStatus.Update();
}
CheckForWin();
};
c.ValidateDragStart +=
delegate
{
if (Cheat)
return true;
return c.SelectedCards.AllWithPrevious(
(Previous, Current) =>
{
if (Previous.Info.Suit != Current.Info.Suit)
return false;
return Previous.Rank + 1 == Current.Rank;
}
);
};
c.ValidateDragStop +=
CandidateStack =>
{
if (Cheat)
return true;
if (PlayStacks.Contains(CandidateStack))
{
if (CandidateStack.Cards.Count == 0)
return true;
var Candidate = CandidateStack.Last();
// we do not care about the suit
if (c.Rank == Candidate.Rank + 1)
//if (c.Info.Suit == Candidate.Info.Suit)
return true;
return false;
}
return false;
};
};
#endregion
System.Console.WriteLine("creating playstack... ");
var Margin = (DefaultWidth - CardInfo.Width * 10) / 11;
PlayStacks.AddRange(
Enumerable.Range(0, 10).ToArray(
i =>
new CardStack
{
Name = "PlayStack " + i,
CardMargin = new Vector { Y = 20 }
}.MoveTo(
Margin + i * (CardInfo.Width + Margin),
Margin + 40
).Apply(
s =>
{
if (i < 4)
s.Cards.AddRange(MyDeck.FetchCards(5));
else
s.Cards.AddRange(MyDeck.FetchCards(4));
if (Cheat)
s.Cards.ForEach(k => k.VisibleSide = Card.SideEnum.TopSide);
}
)
)
);
PlayStacks.ForEach(
delegate(CardStack s)
{
s.Cards.ListChanged +=
(sender, args) =>
{
if (args.ListChangedType == ListChangedType.ItemDeleted)
//if (MyStatus.Ready)
s.RevealLastCard();
};
}
);
DealStacks.ListChanged +=
(sender, args) =>
{
if (args.ListChangedType == ListChangedType.ItemAdded)
{
var s = DealStacks[args.NewIndex];
s.CardMargin = new Vector { Y = 0, X = 0 };
s.Update();
s.Click +=
delegate
{
if (DealStacks.Contains(s))
{
//if (MyStatus.Ready)
DealRow(null);
}
else
{
System.Console.WriteLine("whoops wrong stack click - " + args.NewIndex);
}
};
}
};
System.Console.WriteLine("creating dealstack... ");
var dealpoint = new Point
{
X = DefaultWidth - CardInfo.Width - Margin,
Y = DefaultHeight - CardInfo.Height - Margin - 17 - Margin
};
while (MyDeck.UnusedCards.Count > 0)
{
var s = new CardStack { MyDeck.FetchCards(10) };
//s.Overlay.Opacity = 1;
s.Name = "DealStack";
DealStacks.Add(
s.MoveTo(Convert.ToInt32(dealpoint.X), Convert.ToInt32(dealpoint.Y))
);
dealpoint.X -= 10;
}
// we will collect cards here
DeadStacks.Add(new CardStack().MoveTo(Margin, Convert.ToInt32(dealpoint.Y)));
DealRow(
delegate
{
MyStatus.Score = 500;
MyStatus.Moves = 0;
MyStatus.Update();
MyStatus.Container.Show();
}
);
}
public SolitaireGame()
{
Width = DefaultWidth;
Height = DefaultHeight;
System.Console.WriteLine("--- solitare ---");
this.MyStatus = new StatusControl().AttachContainerTo(this).MoveContainerTo(
(DefaultWidth - StatusControl.Width) / 2,
(DefaultHeight - StatusControl.Height)
);
var GameOverBox = new TextBox
{
Width = DefaultWidth,
TextAlignment = System.Windows.TextAlignment.Center,
Foreground = Brushes.White,
Background = Brushes.Transparent,
BorderThickness = new Thickness(0),
IsReadOnly = true,
FontSize = 24,
}.MoveTo(0, DefaultHeight / 2).AttachTo(this);
// add autoscroll ?
this.MyDeck.SizeTo(DefaultWidth, DefaultHeight);
this.MyDeck.AttachContainerTo(this);
this.MyDeck.GetRank = e => (int)RankMapping[e];
System.Console.WriteLine("adding card infos... ");
MyDeck.UnusedCards.AddRange(CardInfo.FullDeck());
this.MyStatus.Score = -1;
this.MyStatus.CardsLeft = this.MyDeck.UnusedCards.Count;
this.MyStatus.Update();
MyDeck.Stacks.ListChanged +=
(sender, args) =>
{
if (args.ListChangedType == ListChangedType.ItemAdded)
{
// fixme: dynamically set backside for this card
//var s = MyDeck.Stacks[args.NewIndex];
//s.SetBackground(MyDeck.GfxPath + "/spider.empty.png");
}
};
System.Console.WriteLine("creating stacklists... ");
PlayStacks = MyDeck.CreateStackList();
TempStacks = MyDeck.CreateStackList();
GoalStacks = MyDeck.CreateStackList();
PlayStacks.ForEachNewItem(
delegate(CardStack s)
{
s.CardMargin = new Vector { Y = 20 };
s.Update();
s.Cards.ListChanged +=
(sender, args) =>
{
if (args.ListChangedType == ListChangedType.ItemDeleted)
s.RevealLastCard();
};
}
);
GameOver += delegate
{
GameOverBox.Text = "Congratulations! You Won!";
};
System.Console.WriteLine("creating goalstack... ");
var Margin = (DefaultWidth - CardInfo.Width * 7) / 8;
var ReserveStack = new CardStack().MoveTo(Margin, Margin);
var UsedChoiceStack = new CardStack().MoveTo(Margin + CardInfo.Width + Margin, Margin);
var ChoiceStack = new CardStack().MoveTo(Margin + CardInfo.Width + Margin, Margin);
TempStacks.AddRange(
ReserveStack,
UsedChoiceStack,
ChoiceStack
);
ReserveStack.CardMargin.X = 0;
ReserveStack.CardMargin.Y = 0;
UsedChoiceStack.CardMargin.X = 0;
UsedChoiceStack.CardMargin.Y = 0;
ChoiceStack.CardMargin.X = 20;
ChoiceStack.CardMargin.Y = 0;
#region rules
Func<bool> Rule_WinConditionMet =
delegate
{
if (PlayStacks.All(s => s.Cards.Count > 0))
return false;
if (TempStacks.All(s => s.Cards.Count == 0))
return false;
return true;
};
Func<Card, Card, bool> RuleForStackingCardsInGoalStack =
(Previous, Current) =>
{
if (Cheat)
return true;
if (Previous == null)
return Current.Info.Rank == CardInfo.RankEnum.RankAce;
if (Previous.Info.Suit != Current.Info.Suit)
return false;
if (Previous.Rank != Current.Rank + 1)
return false;
return true;
};
Func<Card, Card, bool> RuleForStackingCardsInPlayStack =
(Previous, Current) =>
{
if (Cheat)
return true;
if (Previous.Info.SuitColor == Current.Info.SuitColor)
return false;
if (Previous.Rank + 1 != Current.Rank)
return false;
return true;
};
#endregion
MyDeck.ApplyCardRules += delegate(Card card)
{
card.MovedByLocalPlayer +=
delegate
{
MyStatus.Moves++;
MyStatus.Update();
};
card.ValidateDragStart =
delegate
{
if (Cheat)
return true;
// cannot remove cards from goal stack
if (GoalStacks.Contains(card))
return false;
if (TempStacks.Contains(card))
{
return (card == ChoiceStack.LastOrDefault());
}
// cannot drag a pile of cards unless alternate colors and descending numbers
return card.SelectedCards.AllWithPrevious(RuleForStackingCardsInPlayStack);
};
card.ValidateDragStop =
CandidateStack =>
{
if (Cheat)
return true;
if (TempStacks.Contains(CandidateStack))
{
return false;
}
if (PlayStacks.Contains(CandidateStack))
{
if (CandidateStack.Cards.Count == 0)
return card.Info.Rank == CardInfo.RankEnum.RankKing;
return (RuleForStackingCardsInPlayStack(CandidateStack.Cards.Last(), card));
}
if (GoalStacks.Contains(CandidateStack))
{
if (card.StackedCards.Length > 0)
return false;
return (RuleForStackingCardsInGoalStack(CandidateStack.Cards.LastOrDefault(), card));
}
return false;
};
};
GoalStacks.ForEachNewItem(
s =>
{
s.CardMargin.X = 0;
s.CardMargin.Y = 0;
s.Cards.ForEachNewItem(
card =>
{
this.MyStatus.CardsLeft--;
this.MyStatus.Update();
if (card.Info.Rank == CardInfo.RankEnum.RankKing)
{
card.VisibleSide = Card.SideEnum.BackSide;
if (Rule_WinConditionMet())
{
// winner!
MyDeck.Sounds.win();
if (this.GameOver != null)
this.GameOver();
}
}
}
);
}
);
GoalStacks.AddRange(
Enumerable.Range(0, 4).ToArray(
i => new CardStack().MoveTo(DefaultWidth - ((CardInfo.Width + Margin) * 4) + i * (CardInfo.Width + Margin), Margin)
)
);
System.Console.WriteLine("creating playstack... ");
PlayStacks.AddRange(
Enumerable.Range(0, 7).ToArray(
i => new CardStack().MoveTo(Margin + i * (CardInfo.Width + Margin), Margin * 3 + CardInfo.Height).Apply(s => s.Cards.AddRange(MyDeck.FetchCards(i + 1)))
)
);
ReserveStack.Cards.AddRange(MyDeck.FetchCards(MyDeck.UnusedCards.Count));
ReserveStack.Update();
PlayStacks.ForEach(k => k.Last().VisibleSide = Card.SideEnum.TopSide);
UsedChoiceStack.Cards.ForEachNewItem(
card => card.VisibleSide = Card.SideEnum.BackSide
);
ChoiceStack.Cards.ForEachNewItem(
card => card.VisibleSide = Card.SideEnum.TopSide
);
ChoiceStack.Click +=
delegate
{
ChoiceStack.Update();
}
;
ReserveStack.Overlay.Cursor = Cursors.Hand;
ReserveStack.Cards.ForEachNewItem(
card => card.VisibleSide = Card.SideEnum.BackSide
);
var ReserveStackEnabled = true;
ReserveStack.Click +=
delegate
{
if (!ReserveStackEnabled)
return;
if (ReserveStack.Cards.Count == 0)
{
MyDeck.Sounds.deal();
ChoiceStack.FirstOrDefault().Apply(
card =>
{
card.AnimatedMoveToStack(ReserveStack, null, null);
}
);
UsedChoiceStack.FirstOrDefault().Apply(
card =>
{
card.AnimatedMoveToStack(ReserveStack, null, null);
}
);
}
else
{
ReserveStackEnabled = false;
ChoiceStack.Cards.ToArray().ForEach(
card =>
{
card.AttachToStack(UsedChoiceStack);
}
);
UsedChoiceStack.Update();
3.Times(
SignalNext =>
ReserveStack.LastOrDefault().Apply(
card =>
{
card.BringToFront();
Console.WriteLine(card.ToString());
card.AnimatedMoveToStack(ChoiceStack, null, null);
MyDeck.Sounds.deal();
200.AtDelay(SignalNext);
}
)
);
}
// a timepoint when movements are done.. this should ba an event actually
2000.AtDelay(() => ReserveStackEnabled = true);
};
}
/// <summary>
/// Initializes a new instance of the <see cref="LearnLogic"/> class.
/// </summary>
/// <remarks>Documented by Dev02, 2008-04-22</remarks>
public LearnLogic(GetLoginInformation getLoginDelegate, DataAccessErrorDelegate dataAccessErrorDelegate)
{
GetLoginDelegate = getLoginDelegate;
DataAccessErrorDelegate = dataAccessErrorDelegate;
cardStack = new CardStack(this);
this.LearningModuleOpened += new EventHandler(LearnLogic_LearningModuleOpened);
this.user = new User(this);
this.CardStack.StackChanged += new EventHandler(CardStack_StackChanged);
}
public override void Move(Card c, CardStack s)
{
throw new NotImplementedException();
}
public void CardStackUnitTest()
{
if (TestInfrastructure.IsActive(TestContext))
{
using (Dictionary dictionary = TestInfrastructure.GetConnection(TestContext))
{
DictionaryTest.FillDictionary(dictionary);
CardStack target = new CardStack(new LearnLogic(MLifterTest.DAL.OpenUserProfileTests.GetUserAdmin, (MLifter.DAL.DataAccessErrorDelegate)delegate { return; }));
target.StackChanged += new EventHandler(CardStack_StackChanged);
cardstackChanged = false;
target.Clear();
Assert.IsTrue(cardstackChanged, "CardStackChanged event did not fire for Clear.");
int cardcount = 0;
int rightcount = 0;
TimeSpan duration = new TimeSpan(0);
foreach (ICard card in dictionary.Cards.Cards)
{
for (int i = 0; i < 100; i++)
{
cardcount++;
bool promoted = GetRandBool();
if (promoted)
rightcount++;
DateTime asked = DateTime.Now - new TimeSpan(0, 0, random.Next(1000));
DateTime answered = DateTime.Now;
duration += (answered - asked);
AnswerResult result = promoted ? AnswerResult.Correct : AnswerResult.Wrong;
StackCard stackCard = new StackCard(card, result, promoted, EQueryDirection.Question2Answer, LearnModes.Word, asked, answered, Thread.CurrentThread.CurrentCulture, Thread.CurrentThread.CurrentCulture, card.Answer.ToString(), 0, 0, false, dictionary, 0);
cardstackChanged = false;
target.Push(stackCard);
Assert.IsTrue(cardstackChanged, "CardStackChanged event did not fire for Push.");
}
}
Assert.AreEqual(cardcount, target.Count, "Not all cards were added to the stack.");
Assert.AreEqual(duration, target.SessionDuration, "Session duration sum does not match.");
Assert.AreEqual(rightcount, target.RightCount, "RightCount does not match.");
Assert.AreEqual(cardcount - rightcount, target.WrongCount, "WrongCount does not match.");
Assert.IsTrue(rightcount > 0 && target.VisibleStack.Count > 0, "No StackCards in VisibleStack property.");
}
}
}
private static void CompareSlots(CardStack cardStack1, CardStack cardStack2)
{
if (cardStack1.TopSuit == cardStack2.TopSuit)
{
if (cardStack1.TopValue.HasValue && cardStack2.TopValue.HasValue)
{
if (cardStack1.TopValue > cardStack2.TopValue)
{
cardStack2.Pop();
}
else
{
cardStack1.Pop();
}
}
}
}
public void AnimatedMoveToStack(CardStack CandidateStack, Future GroupMovedByLocalPlayer, FutureStream Chain)
{
Chain.Continue(
SignalNext =>
{
var SelectedCards = this.SelectedCards.ToArray();
var SignalNextDelayed = SignalNext.WhereCounter(i => i == SelectedCards.Length - 1);
using (GroupMovedByLocalPlayer)
SelectedCards.ForEach(
(Card k, int index) =>
{
k.BringToFront();
k.BringOverlayToFront();
if (index == 0)
k.AttachToStack(CandidateStack, GroupMovedByLocalPlayer);
else
k.AttachToStack(CandidateStack);
k.AnimatedMoveTo(
k.LocationInStack,
SignalNextDelayed
);
k.AnimatedOpacity = 1;
}
);
}
);
}
private void SetupMove(CardStack cardStack)
{
if (_origin == null)
SetOrigin(cardStack);
else
SetDestination(cardStack);
}
private void SetDestination(CardStack destination)
{
if (destination == _origin) return;
var origin = _origin;
_origin = null;
if (origin == null || !origin.Any()) return;
var cardToMove = origin.GetMovableCards().FirstOrDefault(destination.CanAccept);
if (cardToMove == null)
{
return;
}
origin.Move(cardToMove, destination);
}
public void AnimatedMoveToStack(CardStack CandidateStack, Future GroupMovedByLocalPlayer)
{
AnimatedMoveToStack(CandidateStack, GroupMovedByLocalPlayer, this.CurrentDeck.AnimatedMoveToChain);
}
private void SetOrigin(CardStack cardStack)
{
_origin = cardStack;
}
public void AttachToStack(CardStack s)
{
AttachToStack(s, null);
}
private void InitializeSlots()
{
this.Slot1 = new CardStack();
this.Slot2 = new CardStack();
this.Slot3 = new CardStack();
this.Slot4 = new CardStack();
}
public OrcasAvalonApplicationCanvas()
{
Width = DefaultWidth;
Height = DefaultHeight;
new[] {
Colors.Black,
Colors.Green,
Colors.Black
}.ToGradient(DefaultHeight / 4).Select(
(c, i) =>
new Rectangle
{
Fill = new SolidColorBrush(c),
Width = DefaultWidth,
Height = 4,
}.MoveTo(0, i * 4).AttachTo(this)
).ToArray();
// step 1 - can we show a card?
// step 2 drag the cards around
var deck = new CardDeck().AttachContainerTo(this);
deck.SizeTo(DefaultWidth, DefaultHeight);
deck.UnusedCards.AddRange(CardInfo.FullDeck());
var PlayStack = deck.CreateStackList();
{
PlayStack.Add(
new CardStack
{
}.MoveTo(64, 64)
);
PlayStack.Add(
new CardStack
{
}.MoveTo(64 + CardInfo.Width, 64)
);
var s3 =
new CardStack
{
deck.FetchCard,
deck.FetchCard,
deck.FetchCard,
}.MoveTo(64 + CardInfo.Width * 2, 64);
PlayStack.Add(s3);
s3.ForEach(k => k.VisibleSide = Card.SideEnum.TopSide);
}
{
PlayStack.Add(
new CardStack
{
}.MoveTo(64, 264)
);
PlayStack.Add(
new CardStack
{
}.MoveTo(64 + CardInfo.Width, 264)
);
var s3 =
new CardStack
{
deck.FetchCard,
deck.FetchCard,
deck.FetchCard,
}.MoveTo(64 + CardInfo.Width * 2, 264);
PlayStack.Add(s3);
s3.RevealLastCard();
}
// step 3 drag cards from stack to stack
}
