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

Merge branch 'reconstruction_model' - Version Semi-Stable (encore légèrement brouillon par manque de temps)

Browse Source
master
cldupland 6 years ago
parent 3606921c05 2d1df465e8
commit ff5e2ad7b2
38 changed files with 1082 additions and 806 deletions
Show Stats Download Patch File Download Diff File

BIN
Documentations/Rapport.docx
View File

Binary file not shown.

34
TheGameExtreme/Preparateur.cs
Unescape View File

@ -0,0 +1,34 @@
using System;
using System.Collections.Generic;
using TheGameExtreme.model;
using TheGameExtreme.model.gameActions.classic;
namespace TheGameExtreme
{
public class Parametreur
{
public GameMode GameMode { get; set; }
public List<Player> players = new List<Player>();
public int NbPlayer { get; set; }
public Parametreur(GameMode gameMode)
{
GameMode = gameMode;
}
public void Prepare()
{
NbPlayer = players.Count;
GameMode.load(NbPlayer, players);
}
public void AddPlayer(Player player)
{
if (player != null)
{
players.Add(player);
}
}
}
}

7
TheGameExtreme/TheGameExtreme.csproj
Unescape View File

@ -14,11 +14,10 @@
<Folder Include="viewmodel\" />
<Folder Include="model\card\" />
<Folder Include="model\deck\" />
<Folder Include="model\rule\" />
<Folder Include="model\rule\playRules\" />
<Folder Include="model\Card\rapidCard\" />
<Folder Include="model\rule\endTurnRules\" />
<Folder Include="model\rule\beforeEndTurnRules\" />
<Folder Include="model\gameActions\" />
<Folder Include="model\gameActions\extreme\" />
<Folder Include="model\gameActions\classic\" />
</ItemGroup>
<ItemGroup>
<Compile Remove="model\effect\StopColm.cs" />

14
TheGameExtreme/model/Card/Card.cs
Unescape View File

@ -3,23 +3,23 @@ using System.ComponentModel;
namespace TheGameExtreme.model.card
{
public abstract class Card : INotifyPropertyChanged
public abstract class Card // : INotifyPropertyChanged
{
public event PropertyChangedEventHandler PropertyChanged;
//public event PropertyChangedEventHandler PropertyChanged;
private int value;
public int Value
{
get { return value; }
set {
this.value = value;
OnPropertyChange("Value");
//OnPropertyChange("Value");
}
}
private void OnPropertyChange(string v)
{
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(v));
}
//private void OnPropertyChange(string v)
//{
// PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(v));
//}
public Card(int value)

92
TheGameExtreme/model/GameMode.cs
Unescape View File

@ -1,92 +0,0 @@
using System;
using System.Collections.Generic;
using TheGameExtreme.model.card;
using TheGameExtreme.model.rule;
using TheGameExtreme.model.rule.beforeEndTurnRules;
using TheGameExtreme.model.rule.endTurnRules;
using TheGameExtreme.model.rule.playRules;
namespace TheGameExtreme.model
{
public class GameMode
{
private List<Rule> playRule = new List<Rule>();
private List<Rule> beforeEndTurnRule = new List<Rule>();
private List<Rule> endTurnRule = new List<Rule>();
private List<Rule> commonRule = new List<Rule>();
public GameMode()
{
}
public void addPlayRule(PlayRule rule)
{
playRule?.Add(rule);
}
public void addEndTurnRule(EndTurnRule rule)
{
endTurnRule?.Add(rule);
}
public void addBeforeEndTurnRule(BeforeEndTurnRule rule)
{
beforeEndTurnRule?.Add(rule);
}
public void addCommonRule(Rule rule)
{
// Vérifier que se ne soit ni une PlayRule, ni une EndTurnRule ?
commonRule?.Add(rule);
}
public bool checkPlayRule(Card card, Stack<Card> orderedStack, bool bottomUp, List<Card> CurrentHand)
{
foreach(PlayRule rule in playRule)
{
if (rule.Test(card, orderedStack, bottomUp, CurrentHand)) // Gestion des messages pour savoir qu'elle règle n'est pas respecter.
{
return true;
}
}
foreach (Rule rule in commonRule)
{
}
return false;
}
public bool checkBeforeEndTurnRule(List<Card> CurrentCardPlayed, int nbCardAtBeginOfTurn, List<Card> CurrentHand)
{
foreach (BeforeEndTurnRule rule in beforeEndTurnRule)
{
if (!rule.Test(CurrentCardPlayed, nbCardAtBeginOfTurn, CurrentHand)) // Gestion des messages pour savoir qu'elle règle n'est pas respecter.
{
return false;
}
}
foreach (Rule rule in commonRule)
{
}
return true;
}
public bool checkEndTurnRule(List<Card> CurrentCardPlayed, int nbCardAtBeginOfTurn, List<Card> CurrentHand)
{
foreach (EndTurnRule rule in endTurnRule)
{
if (!rule.Test(CurrentCardPlayed, nbCardAtBeginOfTurn, CurrentHand)) // Gestion des messages pour savoir qu'elle règle n'est pas respecter.
{
return false;
}
}
foreach (Rule rule in commonRule)
{
}
return true;
}
}
}

5
TheGameExtreme/model/deck/Deck.cs
Unescape View File

@ -9,11 +9,6 @@ namespace TheGameExtreme.model
protected List<Card> deck = new List<Card>();
public Deck()
{
}
public int size()
{
return deck.Count;

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

@ -0,0 +1,17 @@
using System;
using System.Collections.Generic;
using TheGameExtreme.model.card;
namespace TheGameExtreme.model.gameActions
{
public abstract class GameAction
{
protected Piles ListOrderedStacks { get; set; }
public String ErrorMessage { 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
{
private 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];
}
}
}

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

@ -0,0 +1,173 @@
using System;
using System.Collections.Generic;
using TheGameExtreme.model.card;
using TheGameExtreme.model.deck;
using TheGameExtreme.model.@event;
using TheGameExtreme.model.gameActions;
namespace TheGameExtreme.model.gameActions.classic
{
public class GameMode
{
protected List<GameAction> gameActions;
protected Piles piles;
protected int nbCardAtBeginOfTurn = 7;
protected Deck deck;
private int nbMaxCard;
public String Message { get; set; }
#region
public event EventHandler<TopRangeChangedEventArgs> TopRangeChanged;
public event EventHandler<PlayerChangedEventArgs> PlayerChanged;
protected internal void OnTopRangeChanged(TopRangeChangedEventArgs args)
{
TopRangeChanged?.Invoke(this, args);
}
protected internal void OnPlayerChanged(PlayerChangedEventArgs args)
{
PlayerChanged?.Invoke(this, args);
}
#endregion
public GameMode()
{
gameActions = new List<GameAction>();
}
public void load(int nbPlayer, List<Player> players)
{
piles = new Piles();
gameActions.Add(new Piocher(piles));
gameActions.Add(new JouerUneCarte(piles));
gameActions.Add(new TerminerSonTour(piles));
createDeck();
defineNbMaxCard(nbPlayer);
distribueCard(players);
}
protected void createDeck()
{
switch (true)
{
case false:
deck = new ClassicDeck();
break;
default:
deck = new ExtremeDeck();
break;
}
}
protected void defineNbMaxCard(int nbPlayer)
{
switch (nbPlayer)
{
case 1:
nbMaxCard = 8;
break;
case 2:
nbMaxCard = 7;
break;
default:
nbMaxCard = 6;
break;
}
}
protected void distribueCard(List<Player> players)
{
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 pioche(List<Card> currentHand, Player player)
{
Message = null;
((Piocher)gameActions[0]).pioche(currentHand, deck, player);
}
public void playCard(int valueCard, List<Card> currentHand, int orderedStackSelected, Player player, List<Card> CurrentCardPlayed)
{
Message = null;
if (((JouerUneCarte)gameActions[1]).play(valueCard, currentHand, orderedStackSelected, player, CurrentCardPlayed))
{
OnTopRangeChanged(new TopRangeChangedEventArgs(piles.getStack(orderedStackSelected).Peek(), ((JouerUneCarte)gameActions[1]).OldCard, orderedStackSelected));
}
else
{
Message = ((JouerUneCarte)gameActions[1]).ErrorMessage;
}
}
public bool endTurn(List<Card> currentHand, List<Card> CurrentCardPlayed, Player player)
{
Message = null;
if (((TerminerSonTour)gameActions[2]).end(currentHand, nbCardAtBeginOfTurn, CurrentCardPlayed))
{
pioche(currentHand, player);
nbCardAtBeginOfTurn = currentHand.Count;
CurrentCardPlayed.Clear();
OnPlayerChanged(null);
return false;
}
else
{
Message = ((TerminerSonTour)gameActions[2]).ErrorMessage;
return true;
}
}
#region Decaler dans un GameAction
public bool isEndGame(List<Card> currentHand)
{
if (currentHand.Count != 0)
{
List<Card> playableCard = new List<Card>();
tryToFindSoluce(playableCard, currentHand);
return testEndGame(playableCard);
}
return false;
}
protected void tryToFindSoluce(List<Card> playableCard, List<Card> currentHand)
{
currentHand.ForEach(card =>
{
if (card.Value > piles.getStack(0).Peek().Value || card.Value > piles.getStack(1).Peek().Value || card.Value < piles.getStack(2).Peek().Value || card.Value < piles.getStack(3).Peek().Value)
{
playableCard.Add(card);
}
});
}
protected bool testEndGame(List<Card> playableCard)
{
if (playableCard.Count < 2)
{
Message = "Le jeu est terminé!\n Désolé, vous avez perdu... Essayez encore!";
return true;
}
return false;
}
#endregion
}
}

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

@ -0,0 +1,64 @@
using System;
using System.Collections.Generic;
using TheGameExtreme.model.card;
namespace TheGameExtreme.model.gameActions.classic
{
public class JouerUneCarte : GameAction
{
public Card OldCard { get; set; }
public JouerUneCarte(Piles ListOrderedStacks) : base(ListOrderedStacks)
{
}
public bool 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)
{
ErrorMessage = null;
return rule(card, ListOrderedStacks.getStack(orderedStackSelected), true, player, CurrentCardPlayed);
}
else
{
ErrorMessage = null;
return rule(card, ListOrderedStacks.getStack(orderedStackSelected), false, player, CurrentCardPlayed);
}
}
else
{
ErrorMessage = AppRessource.StrCantGetStack;
}
}
}
return false;
}
private bool 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)
{
OldCard = stack.Peek();
player.joue(card);
CurrentCardPlayed.Add(card);
stack.Push(card);
return true;
//OnTopRangeChanged(new TopRangeChangedEventArgs(card, oldCard, ListOrderedStacks.IndexOf(orderedStack)));
}
else
{
ErrorMessage = AppRessource.StrWrongStack;
return false;
}
}
}
}

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

@ -0,0 +1,36 @@
using System;
using System.Collections.Generic;
using TheGameExtreme.model.card;
namespace TheGameExtreme.model.gameActions.classic
{
public class Piocher : GameAction
{
protected int nbMaxCard = 7; // Changer
public Piocher(Piles ListOrderedStacks) : base(ListOrderedStacks)
{
}
protected bool checkRule()
{
return true;
}
public void pioche(List<Card> CurrentHand, Deck deck, Player player)
{
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);
player.pioche(deck.getCard(random));
deck.removeAt(random);
}
}
}
}

29
TheGameExtreme/model/rule/endTurnRules/EndGame.cs → TheGameExtreme/model/gameActions/classic/TerminerSonTour.cs
Unescape View File

@ -3,21 +3,33 @@ using System.Collections.Generic;
using TheGameExtreme.model.card;
using TheGameExtreme.model.card.rapidCard;
namespace TheGameExtreme.model.rule.endTurnRules
namespace TheGameExtreme.model.gameActions.classic
{
public class EndGame : EndTurnRule
public class TerminerSonTour : GameAction
{
public static readonly String REGLE_ENDGAME = "End Game";
public List<Stack<Card>> ListOrderedStacks { get; set; }
public TerminerSonTour(Piles ListOrderedStacks) : base(ListOrderedStacks)
{
}
public EndGame(List<Stack<Card>> ListOrderedStacks)
public bool end(List<Card> CurrentHand, int nbCardAtBeginOfTurn, List<Card> CurrentCardPlayed)
{
this.ListOrderedStacks = ListOrderedStacks;
// Si carte qui fait piocher que d'un, vérifier la bonne pioche (penser si elle vient d'être recouverte)
// Sinon
if (nbCardAtBeginOfTurn == CurrentCardPlayed.Count || CurrentHand.Count == 0 || CurrentCardPlayed.Count >= 2)
{ // Ne pas oublié de gérer les ThreeCard
return Test(CurrentHand);
}
else
{
ErrorMessage = AppRessource.StrCardPlayedLessThanTwo;
return false;
}
}
public override bool Test(List<Card> CurrentCardPlayed, int nbCardAtBeginOfTurn, List<Card> CurrentHand)
public bool Test(List<Card> CurrentHand)
{
if (CurrentHand.Count != 0)
{
@ -32,7 +44,7 @@ namespace TheGameExtreme.model.rule.endTurnRules
{
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)
if (card.Value > ListOrderedStacks.getStack(0).Peek().Value || card.Value > ListOrderedStacks.getStack(1).Peek().Value || card.Value < ListOrderedStacks.getStack(2).Peek().Value || card.Value < ListOrderedStacks.getStack(3).Peek().Value)
{
playableCard.Add(card);
}
@ -57,6 +69,5 @@ namespace TheGameExtreme.model.rule.endTurnRules
}
return true;
}
}
}

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

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

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

@ -0,0 +1,15 @@
using System;
using TheGameExtreme.model.gameActions.classic;
namespace TheGameExtreme.model.gameActions.extreme
{
public class ExtremeMode : GameMode
{
public ExtremeMode()
{
gameActions.Add(new ExtremePiocher(piles));
gameActions.Add(new ExtremeJouerUneCarte(piles));
gameActions.Add(new ExtremeTerminerSonTour(piles));
}
}
}

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

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

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

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

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

@ -1,234 +1,293 @@
using System;
using System.Collections.Generic;
using System.ComponentModel;
using TheGameExtreme.model.card;
using TheGameExtreme.model.deck;
using TheGameExtreme.model.@event;
using TheGameExtreme.model.rule.beforeEndTurnRules;
using TheGameExtreme.model.rule.endTurnRules;
using TheGameExtreme.model.rule.playRules;
using TheGameExtreme.model.gameActions;
using TheGameExtreme.model.gameActions.classic;
namespace TheGameExtreme.model.manager
{
public abstract class GameManager
public abstract class GameManager: INotifyPropertyChanged
{
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;
/* GameMaster implémente un mode de jeu (classe fille de gameMode qui connait les actions a effectué en fonction du mode de jeu */
protected Parametreur preparateur;
public Piles ListOrderedStacks { get; set; }
protected List<Card> CurrentCardPlayed = new List<Card>();
public String EndMessage { get; set; }
protected int currentIndexPlayer;
protected List<Card> currentHand;
public List<Card> CurrentHand
{
get { return currentHand; }
set
{
currentHand = value;
OnPropertyChanged("CurrentHand");
}
}
#region event
public event EventHandler<TopRangeChangedEventArgs> TopRangeChanged;
public event EventHandler<PlayerChangedEventArgs> PlayerChanged;
public List<Card> CurrentHand { get; set; }
protected int nbCardAtBeginOfTurn;
protected List<Card> CurrentCardPlayed = new List<Card>();
protected string langue;
public event PropertyChangedEventHandler PropertyChanged;
public virtual void OnPropertyChanged(string info)
{
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(info));
}
public void OnTopRangeChanged(object source, TopRangeChangedEventArgs args)
{
TopRangeChanged?.Invoke(this, args);
}
protected internal void OnPlayerChanged(object source, PlayerChangedEventArgs args)
{
currentIndexPlayer += 1;
if (currentIndexPlayer == preparateur.players.Count)
{
currentIndexPlayer = 0;
}
CurrentHand = preparateur.players[currentIndexPlayer].getCardList();
PlayerChanged?.Invoke(this, new PlayerChangedEventArgs(CurrentHand, preparateur.players[currentIndexPlayer].Pseudo));
}
#endregion
protected GameMode gameMode;
protected GameManager(int nbPlayer, List<String> players)
protected GameManager(Parametreur parametreur)
{
ListOrderedStacks = new List<Stack<Card>>();
CurrentHand = new List<Card>();
this.preparateur = parametreur;
this.nbPlayer = nbPlayer;
players.ForEach(player => playerList.Add(new Player(player)));
parametreur.Prepare();
parametreur.GameMode.TopRangeChanged += OnTopRangeChanged;
initStacks();
parametreur.GameMode.PlayerChanged += OnPlayerChanged;
initRule();
CurrentHand = parametreur.players[0].getCardList();
}
createDeck();
defineNbMaxCard();
distribueCard();
CurrentHand = playerList[currentIndexPlayer].getCardList();
nbCardAtBeginOfTurn = CurrentHand.Count;
public void joue(int valueCard, int orderedStackSelected)
{
preparateur.GameMode.playCard(valueCard, currentHand, orderedStackSelected, preparateur.players[currentIndexPlayer], CurrentCardPlayed); // Mettre le joueur actif
EndMessage = preparateur.GameMode.Message;
}
protected void initStacks()
public bool endTurn()
{
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(preparateur.GameMode.endTurn(currentHand, CurrentCardPlayed, preparateur.players[currentIndexPlayer]))
{
if (i < 2)
EndMessage = preparateur.GameMode.Message;
if (isEndGame())
{
ListOrderedStacks[i].Push(new ClassicCard(1));
EndMessage = preparateur.GameMode.Message;
return true;
}
else
{
ListOrderedStacks[i].Push(new ClassicCard(100));
return false;
}
}
else
{
return false;
}
}
protected void initRule()
private bool isEndGame()
{
gameMode = new GameMode();
gameMode.addPlayRule(new Ascendant());
gameMode.addPlayRule(new Descendant());
gameMode.addPlayRule(new PasDeDix());
//gameMode.addPlayRule(new VoidHand());
gameMode.addBeforeEndTurnRule(new NbCardPlay());
gameMode.addEndTurnRule(new EndGame(ListOrderedStacks));
//gameMode.addEndTurnRule(new VoidDeck());
//gameMode.addEndTurnRule(new CompleteHand());
return preparateur.GameMode.isEndGame(currentHand);
}
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++)
{
playerList.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)
{
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;
}
}
}
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);
}
//if ((bottomUp && card.Value > orderedStack.Peek().Value) || (!bottomUp && card.Value < orderedStack.Peek().Value) || card.Value == orderedStack.Peek().Value + 10 || card.Value == orderedStack.Peek().Value - 10)
//{
// Card oldCard = orderedStack.Peek();
// playerList[currentIndexPlayer].joue(card);
// CurrentCardPlayed.Add(card);
// orderedStack.Push(card);
// OnTopRangeChanged(new TopRangeChangedEventArgs(card, oldCard, ListOrderedStacks.IndexOf(orderedStack)));
//}
//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 void pioche();
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(Parametreur parametreur) : base(parametreur)
{
}
}

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

@ -1,177 +1,175 @@
using System;
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(Parametreur parametreur)
: base(parametreur)
{
}
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 override 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(Parametreur parametreur) : base(parametreur)
{
}
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(Parametreur parametreur) : base(parametreur)
{
}
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();
//}
}
}

10
TheGameExtreme/model/rule/InfinitEffect.cs
Unescape View File

@ -1,10 +0,0 @@
using System;
namespace TheGameExtreme.model.rule
{
public class InfinitEffect : Rule
{
public InfinitEffect()
{
}
}
}

38
TheGameExtreme/model/rule/RapidEffect.cs
Unescape View File

@ -1,38 +0,0 @@
using System;
namespace TheGameExtreme.model.rule
{
public class RapidEffect : Rule
{
public RapidEffect()
{
}
// Checker les cartes du haut de pile et celle joué.
//protected bool effectLose()
//{
// foreach (Stack<Card> orderedStack in ListOrderedStacks)
// {
// if (Equals(orderedStack.Peek().getName(), EndGameCard.CARD_ENDGAME))
// {
// return true;
// }
// }
// return false;
//}
//foreach (Card cardPlayed in CurrentCardPlayed)
//{
// if (Equals(cardPlayed.GetType(), ThreeCard.CARD_THREE))
// {
// if ((nbCardAtBeginOfTurn - CurrentHand.Count) < 3)
// {
// return true;
// }
// }
//}
}
}

15
TheGameExtreme/model/rule/Rule.cs
Unescape View File

@ -1,15 +0,0 @@
using System;
using TheGameExtreme.model.card;
namespace TheGameExtreme.model.rule
{
public abstract class Rule
{
public bool Test()
{
throw new NotImplementedException();
}
}
}

13
TheGameExtreme/model/rule/beforeEndTurnRules/BeforeEndTurnRule.cs
Unescape View File

@ -1,13 +0,0 @@
using System;
using System.Collections.Generic;
using TheGameExtreme.model.card;
namespace TheGameExtreme.model.rule.beforeEndTurnRules
{
public abstract class BeforeEndTurnRule : Rule
{
public abstract bool Test(List<Card> CurrentCardPlayed, int nbCardAtBeginOfTurn, List<Card> CurrentHand);
}
}

24
TheGameExtreme/model/rule/beforeEndTurnRules/NbCardPlay.cs
Unescape View File

@ -1,24 +0,0 @@
using System;
using System.Collections.Generic;
using TheGameExtreme.model.card;
namespace TheGameExtreme.model.rule.beforeEndTurnRules
{
public class NbCardPlay : BeforeEndTurnRule
{
override public bool Test(List<Card> CurrentCardPlayed, int nbCardAtBeginOfTurn, List<Card> CurrentHand)
{
if (CurrentHand.Count == 0)
{
return true;
}
if ((nbCardAtBeginOfTurn - CurrentHand.Count) < 2)
{
return false;
}
return true;
}
}
}

24
TheGameExtreme/model/rule/endTurnRules/CompleteHand.cs
Unescape View File

@ -1,24 +0,0 @@
using System;
using System.Collections.Generic;
using TheGameExtreme.model.card;
namespace TheGameExtreme.model.rule.endTurnRules
{
public class CompleteHand : EndTurnRule
{
public static readonly String REGLE_COMPLETEHAND = "Complete Hand";
public override bool Test(List<Card> CurrentCardPlayed, int nbCardAtBeginOfTurn, List<Card> CurrentHand)
{
// Si carte qui fait piocher que d'un vérifier la bonne pioche (penser si elle vient d'être recouverte)
// Sinon
if (nbCardAtBeginOfTurn == CurrentCardPlayed.Count)
{
return true;
}
return false;
}
}
}

13
TheGameExtreme/model/rule/endTurnRules/EndTurnRule.cs
Unescape View File

@ -1,13 +0,0 @@
using System;
using System.Collections.Generic;
using TheGameExtreme.model.card;
namespace TheGameExtreme.model.rule.endTurnRules
{
public abstract class EndTurnRule : Rule
{
public abstract bool Test(List<Card> CurrentCardPlayed, int nbCardAtBeginOfTurn, List<Card> CurrentHand);
}
}

17
TheGameExtreme/model/rule/endTurnRules/VoidDeck.cs
Unescape View File

@ -1,17 +0,0 @@
using System;
using System.Collections.Generic;
using TheGameExtreme.model.card;
namespace TheGameExtreme.model.rule.endTurnRules
{
public class VoidDeck : EndTurnRule
{
public static readonly String REGLE_VOIDDECK = "Void Deck";
public override bool Test(List<Card> CurrentCardPlayed, int nbCardAtBeginOfTurn, List<Card> CurrentHand)
{
throw new NotImplementedException();
}
}
}

22
TheGameExtreme/model/rule/playRules/Ascendant.cs
Unescape View File

@ -1,22 +0,0 @@
using System;
using System.Collections.Generic;
using TheGameExtreme.model.card;
namespace TheGameExtreme.model.rule.playRules
{
public class Ascendant : PlayRule
{
public static readonly String REGLE_ASCENDANT = "Ascendant";
override public bool Test(Card playedCard, Stack<Card> stack, bool bottomUp, List<Card> CurrentHand)
{
if (bottomUp && playedCard.Value > stack.Peek().Value)
{
return true;
}
return false;
}
}
}

21
TheGameExtreme/model/rule/playRules/Descendant.cs
Unescape View File

@ -1,21 +0,0 @@
using System;
using System.Collections.Generic;
using TheGameExtreme.model.card;
namespace TheGameExtreme.model.rule.playRules
{
public class Descendant : PlayRule
{
public static readonly String REGLE_DESCENDANT = "Descendant";
override public bool Test(Card playedCard, Stack<Card> stack, bool bottomUp, List<Card> CurrentHand)
{
if (!bottomUp && playedCard.Value < stack.Peek().Value)
{
return true;
}
return false;
}
}
}

22
TheGameExtreme/model/rule/playRules/PasDeDix.cs
Unescape View File

@ -1,22 +0,0 @@
using System;
using System.Collections.Generic;
using TheGameExtreme.model.card;
namespace TheGameExtreme.model.rule.playRules
{
public class PasDeDix : PlayRule
{
public static readonly String REGLE_PASDEDIX = "PasDeDix";
override public bool Test(Card playedCard, Stack<Card> stack, bool bottomUp, List<Card> CurrentHand)
{
if ((stack.Peek().Value + 10) == playedCard.Value || (stack.Peek().Value - 10) == playedCard.Value)
{
return true;
}
return false;
}
}
}

11
TheGameExtreme/model/rule/playRules/PlayRule.cs
Unescape View File

@ -1,11 +0,0 @@
using System;
using System.Collections.Generic;
using TheGameExtreme.model.card;
namespace TheGameExtreme.model.rule.playRules
{
public abstract class PlayRule : Rule
{
public abstract bool Test(Card playedCard, Stack<Card> stack, bool bottomUp, List<Card> CurrentHand);
}
}

22
TheGameExtreme/model/rule/playRules/VoidHand.cs
Unescape View File

@ -1,22 +0,0 @@
using System;
using System.Collections.Generic;
using TheGameExtreme.model.card;
namespace TheGameExtreme.model.rule.playRules
{
public class VoidHand : PlayRule
{
public static readonly String REGLE_VOIDHAND = "Void Hand";
override public bool Test(Card playedCard, Stack<Card> stack, bool bottomUp, List<Card> CurrentHand)
{
if (CurrentHand.Count == 0)
{
return false;
}
return true;
}
}
}

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

@ -33,12 +33,19 @@ namespace TheGameExtreme.view
viewmodel.BindingChanged += OnBindingChanged;
//viewmodel.PlayerChanged += OnPlayerChanged;
Alert.SetBinding(Label.TextProperty, new Binding("Alert", source: viewmodel));
pseudo.SetBinding(Label.TextProperty, new Binding("Pseudo", source: viewmodel));
inflateHand();
}
//private void OnPlayerChanged(object sender, PlayerChangedEventArgs args)
//{
// inflateHand();
//}
private void inflateHand()
{
Hand.Children.Clear();
@ -145,6 +152,7 @@ namespace TheGameExtreme.view
private void endTurn(object sender, EventArgs args)
{
viewmodel.Alert = "";
if (viewmodel.endTurn())
{
botPanel.Children.Add(button);

33
TheGameExtreme/viewmodel/CardVM.cs
Unescape View File

@ -0,0 +1,33 @@
using System;
using System.ComponentModel;
using TheGameExtreme.model.card;
namespace TheGameExtreme.viewmodel
{
public class CardVM : INotifyPropertyChanged
{
public event PropertyChangedEventHandler PropertyChanged;
public Card View { get; set; }
private int value;
public int Value {
get { return value; }
set
{
this.value = value;
OnPropertyChanged("Value");
}
}
protected virtual void OnPropertyChanged(string info)
{
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(info));
}
public CardVM(Card view)
{
View = view;
Value = view.Value;
}
}
}

143
TheGameExtreme/viewmodel/Main.cs
Unescape View File

@ -2,8 +2,10 @@
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using TheGameExtreme.model;
using TheGameExtreme.model.card;
using TheGameExtreme.model.@event;
using TheGameExtreme.model.gameActions.classic;
using TheGameExtreme.model.manager;
namespace TheGameExtreme.viewmodel
@ -11,8 +13,10 @@ namespace TheGameExtreme.viewmodel
public class Main : INotifyPropertyChanged
{
//public event EventHandler<PlayerChangedEventArgs> PlayerChanged;
public event EventHandler<TopRangeChangedEventArgs> BindingChanged;
public event PropertyChangedEventHandler PropertyChanged;
private List<PlayerVM> players = new List<PlayerVM>();
private string alert = "";
public String Alert
{
@ -45,14 +49,20 @@ namespace TheGameExtreme.viewmodel
public Main()
{
gameManager = new SoloGameManager(2, new List<String> { "Clément", "Baptiste" }) ; // Donner le nom des joueurs
List<string> playersNames = new List<string> { "Clément", "Baptiste" };
playersNames.ForEach(name => players.Add(new PlayerVM(new Player(name))));
Parametreur parametreur = new Parametreur(new GameMode());
players.ForEach(player => parametreur.AddPlayer(player.View));
gameManager = new SoloGameManager(parametreur) ; // Donner le nom des joueurs
gameManager.TopRangeChanged += OnTopRangeChanged;
gameManager.TopRangeChanged += OnBindingChanged;
gameManager.PlayerChanged += OnPlayerChanged;
CurrentHand = gameManager.CurrentHand;
Pseudo = players[0].Pseudo;
//ListOrderedStacks = new ObservableCollection<Stack<Card>>(gameManager.ListOrderedStacks);
}
@ -60,13 +70,21 @@ namespace TheGameExtreme.viewmodel
{
CurrentHand = args.NewCurrentHand;
Pseudo = args.Pseudo;
//PlayerChanged?.Invoke(this, args);
}
public void OnTopRangeChanged(object source, TopRangeChangedEventArgs args)
public void OnBindingChanged(object source, TopRangeChangedEventArgs args)
{
BindingChanged?.Invoke(this, args);
}
/**
*
*
@ -74,56 +92,89 @@ namespace TheGameExtreme.viewmodel
*/
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
//try
//{
gameManager.joue(valueCard, numStack);
Alert = gameManager.EndMessage;
//if (gameManager.EndMessage != null)
//{
// Alert = gameManager.EndMessage;
// return true;
//}
return false;
}
}
//}
//catch (Exception e)
//{
// // Faire un toast
// Alert = e.Message;
//}
//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;
//if (gameManager.isCanPlay())
//{
// return playOneCard(numStack, valueCard);
//}
//else
//{
// Alert = "Le joueur n'a plus de carte dans sa main!";
// // Faire un toast
// return false;
//}
}
public bool endTurn()
{
try
{
bool isEnd = gameManager.endTurn();
Alert = gameManager.EndMessage;
return isEnd;
}
catch(Exception e)
{
Alert = e.Message;
return false;
}
bool isEnd = gameManager.endTurn();
Alert = gameManager.EndMessage;
return isEnd;
}
///**
// *
// *
// * @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;
// }
//}
}
}

49
TheGameExtreme/viewmodel/PlayerVM.cs
Unescape View File

@ -0,0 +1,49 @@
using System;
using System.Collections.Generic;
using TheGameExtreme.model;
using TheGameExtreme.model.card;
using TheGameExtreme.model.@event;
namespace TheGameExtreme.viewmodel
{
public class PlayerVM
{
public Player View { get; set; }
public string Pseudo { get; set; }
private List<CardVM> cardList = new List<CardVM>();
//public event EventHandler<HandCardChangedEventArgs> HandCardChanged;
public PlayerVM(Player view)
{
View = view;
Pseudo = view.Pseudo;
view.getCardList().ForEach(card => cardList.Add(new CardVM(card)));
View.HandCardChanged += OnHandCardChanged;
}
private void OnHandCardChanged(object sender, HandCardChangedEventArgs args)
{
if (args.NewCard == null)
{
cardList.RemoveAt(args.Position);
}
else
{
cardList.Insert(args.Position, new CardVM(args.NewCard));
}
}
public void pioche(CardVM card)
{
View.pioche(card.View);
}
public List<CardVM> getCardList()
{
return cardList;
}
}
}
Write Preview
Loading…
Cancel
Save