pascal.lafourcade
/
orderstacks
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

En cours de transformation du model

Browse Source
master
cldupland 6 years ago
parent 8092190f3c
commit dba3b1aef4
17 changed files with 609 additions and 415 deletions
Show Stats Download Patch File Download Diff File

10
TheGameExtreme/model/gameActions/GameAction.cs
Unescape View File

@ -1,10 +1,16 @@
using System;
using System.Collections.Generic;
using TheGameExtreme.model.card;
namespace TheGameExtreme.model.gameActions
{
public class GameAction
public abstract class GameAction
{
public abstract GameAction()
protected Piles ListOrderedStacks { get; set; }
protected GameAction(Piles listOrderedStacks)
{
ListOrderedStacks = listOrderedStacks;
}
}
}

39
TheGameExtreme/model/gameActions/Piles.cs
Unescape View File

@ -0,0 +1,39 @@
using System;
using System.Collections.Generic;
using TheGameExtreme.model.card;
namespace TheGameExtreme.model.gameActions
{
public class Piles
{
public List<Stack<Card>> ListOrderedStacks { get; set; }
public Piles()
{
ListOrderedStacks = new List<Stack<Card>>();
ListOrderedStacks.Add(new Stack<Card>());
ListOrderedStacks.Add(new Stack<Card>());
ListOrderedStacks.Add(new Stack<Card>());
ListOrderedStacks.Add(new Stack<Card>());
for (int i = 0; i < 4; i++)
{
if (i < 2)
{
ListOrderedStacks[i].Push(new ClassicCard(1));
}
else
{
ListOrderedStacks[i].Push(new ClassicCard(100));
}
}
}
public Stack<Card> getStack(int i)
{
return ListOrderedStacks[i];
}
}
}

25
TheGameExtreme/model/gameActions/classic/GameMode.cs
Unescape View File

@ -1,5 +1,6 @@
using System;
using System.Collections.Generic;
using TheGameExtreme.model.card;
using TheGameExtreme.model.gameActions;
namespace TheGameExtreme.model.gameActions.classic
@ -8,14 +9,20 @@ namespace TheGameExtreme.model.gameActions.classic
{
protected List<GameAction> gameActions;
protected Piles piles;
public GameMode()
{
gameActions = new List<GameAction>();
gameActions.Add(new Piocher());
gameActions.Add(new JouerUneCarte());
gameActions.Add(new TerminerSonTour());
gameActions.Add(new Piocher(piles));
gameActions.Add(new JouerUneCarte(piles));
gameActions.Add(new TerminerSonTour(piles));
}
public void load()
{
piles = new Piles();
}
public void pioche()
@ -23,14 +30,18 @@ namespace TheGameExtreme.model.gameActions.classic
((Piocher)gameActions[0]).pioche();
}
public void playCard()
public void playCard(int valueCard, List<Card> CurrentHand, int orderedStackSelected, Player player, List<Card> CurrentCardPlayed)
{
((JouerUneCarte)gameActions[0]).play();
((JouerUneCarte)gameActions[1]).play(valueCard, CurrentHand, orderedStackSelected, player, CurrentCardPlayed);
if (CurrentHand.Count == 0)
{
endTurn(); // Presque bon, oublie juste d'afficher les nouvelles cartes
}
}
public void endTurn()
{
((TerminerSonTour)gameActions[0]).end();
((TerminerSonTour)gameActions[2]).end();
}
@ -111,5 +122,5 @@ namespace TheGameExtreme.model.gameActions.classic
// }
// return true;
// }
//}
}
}

50
TheGameExtreme/model/gameActions/classic/JouerUneCarte.cs
Unescape View File

@ -1,15 +1,61 @@
using System;
using System.Collections.Generic;
using TheGameExtreme.model.card;
namespace TheGameExtreme.model.gameActions.classic
{
public class JouerUneCarte : GameAction
{
public JouerUneCarte()
public JouerUneCarte(Piles ListOrderedStacks) : base(ListOrderedStacks)
{
}
public void play()
public void play(int valueCard, List<Card> CurrentHand, int orderedStackSelected, Player player, List<Card> CurrentCardPlayed)
{
foreach (Card card in CurrentHand)
{
if (valueCard == card.Value)
{
if (orderedStackSelected >= 0 && orderedStackSelected < 4)
{
if (orderedStackSelected < 2)
{
rule(card, ListOrderedStacks.getStack(orderedStackSelected), true, player, CurrentCardPlayed);
}
else
{
rule(card, ListOrderedStacks.getStack(orderedStackSelected), false, player, CurrentCardPlayed);
}
}
else
{
throw new Exception(AppRessource.StrCantGetStack);
}
return;
}
}
}
private void rule(Card card, Stack<Card> stack, bool bottomUp, Player player, List<Card> CurrentCardPlayed)
{
if ((bottomUp && card.Value > stack.Peek().Value) || (!bottomUp && card.Value < stack.Peek().Value) || card.Value == stack.Peek().Value - 10 || card.Value == stack.Peek().Value + 10)
{
Card oldCard = stack.Peek();
player.joue(card);
CurrentCardPlayed.Add(card);
stack.Push(card);
//OnTopRangeChanged(new TopRangeChangedEventArgs(card, oldCard, ListOrderedStacks.IndexOf(orderedStack)));
}
else
{
throw new Exception(AppRessource.StrWrongStack);
}
//if (EndMessage != null)
//{
// //throw new Exception("Le jeu est fini! Veuillez lancer une nouvelle partie!");
// throw new Exception(AppRessource.StrEndOfGame);
//}
}
}
}

5
TheGameExtreme/model/gameActions/classic/Piocher.cs
Unescape View File

@ -1,9 +1,12 @@
using System;
using System.Collections.Generic;
using TheGameExtreme.model.card;
namespace TheGameExtreme.model.gameActions.classic
{
public class Piocher : GameAction
{
public Piocher()
public Piocher(Piles ListOrderedStacks) : base(ListOrderedStacks)
{
}

2
TheGameExtreme/model/gameActions/classic/TerminerSonTour.cs
Unescape View File

@ -3,7 +3,7 @@ namespace TheGameExtreme.model.gameActions.classic
{
public class TerminerSonTour : GameAction
{
public TerminerSonTour()
public TerminerSonTour(Piles ListOrderedStacks) : base(ListOrderedStacks)
{
}

4
TheGameExtreme/model/gameActions/extreme/ExtremeJouerUneCarte.cs
Unescape View File

@ -1,9 +1,11 @@
using System;
using TheGameExtreme.model.gameActions.classic;
namespace TheGameExtreme.model.gameActions.extreme
{
public class ExtremeJouerUneCarte : JouerUneCarte
{
public ExtremeJouerUneCarte()
public ExtremeJouerUneCarte(Piles ListOrderedStacks) : base(ListOrderedStacks)
{
}
}

7
TheGameExtreme/model/gameActions/extreme/ExtremeMode.cs
Unescape View File

@ -1,4 +1,5 @@
using System;
using TheGameExtreme.model.gameActions.classic;
namespace TheGameExtreme.model.gameActions.extreme
{
@ -6,9 +7,9 @@ namespace TheGameExtreme.model.gameActions.extreme
{
public ExtremeMode()
{
gameActions.Add(new ExtremePiocher());
gameActions.Add(new ExtremeJouerUneCarte());
gameActions.Add(new ExtremeTerminerSonTour());
gameActions.Add(new ExtremePiocher(piles));
gameActions.Add(new ExtremeJouerUneCarte(piles));
gameActions.Add(new ExtremeTerminerSonTour(piles));
}
}
}

4
TheGameExtreme/model/gameActions/extreme/ExtremePiocher.cs
Unescape View File

@ -1,9 +1,11 @@
using System;
using TheGameExtreme.model.gameActions.classic;
namespace TheGameExtreme.model.gameActions.extreme
{
public class ExtremePiocher : Piocher
{
public ExtremePiocher()
public ExtremePiocher(Piles ListOrderedStacks) : base(ListOrderedStacks)
{
}
}

4
TheGameExtreme/model/gameActions/extreme/ExtremeTerminerSonTour.cs
Unescape View File

@ -1,9 +1,11 @@
using System;
using TheGameExtreme.model.gameActions.classic;
namespace TheGameExtreme.model.gameActions.extreme
{
public class ExtremeTerminerSonTour : TerminerSonTour
{
public ExtremeTerminerSonTour()
public ExtremeTerminerSonTour(Piles ListOrderedStacks) : base(ListOrderedStacks)
{
}
}

333
TheGameExtreme/model/manager/GameManager.cs
Unescape View File

@ -17,87 +17,37 @@ namespace TheGameExtreme.model.manager
/* GameMaster implémente un mode de jeu (classe fille de gameMode qui connait les actions a effectué en fonction du mode de jeu */
protected GameMode gameMode;
protected GameManager(GameMode gameMode)
{
this.gameMode = gameMode;
}
public readonly int nbPlayer;
protected int nbMaxCard;
protected int currentIndexPlayer;
protected List<Player> playerList = new List<Player>();
public List<Stack<Card>> ListOrderedStacks { get; set; }
protected Deck deck;
protected bool win = true;
public String EndMessage { get; set; }
public readonly int nbPlayer;
protected List<Player> players = new List<Player>();
public event EventHandler<TopRangeChangedEventArgs> TopRangeChanged;
public event EventHandler<PlayerChangedEventArgs> PlayerChanged;
public List<Card> CurrentHand { get; set; }
protected int nbCardAtBeginOfTurn;
public Piles ListOrderedStacks { get; set; }
//protected int nbCardAtBeginOfTurn;
protected int nbMaxCard;
protected List<Card> CurrentCardPlayed = new List<Card>();
protected string langue;
public String EndMessage { get; set; }
protected GameManager(int nbPlayer, List<String> players)
{
ListOrderedStacks = new List<Stack<Card>>();
CurrentHand = new List<Card>();
this.nbPlayer = nbPlayer;
players.ForEach(player => playerList.Add(new Player(player)));
public List<Card> CurrentHand { get; set; }
protected GameManager(List<string> playersNames, GameMode gameMode)
{
nbPlayer = players.Count;
playersNames.ForEach(playerName => players.Add(new Player(playerName)));
initStacks();
this.gameMode = gameMode;
gameMode.load();
initRule();
ListOrderedStacks = new Piles();
createDeck();
defineNbMaxCard();
distribueCard();
CurrentHand = playerList[currentIndexPlayer].getCardList();
nbCardAtBeginOfTurn = CurrentHand.Count;
}
protected void initStacks()
{
ListOrderedStacks.Add(new Stack<Card>());
ListOrderedStacks.Add(new Stack<Card>());
ListOrderedStacks.Add(new Stack<Card>());
ListOrderedStacks.Add(new Stack<Card>());
for (int i = 0; i < 4; i++)
{
if (i < 2)
{
ListOrderedStacks[i].Push(new ClassicCard(1));
}
else
{
ListOrderedStacks[i].Push(new ClassicCard(100));
}
}
CurrentHand = players[0].getCardList();
}
protected void createDeck()
@ -134,7 +84,8 @@ namespace TheGameExtreme.model.manager
{
for (int i = 0; i < nbMaxCard; i++)
{
playerList.ForEach(player => {
players.ForEach(player =>
{
int r = new Random().Next(0, deck.size() - 1);
player.pioche(deck.getCard(r));
deck.removeAt(r);
@ -144,91 +95,191 @@ namespace TheGameExtreme.model.manager
public void joue(int valueCard, int orderedStackSelected)
{
if (EndMessage != null)
{
//throw new Exception("Le jeu est fini! Veuillez lancer une nouvelle partie!");
throw new Exception(AppRessource.StrEndOfGame);
}
foreach(Card card in CurrentHand)
{
if (valueCard == card.Value)
{
if (orderedStackSelected >= 0 && orderedStackSelected < 4)
{
if (orderedStackSelected < 2)
{
testPossibility(card, ListOrderedStacks[orderedStackSelected], true);
}
else
{
testPossibility(card, ListOrderedStacks[orderedStackSelected], false);
}
}
else
{
throw new Exception(AppRessource.StrCantGetStack);
}
return;
}
}
gameMode.playCard(valueCard, CurrentHand, orderedStackSelected, players[0], CurrentCardPlayed); // Mettre le joueur actif
}
protected void testPossibility(Card card, Stack<Card> orderedStack, bool bottomUp)
{
//if (gameMode.checkPlayRule(card, orderedStack, bottomUp, CurrentHand))
//{
// Card oldCard = orderedStack.Peek();
// playerList[currentIndexPlayer].joue(card);
// CurrentCardPlayed.Add(card);
// orderedStack.Push(card);
// OnTopRangeChanged(new TopRangeChangedEventArgs(card, oldCard, ListOrderedStacks.IndexOf(orderedStack)));
// //if (CurrentHand.Count == 0)
// //{
// // endTurn(); // Presque bon, oublie juste d'afficher les nouvelles cartes
// //}
//}
//else
//{
// throw new Exception(AppRessource.StrWrongStack);
//}
}
protected internal void OnTopRangeChanged(TopRangeChangedEventArgs args)
{
TopRangeChanged?.Invoke(this, args);
}
protected internal void OnPlayerChanged(PlayerChangedEventArgs args)
{
PlayerChanged?.Invoke(this, args);
}
public bool isCanPlay()
{
if (CurrentHand.Count > 0)
{
return true;
}
else
{
return false;
}
}
abstract public bool endTurn();
abstract protected bool isEndGame();
abstract protected void tryToFindSoluce(List<Card> playableCard);
abstract protected bool testEndGame(List<Card> playableCard);
abstract protected bool effectLose();
public int getCurentIndexPlayer()
{
return currentIndexPlayer;
}
//public readonly int nbPlayer;
//protected int nbMaxCard;
//protected int currentIndexPlayer;
//protected List<Player> playerList = new List<Player>();
//public List<Stack<Card>> ListOrderedStacks { get; set; }
//protected Deck deck;
//protected bool win = true;
//public String EndMessage { get; set; }
//public List<Card> CurrentHand { get; set; }
//protected int nbCardAtBeginOfTurn;
//protected List<Card> CurrentCardPlayed = new List<Card>();
//protected string langue;
//public event EventHandler<TopRangeChangedEventArgs> TopRangeChanged;
//public event EventHandler<PlayerChangedEventArgs> PlayerChanged;
//protected GameManager(int nbPlayer, List<String> players)
//{
// ListOrderedStacks = new List<Stack<Card>>();
// CurrentHand = new List<Card>();
// this.nbPlayer = nbPlayer;
// players.ForEach(player => playerList.Add(new Player(player)));
// initStacks();
// initRule();
// createDeck();
// defineNbMaxCard();
// distribueCard();
// CurrentHand = playerList[currentIndexPlayer].getCardList();
// nbCardAtBeginOfTurn = CurrentHand.Count;
//}
//protected void initStacks()
//{
// ListOrderedStacks = new List<Stack<Card>>();
// ListOrderedStacks.Add(new Stack<Card>());
// ListOrderedStacks.Add(new Stack<Card>());
// ListOrderedStacks.Add(new Stack<Card>());
// ListOrderedStacks.Add(new Stack<Card>());
// for (int i = 0; i < 4; i++)
// {
// if (i < 2)
// {
// ListOrderedStacks[i].Push(new ClassicCard(1));
// }
// else
// {
// ListOrderedStacks[i].Push(new ClassicCard(100));
// }
// }
//}
//protected void createDeck()
//{
// switch (true)
// {
// case false:
// deck = new ClassicDeck();
// break;
// default:
// deck = new ExtremeDeck();
// break;
// }
//}
//protected void defineNbMaxCard()
//{
// switch (nbPlayer)
// {
// case 1:
// nbMaxCard = 8;
// break;
// case 2:
// nbMaxCard = 7;
// break;
// default:
// nbMaxCard = 6;
// break;
// }
//}
//protected void distribueCard()
//{
// for (int i = 0; i < nbMaxCard; i++)
// {
// players.ForEach(player =>
// {
// int r = new Random().Next(0, deck.size() - 1);
// player.pioche(deck.getCard(r));
// deck.removeAt(r);
// });
// }
//}
//public void joue(int valueCard, int orderedStackSelected)
//{
// gameMode.playCard(valueCard, CurrentHand, orderedStackSelected, players[0], CurrentCardPlayed); // Mettre le joueur actif
//}
//protected void testPossibility(Card card, Stack<Card> orderedStack, bool bottomUp)
//{
// //if (gameMode.checkPlayRule(card, orderedStack, bottomUp, CurrentHand))
// //{
// // Card oldCard = orderedStack.Peek();
// // playerList[currentIndexPlayer].joue(card);
// // CurrentCardPlayed.Add(card);
// // orderedStack.Push(card);
// // OnTopRangeChanged(new TopRangeChangedEventArgs(card, oldCard, ListOrderedStacks.IndexOf(orderedStack)));
// // //if (CurrentHand.Count == 0)
// // //{
// // // endTurn(); // Presque bon, oublie juste d'afficher les nouvelles cartes
// // //}
// //}
// //else
// //{
// // throw new Exception(AppRessource.StrWrongStack);
// //}
//}
//protected internal void OnTopRangeChanged(TopRangeChangedEventArgs args)
//{
// TopRangeChanged?.Invoke(this, args);
//}
//protected internal void OnPlayerChanged(PlayerChangedEventArgs args)
//{
// PlayerChanged?.Invoke(this, args);
//}
//public bool isCanPlay()
//{
// if (CurrentHand.Count > 0)
// {
// return true;
// }
// else
// {
// return false;
// }
//}
//abstract public bool endTurn();
//abstract protected bool isEndGame();
//abstract protected void tryToFindSoluce(List<Card> playableCard);
//abstract protected bool testEndGame(List<Card> playableCard);
//abstract protected bool effectLose();
//public int getCurentIndexPlayer()
//{
// return currentIndexPlayer;
//}
}
}

3
TheGameExtreme/model/manager/MultiplayerGameManager.cs
Unescape View File

@ -1,11 +1,12 @@
using System;
using System.Collections.Generic;
using TheGameExtreme.model.gameActions.classic;
namespace TheGameExtreme.model.manager
{
public abstract class MultiplayerGameManager : GameManager
{
protected MultiplayerGameManager(int nbPlayer, List<string> players) : base(nbPlayer, players)
protected MultiplayerGameManager(List<string> players, GameMode gameMode) : base(players, gameMode)
{
}
}

321
TheGameExtreme/model/manager/SoloGameManager.cs
Unescape View File

@ -3,175 +3,176 @@ using System.Collections.Generic;
using TheGameExtreme.model.card;
using TheGameExtreme.model.card.rapidCard;
using TheGameExtreme.model.@event;
using TheGameExtreme.model.gameActions.classic;
namespace TheGameExtreme.model.manager
{
public class SoloGameManager : GameManager
{
public SoloGameManager(int nbPlayer, List<String> players)
: base(nbPlayer, players)
public SoloGameManager(List<String> players, GameMode gameMode)
: base(players, gameMode)
{
}
public override bool endTurn()
{
//if (gameMode.checkBeforeEndTurnRule(CurrentCardPlayed, nbCardAtBeginOfTurn, CurrentHand))
//{
// //verifyNbCardPlay();
// pioche();
// currentIndexPlayer += 1;
// if (currentIndexPlayer == playerList.Count)
// {
// currentIndexPlayer = 0;
// }
// CurrentHand = playerList[currentIndexPlayer].getCardList();
// OnPlayerChanged(new PlayerChangedEventArgs(CurrentHand, playerList[currentIndexPlayer].Pseudo));
// nbCardAtBeginOfTurn = CurrentHand.Count;
// CurrentCardPlayed.Clear();
// if (gameMode.checkEndTurnRule(CurrentCardPlayed, nbCardAtBeginOfTurn, CurrentHand))
// {
// //if (isEndGame()) // Ajouter le score en calculant les cartes restantes dans la pile et dans les mains des joueurs
// //{
// // displayWinner();
// // return true;
// //}
// return false;
// }
// else
// {
// return true;
// }
//}
//else
//{
// return false;
//}
}
protected void verifyNbCardPlay()
{
foreach (Card cardPlayed in CurrentCardPlayed)
{
if (Equals(cardPlayed.GetType(), ThreeCard.CARD_THREE))
{
if ((nbCardAtBeginOfTurn - CurrentHand.Count) < 3) // Penser à vérifier s'il a joué une ThreeCard pour regarder s'il a bien joué 3 cartes
{
testIsEndGame();
}
return;
}
}
if ((nbCardAtBeginOfTurn - CurrentHand.Count) < 2) // Penser à vérifier s'il a joué une ThreeCard pour regarder s'il a bien joué 3 cartes
{
testIsEndGame();
}
}
protected void testIsEndGame()
{
if (isEndGame())
{
displayWinner();
}
else
{
//throw new Exception("Vous n'avez pas joué assez de carte!");
throw new Exception(AppRessources_br.StrCardPlayedLessThanTwo);
}
}
protected void displayWinner()
{
if (win)
{
EndMessage = "Le jeu est terminé!\n Bravo vous avez gagné!";
EndMessage = AppRessource.StrWin;
}
}
protected void pioche()
{
int nbPickedCard = nbMaxCard - CurrentHand.Count;
for (int i = 0; i < nbPickedCard; i++)
{
if (deck.size() == 0)
{
return;
}
int random = new Random().Next(0, deck.size() - 1);
playerList[currentIndexPlayer].pioche(deck.getCard(random));
deck.removeAt(random);
}
}
protected override bool isEndGame()
{
if (CurrentHand.Count != 0)
{
List<Card> playableCard = new List<Card>();
tryToFindSoluce(playableCard);
return testEndGame(playableCard);
}
return false;
}
protected override void tryToFindSoluce(List<Card> playableCard)
{
CurrentHand.ForEach(card =>
{
if (card.Value > ListOrderedStacks[0].Peek().Value || card.Value > ListOrderedStacks[1].Peek().Value || card.Value < ListOrderedStacks[2].Peek().Value || card.Value < ListOrderedStacks[3].Peek().Value)
{
playableCard.Add(card);
}
});
}
protected override bool testEndGame(List<Card> playableCard)
{
if (playableCard.Count == 2)
{
foreach (Card c in playableCard)
{
if (Equals(c.getName(), ThreeCard.CARD_THREE))
{
win = false;
EndMessage = "Le jeu est terminé!\n Désolé, vous avez perdu... Vous deviez jouer trois cartes à cause de l'effet \"Trois cartes joué\" hors votre jeu ne permet pas d'en jouer autant! Essayez encore!";
return true;
}
}
}
else if (playableCard.Count < 2)
{
win = false;
EndMessage = "Le jeu est terminé!\n Désolé, vous avez perdu... Essayez encore!";
return true;
}
else if (effectLose())
{
win = false;
EndMessage = "Désolé, vous n'avez pas recouvert la tête de mort... Réessayez ;)";
return true;
}
return false;
}
protected override bool effectLose()
{
foreach (Stack<Card> orderedStack in ListOrderedStacks)
{
if (Equals(orderedStack.Peek().getName(), EndGameCard.CARD_ENDGAME))
{
return true;
}
}
return false;
}
//public override bool endTurn()
//{
// //if (gameMode.checkBeforeEndTurnRule(CurrentCardPlayed, nbCardAtBeginOfTurn, CurrentHand))
// //{
// // //verifyNbCardPlay();
// // pioche();
// // currentIndexPlayer += 1;
// // if (currentIndexPlayer == playerList.Count)
// // {
// // currentIndexPlayer = 0;
// // }
// // CurrentHand = playerList[currentIndexPlayer].getCardList();
// // OnPlayerChanged(new PlayerChangedEventArgs(CurrentHand, playerList[currentIndexPlayer].Pseudo));
// // nbCardAtBeginOfTurn = CurrentHand.Count;
// // CurrentCardPlayed.Clear();
// // if (gameMode.checkEndTurnRule(CurrentCardPlayed, nbCardAtBeginOfTurn, CurrentHand))
// // {
// // //if (isEndGame()) // Ajouter le score en calculant les cartes restantes dans la pile et dans les mains des joueurs
// // //{
// // // displayWinner();
// // // return true;
// // //}
// // return false;
// // }
// // else
// // {
// // return true;
// // }
// //}
// //else
// //{
// // return false;
// //}
//}
//protected void verifyNbCardPlay()
//{
// foreach (Card cardPlayed in CurrentCardPlayed)
// {
// if (Equals(cardPlayed.GetType(), ThreeCard.CARD_THREE))
// {
// if ((nbCardAtBeginOfTurn - CurrentHand.Count) < 3) // Penser à vérifier s'il a joué une ThreeCard pour regarder s'il a bien joué 3 cartes
// {
// testIsEndGame();
// }
// return;
// }
// }
// if ((nbCardAtBeginOfTurn - CurrentHand.Count) < 2) // Penser à vérifier s'il a joué une ThreeCard pour regarder s'il a bien joué 3 cartes
// {
// testIsEndGame();
// }
//}
//protected void testIsEndGame()
//{
// if (isEndGame())
// {
// displayWinner();
// }
// else
// {
// //throw new Exception("Vous n'avez pas joué assez de carte!");
// throw new Exception(AppRessources_br.StrCardPlayedLessThanTwo);
// }
//}
//protected void displayWinner()
//{
// if (win)
// {
// EndMessage = "Le jeu est terminé!\n Bravo vous avez gagné!";
// EndMessage = AppRessource.StrWin;
// }
//}
//protected void pioche()
//{
// int nbPickedCard = nbMaxCard - CurrentHand.Count;
// for (int i = 0; i < nbPickedCard; i++)
// {
// if (deck.size() == 0)
// {
// return;
// }
// int random = new Random().Next(0, deck.size() - 1);
// playerList[currentIndexPlayer].pioche(deck.getCard(random));
// deck.removeAt(random);
// }
//}
//protected override bool isEndGame()
//{
// if (CurrentHand.Count != 0)
// {
// List<Card> playableCard = new List<Card>();
// tryToFindSoluce(playableCard);
// return testEndGame(playableCard);
// }
// return false;
//}
//protected override void tryToFindSoluce(List<Card> playableCard)
//{
// CurrentHand.ForEach(card =>
// {
// if (card.Value > ListOrderedStacks[0].Peek().Value || card.Value > ListOrderedStacks[1].Peek().Value || card.Value < ListOrderedStacks[2].Peek().Value || card.Value < ListOrderedStacks[3].Peek().Value)
// {
// playableCard.Add(card);
// }
// });
//}
//protected override bool testEndGame(List<Card> playableCard)
//{
// if (playableCard.Count == 2)
// {
// foreach (Card c in playableCard)
// {
// if (Equals(c.getName(), ThreeCard.CARD_THREE))
// {
// win = false;
// EndMessage = "Le jeu est terminé!\n Désolé, vous avez perdu... Vous deviez jouer trois cartes à cause de l'effet \"Trois cartes joué\" hors votre jeu ne permet pas d'en jouer autant! Essayez encore!";
// return true;
// }
// }
// }
// else if (playableCard.Count < 2)
// {
// win = false;
// EndMessage = "Le jeu est terminé!\n Désolé, vous avez perdu... Essayez encore!";
// return true;
// }
// else if (effectLose())
// {
// win = false;
// EndMessage = "Désolé, vous n'avez pas recouvert la tête de mort... Réessayez ;)";
// return true;
// }
// return false;
//}
//protected override bool effectLose()
//{
// foreach (Stack<Card> orderedStack in ListOrderedStacks)
// {
// if (Equals(orderedStack.Peek().getName(), EndGameCard.CARD_ENDGAME))
// {
// return true;
// }
// }
// return false;
//}
}
}

51
TheGameExtreme/model/manager/multiplayer/LocalGameManager.cs
Unescape View File

@ -1,43 +1,44 @@
using System;
using System.Collections.Generic;
using TheGameExtreme.model.card;
using TheGameExtreme.model.gameActions.classic;
namespace TheGameExtreme.model.manager
{
public class LocalGameManager : MultiplayerGameManager
{
public LocalGameManager(int nbPlayer, List<string> players) : base(nbPlayer, players)
public LocalGameManager(List<string> players, GameMode gameMode) : base(players, gameMode)
{
}
public override bool endTurn()
{
throw new NotImplementedException();
}
//public override bool endTurn()
//{
// throw new NotImplementedException();
//}
protected override bool effectLose()
{
throw new NotImplementedException();
}
//protected override bool effectLose()
//{
// throw new NotImplementedException();
//}
protected override bool isEndGame()
{
throw new NotImplementedException();
}
//protected override bool isEndGame()
//{
// throw new NotImplementedException();
//}
protected override void pioche()
{
throw new NotImplementedException();
}
//protected override void pioche()
//{
// throw new NotImplementedException();
//}
protected override bool testEndGame(List<Card> playableCard)
{
throw new NotImplementedException();
}
//protected override bool testEndGame(List<Card> playableCard)
//{
// throw new NotImplementedException();
//}
protected override void tryToFindSoluce(List<Card> playableCard)
{
throw new NotImplementedException();
}
//protected override void tryToFindSoluce(List<Card> playableCard)
//{
// throw new NotImplementedException();
//}
}
}

51
TheGameExtreme/model/manager/multiplayer/RemoteGameManager.cs
Unescape View File

@ -1,43 +1,44 @@
using System;
using System.Collections.Generic;
using TheGameExtreme.model.card;
using TheGameExtreme.model.gameActions.classic;
namespace TheGameExtreme.model.manager.multiplayer
{
public class RemoteGameManager : MultiplayerGameManager
{
public RemoteGameManager(int nbPlayer, List<string> players) : base(nbPlayer, players)
public RemoteGameManager(List<string> players, GameMode gameMode) : base(players, gameMode)
{
}
public override bool endTurn()
{
throw new NotImplementedException();
}
//public override bool endTurn()
//{
// throw new NotImplementedException();
//}
protected override bool effectLose()
{
throw new NotImplementedException();
}
//protected override bool effectLose()
//{
// throw new NotImplementedException();
//}
protected override bool isEndGame()
{
throw new NotImplementedException();
}
//protected override bool isEndGame()
//{
// throw new NotImplementedException();
//}
protected override void pioche()
{
throw new NotImplementedException();
}
//protected override void pioche()
//{
// throw new NotImplementedException();
//}
protected override bool testEndGame(List<Card> playableCard)
{
throw new NotImplementedException();
}
//protected override bool testEndGame(List<Card> playableCard)
//{
// throw new NotImplementedException();
//}
protected override void tryToFindSoluce(List<Card> playableCard)
{
throw new NotImplementedException();
}
//protected override void tryToFindSoluce(List<Card> playableCard)
//{
// throw new NotImplementedException();
//}
}
}

16
TheGameExtreme/view/MainPage.xaml.cs
Unescape View File

@ -145,14 +145,14 @@ namespace TheGameExtreme.view
private void endTurn(object sender, EventArgs args)
{
if (viewmodel.endTurn())
{
botPanel.Children.Add(button);
}
else
{
inflateHand();
}
//if (viewmodel.endTurn())
//{
// botPanel.Children.Add(button);
//}
//else
//{
// inflateHand();
//}
}
}
}

99
TheGameExtreme/viewmodel/Main.cs
Unescape View File

@ -4,6 +4,7 @@ using System.Collections.ObjectModel;
using System.ComponentModel;
using TheGameExtreme.model.card;
using TheGameExtreme.model.@event;
using TheGameExtreme.model.gameActions.classic;
using TheGameExtreme.model.manager;
namespace TheGameExtreme.viewmodel
@ -45,7 +46,7 @@ namespace TheGameExtreme.viewmodel
public Main()
{
gameManager = new SoloGameManager(2, new List<String> { "Clément", "Baptiste" }) ; // Donner le nom des joueurs
gameManager = new SoloGameManager(new List<String> { "Clément", "Baptiste" }, new GameMode()) ; // Donner le nom des joueurs
gameManager.TopRangeChanged += OnTopRangeChanged;
@ -67,31 +68,19 @@ namespace TheGameExtreme.viewmodel
BindingChanged?.Invoke(this, args);
}
/**
*
*
* @return booléen de fin de jeu
*/
public bool played(int numStack, int valueCard)
{
if (gameManager.isCanPlay())
{
return playOneCard(numStack, valueCard);
}
else
{
Alert = "Le joueur n'a plus de carte dans sa main!";
// Faire un toast
return false;
}
}
/**
*
*
* @return booléen de fin de jeu
*/
private bool playOneCard(int numStack, int valueCard)
public bool played(int numStack, int valueCard)
{
try
{
@ -102,28 +91,66 @@ namespace TheGameExtreme.viewmodel
return true;
}
}
catch(Exception e)
catch (Exception e)
{
// Faire un toast
Alert = e.Message;
}
return false;
}
public bool endTurn()
{
try
{
bool isEnd = gameManager.endTurn();
Alert = gameManager.EndMessage;
return isEnd;
}
catch(Exception e)
{
Alert = e.Message;
return false;
}
//if (gameManager.isCanPlay())
//{
// return playOneCard(numStack, valueCard);
//}
//else
//{
// Alert = "Le joueur n'a plus de carte dans sa main!";
// // Faire un toast
// return false;
//}
}
}
///**
// *
// *
// * @return booléen de fin de jeu
// */
//private bool playOneCard(int numStack, int valueCard)
//{
// try
// {
// gameManager.joue(valueCard, numStack);
// if (gameManager.EndMessage != null)
// {
// Alert = gameManager.EndMessage;
// return true;
// }
// }
// catch(Exception e)
// {
// // Faire un toast
// Alert = e.Message;
// }
// return false;
//}
//public bool endTurn()
//{
// try
// {
// bool isEnd = gameManager.endTurn();
// Alert = gameManager.EndMessage;
// return isEnd;
// }
// catch(Exception e)
// {
// Alert = e.Message;
// return false;
// }
//}
}
}

Write Preview
Loading…
Cancel
Save