From f7d6f41f00c1fc3106f7705eff9a0c99df7d181b Mon Sep 17 00:00:00 2001 From: cldupland Date: Wed, 18 Dec 2019 15:48:53 +0100 Subject: [PATCH] Ajout commentaire --- OrderStacks/Resx/AppResources.Designer.cs | 234 +++--------------- .../gameActions/abstractRules/GameAction.cs | 2 +- .../gameActions/abstractRules/GameMode.cs | 40 ++- .../abstractRules/JouerUneCarte.cs | 27 ++ .../gameActions/abstractRules/Piocher.cs | 13 + .../abstractRules/TerminerSonTour.cs | 31 +++ .../gameActions/classic/GameModeClassic.cs | 44 +++- .../classic/JouerUneCarteClassic.cs | 28 ++- .../gameActions/classic/PiocherClassic.cs | 14 +- .../classic/TerminerSonTourClassic.cs | 36 ++- .../gameActions/decimals/GameModeDecimal.cs | 43 ++++ .../decimals/JouerUneCarteDecimal.cs | 27 ++ .../decimals/TerminerSonTourDecimal.cs | 24 ++ .../gameActions/fraction/GameModeFraction.cs | 43 ++++ .../fraction/JouerUneCarteFraction.cs | 27 ++ .../fraction/TerminerSonTourFraction.cs | 24 ++ OrderStacks/view/MainPage.xaml.cs | 1 - 17 files changed, 434 insertions(+), 224 deletions(-) diff --git a/OrderStacks/Resx/AppResources.Designer.cs b/OrderStacks/Resx/AppResources.Designer.cs index 94b3f7f..13cce36 100644 --- a/OrderStacks/Resx/AppResources.Designer.cs +++ b/OrderStacks/Resx/AppResources.Designer.cs @@ -1,57 +1,44 @@ //------------------------------------------------------------------------------ // -// Ce code a été généré par un outil. -// Version du runtime :4.0.30319.42000 +// This code was generated by a tool. +// Runtime Version:4.0.30319.42000 // -// Les modifications apportées à ce fichier peuvent provoquer un comportement incorrect et seront perdues si -// le code est régénéré. +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. // //------------------------------------------------------------------------------ namespace OrderStacks.Resx { using System; + using System.Reflection; - /// - /// Une classe de ressource fortement typée destinée, entre autres, à la consultation des chaînes localisées. - /// - // Cette classe a été générée automatiquement par la classe StronglyTypedResourceBuilder - // à l'aide d'un outil, tel que ResGen ou Visual Studio. - // Pour ajouter ou supprimer un membre, modifiez votre fichier .ResX, puis réexécutez ResGen - // avec l'option /str ou régénérez votre projet VS. - [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "16.0.0.0")] - [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] - [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + [System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")] + [System.Diagnostics.DebuggerNonUserCodeAttribute()] + [System.Runtime.CompilerServices.CompilerGeneratedAttribute()] public class AppResources { - private static global::System.Resources.ResourceManager resourceMan; + private static System.Resources.ResourceManager resourceMan; - private static global::System.Globalization.CultureInfo resourceCulture; + private static System.Globalization.CultureInfo resourceCulture; - [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + [System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] internal AppResources() { } - /// - /// Retourne l'instance ResourceManager mise en cache utilisée par cette classe. - /// - [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] - public static global::System.Resources.ResourceManager ResourceManager { + [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Advanced)] + public static System.Resources.ResourceManager ResourceManager { get { - if (object.ReferenceEquals(resourceMan, null)) { - global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("OrderStacks.Resx.AppResources", typeof(AppResources).Assembly); + if (object.Equals(null, resourceMan)) { + System.Resources.ResourceManager temp = new System.Resources.ResourceManager("OrderStacks.Resx.AppResources", typeof(AppResources).Assembly); resourceMan = temp; } return resourceMan; } } - /// - /// Remplace la propriété CurrentUICulture du thread actuel pour toutes - /// les recherches de ressources à l'aide de cette classe de ressource fortement typée. - /// - [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] - public static global::System.Globalization.CultureInfo Culture { + [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Advanced)] + public static System.Globalization.CultureInfo Culture { get { return resourceCulture; } @@ -60,469 +47,306 @@ namespace OrderStacks.Resx { } } - /// - /// Recherche une chaîne localisée semblable à OrderStacks - /// - ///A votre disposition, un mode de jeu en local, jouable jusqu'à 5 joueurs. - /// - ///Un mode multijoueur en cours de développement. - /// - ///Une présentation des règles du jeu. - /// - ///Une possibilité de changer le thème de l'application grâce aux images du soleil et lune.. - /// public static string StrAbout { get { return ResourceManager.GetString("StrAbout", resourceCulture); } } - /// - /// Recherche une chaîne localisée semblable à Pile ascendante. - /// public static string StrAcendingStack { get { return ResourceManager.GetString("StrAcendingStack", resourceCulture); } } - /// - /// Recherche une chaîne localisée semblable à Jouer. - /// public static string StrBtnPlay { get { return ResourceManager.GetString("StrBtnPlay", resourceCulture); } } - /// - /// Recherche une chaîne localisée semblable à La pile n'est pas disponnible. - /// public static string StrCantGetStack { get { return ResourceManager.GetString("StrCantGetStack", resourceCulture); } } - /// - /// Recherche une chaîne localisée semblable à La carte n'existe pas . - /// public static string StrCardDoesntExist { get { return ResourceManager.GetString("StrCardDoesntExist", resourceCulture); } } - /// - /// Recherche une chaîne localisée semblable à Vous devez jouer au minimum deux cartes par tour. - /// public static string StrCardPlayedLessThanTwo { get { return ResourceManager.GetString("StrCardPlayedLessThanTwo", resourceCulture); } } - /// - /// Recherche une chaîne localisée semblable à Fermer. - /// public static string StrCloseWind { get { return ResourceManager.GetString("StrCloseWind", resourceCulture); } } - /// - /// Recherche une chaîne localisée semblable à Pile descendante. - /// public static string StrDownStack { get { return ResourceManager.GetString("StrDownStack", resourceCulture); } } - /// - /// Recherche une chaîne localisée semblable à Fin de tour. - /// public static string StrEndTurn { get { return ResourceManager.GetString("StrEndTurn", resourceCulture); } } - /// - /// Recherche une chaîne localisée semblable à Entrez votre pseudo. - /// public static string StrEnterPseudo { get { return ResourceManager.GetString("StrEnterPseudo", resourceCulture); } } - /// - /// Recherche une chaîne localisée semblable à A propos. - /// public static string StrInfo { get { return ResourceManager.GetString("StrInfo", resourceCulture); } } - /// - /// Recherche une chaîne localisée semblable à La partie est terminée. - /// public static string String3 { get { return ResourceManager.GetString("String3", resourceCulture); } } - /// - /// Recherche une chaîne localisée semblable à Bravo vous avez gagné!. - /// public static string String4 { get { return ResourceManager.GetString("String4", resourceCulture); } } - /// - /// Recherche une chaîne localisée semblable à Lancer une partie. - /// public static string StrLocalGame { get { return ResourceManager.GetString("StrLocalGame", resourceCulture); } } - /// - /// Recherche une chaîne localisée semblable à . - /// public static string StrLose { get { return ResourceManager.GetString("StrLose", resourceCulture); } } - /// - /// Recherche une chaîne localisée semblable à Multijoueur. - /// public static string StrMultiplayer { get { return ResourceManager.GetString("StrMultiplayer", resourceCulture); } } - /// - /// Recherche une chaîne localisée semblable à Nombre de cartes :. - /// public static string StrNbCards { get { return ResourceManager.GetString("StrNbCards", resourceCulture); } } - /// - /// Recherche une chaîne localisée semblable à Joueurs :. - /// public static string StrNbPlayers { get { return ResourceManager.GetString("StrNbPlayers", resourceCulture); } } - /// - /// Recherche une chaîne localisée semblable à Nombre de piles en jeu :. - /// public static string StrNbStacksInGame { get { return ResourceManager.GetString("StrNbStacksInGame", resourceCulture); } } - /// - /// Recherche une chaîne localisée semblable à Suivant. - /// public static string StrNext { get { return ResourceManager.GetString("StrNext", resourceCulture); } } - /// - /// Recherche une chaîne localisée semblable à Veuillez choisir un nombre de joueur ainsi que leur(s) nom(s). - /// public static string StrPlayerSelections { get { return ResourceManager.GetString("StrPlayerSelections", resourceCulture); } } - /// - /// Recherche une chaîne localisée semblable à Entrez votre pseudo :. - /// public static string StrPseudoGM { get { return ResourceManager.GetString("StrPseudoGM", resourceCulture); } } - /// - /// Recherche une chaîne localisée semblable à Rejouer. - /// public static string StrRetry { get { return ResourceManager.GetString("StrRetry", resourceCulture); } } - /// - /// Recherche une chaîne localisée semblable à - L'objectif est de battre la machine seul et/ou en coopération.. - /// public static string StrTiret1 { get { return ResourceManager.GetString("StrTiret1", resourceCulture); } } - /// - /// Recherche une chaîne localisée semblable à - Une fois votre tour terminé, vous appuyez sur le boutton "Fin de tour" afin de passer au joueur suivant.. - /// public static string StrTiret10 { get { return ResourceManager.GetString("StrTiret10", resourceCulture); } } - /// - /// Recherche une chaîne localisée semblable à - La partie est finie quand toutes les cartes sont jouées ou quand le joueur dont c'est le tour ne peut plus jouer.. - /// public static string StrTiret11 { get { return ResourceManager.GetString("StrTiret11", resourceCulture); } } - /// - /// Recherche une chaîne localisée semblable à - Afin de préparer la partie, vous disposez d'un écran permettant de choisir le nombre de joueur et leur pseudo, le type de jeu auquels vous souhaitez jouer et enfin le nombre de piles pour jouer.. - /// public static string StrTiret12 { get { return ResourceManager.GetString("StrTiret12", resourceCulture); } } - /// - /// Recherche une chaîne localisée semblable à - Le type de jeu permet de définir les valeurs présentent sur les cartes. Vous pouvez jouer avec des valeurs entières, relatives, décimales (1 chiffre), décimales (2 chiffres), décimales (3 chiffres) et avec des fractions décimales. - /// public static string StrTiret13 { get { return ResourceManager.GetString("StrTiret13", resourceCulture); } } - /// - /// Recherche une chaîne localisée semblable à - Afin d'atteindre l'objectif, les joueurs disposent de 4 piles (par défaut): deux piles ascendantes vertes et deux piles descendantes rouges.. - /// public static string StrTiret2 { get { return ResourceManager.GetString("StrTiret2", resourceCulture); } } - /// - /// Recherche une chaîne localisée semblable à - Sur les piles ascendantes vertes, le joueur peut poser des cartes plus grandes et sur les piles descendantes rouges, le joueur peut poser des cartes plus petites.. - /// public static string StrTiret3 { get { return ResourceManager.GetString("StrTiret3", resourceCulture); } } - /// - /// Recherche une chaîne localisée semblable à - Le but est de poser toutes les cartes du jeu sur les différentes piles.. - /// public static string StrTiret4 { get { return ResourceManager.GetString("StrTiret4", resourceCulture); } } - /// - /// Recherche une chaîne localisée semblable à - Pour jouer, il suffit de faire glisser une carte sur la pile souhaitée.. - /// public static string StrTiret5 { get { return ResourceManager.GetString("StrTiret5", resourceCulture); } } - /// - /// Recherche une chaîne localisée semblable à - Cette carte doit être plus grande que celle déjà présente s'il s'agit d'une pile ascendante et plus petite si c'est l'inverse.. - /// public static string StrTiret6 { get { return ResourceManager.GetString("StrTiret6", resourceCulture); } } - /// - /// Recherche une chaîne localisée semblable à - Il est possible de poser une carte plus petite que celle de la pile ascendante à condition que la carte que l'on souhaite jouer soit uniquement plus petite d'une dizaine que le carte sur la pile. De la même manière pour les piles descendantes, il est possible de poser une carte plus grande que celle de la pile descendante à condition que la carte que l'on souhaite jouer soit uniquement plus grande d'une dizaine que le carte sur la pile.. - /// public static string StrTiret7 { get { return ResourceManager.GetString("StrTiret7", resourceCulture); } } - /// - /// Recherche une chaîne localisée semblable à - Exemples : Sur une pile descendante, si nous avons 22 alors il est possible de poser 32. - /// Sur une pile ascendante, si nous avons 16 alors il est possible de poser 6.. - /// public static string StrTiret8 { get { return ResourceManager.GetString("StrTiret8", resourceCulture); } } - /// - /// Recherche une chaîne localisée semblable à - Chaque joueur doit jouer au minimum deux cartes par tour. - /// La seule limite de cartes jouées par tour est donc le nombre de cartes possédées au début de chaque tour. Cependant, il est conseillé dans la plupart des cas de ne pas jouer toutes les cartes en sa possessions.. - /// public static string StrTiret9 { get { return ResourceManager.GetString("StrTiret9", resourceCulture); } } - /// - /// Recherche une chaîne localisée semblable à OrderStacks. - /// public static string StrTitle { get { return ResourceManager.GetString("StrTitle", resourceCulture); } } - /// - /// Recherche une chaîne localisée semblable à Règles. - /// public static string StrTitleRules { get { return ResourceManager.GetString("StrTitleRules", resourceCulture); } } - /// - /// Recherche une chaîne localisée semblable à Valeurs :. - /// public static string StrValueType { get { return ResourceManager.GetString("StrValueType", resourceCulture); } } - /// - /// Recherche une chaîne localisée semblable à Félicitation vous avez gagné. - /// public static string StrWin { get { return ResourceManager.GetString("StrWin", resourceCulture); } } - /// - /// Recherche une chaîne localisée semblable à La carte choisie ne convient pas. - /// public static string StrWrongStack { get { return ResourceManager.GetString("StrWrongStack", resourceCulture); } } - /// - /// Recherche une chaîne localisée semblable à Fractionnées. - /// public static string TypeValuefractionated { get { return ResourceManager.GetString("TypeValuefractionated", resourceCulture); } } - /// - /// Recherche une chaîne localisée semblable à 2 Décimales. - /// - public static string TypeValueHundredth { - get { - return ResourceManager.GetString("TypeValueHundredth", resourceCulture); - } - } - - /// - /// Recherche une chaîne localisée semblable à 2 Décimales (Fraction). - /// public static string TypeValueHundredthFract { get { return ResourceManager.GetString("TypeValueHundredthFract", resourceCulture); } } - /// - /// Recherche une chaîne localisée semblable à Relatives. - /// public static string TypeValueRelative { get { return ResourceManager.GetString("TypeValueRelative", resourceCulture); } } - /// - /// Recherche une chaîne localisée semblable à 1 Décimales. - /// - public static string TypeValueTenth { - get { - return ResourceManager.GetString("TypeValueTenth", resourceCulture); - } - } - - /// - /// Recherche une chaîne localisée semblable à 1 Décimales (Fraction). - /// public static string TypeValueTenthFract { get { return ResourceManager.GetString("TypeValueTenthFract", resourceCulture); } } - /// - /// Recherche une chaîne localisée semblable à 3 Décimales (Fraction). - /// public static string TypeValueThousandthFract { get { return ResourceManager.GetString("TypeValueThousandthFract", resourceCulture); } } - /// - /// Recherche une chaîne localisée semblable à Entière. - /// public static string TypeValueWhole { get { return ResourceManager.GetString("TypeValueWhole", resourceCulture); } } - /// - /// Recherche une chaîne localisée semblable à Thème clair :. - /// + public static string TypeValueTenth { + get { + return ResourceManager.GetString("TypeValueTenth", resourceCulture); + } + } + + public static string TypeValueHundredth { + get { + return ResourceManager.GetString("TypeValueHundredth", resourceCulture); + } + } + public static string WhiteTheme { get { return ResourceManager.GetString("WhiteTheme", resourceCulture); } } - /// - /// Recherche une chaîne localisée semblable à Erreur pseudo :. - /// public static string WrongPseudo { get { return ResourceManager.GetString("WrongPseudo", resourceCulture); diff --git a/OrderStacks/model/gameActions/abstractRules/GameAction.cs b/OrderStacks/model/gameActions/abstractRules/GameAction.cs index e282202..4ac91bf 100644 --- a/OrderStacks/model/gameActions/abstractRules/GameAction.cs +++ b/OrderStacks/model/gameActions/abstractRules/GameAction.cs @@ -9,7 +9,7 @@ namespace OrderStacks.model.gameActions.abstractRules public string ErrorMessage { get; set; } = ""; /** - *Piles de jeu + * Piles de jeu * * Constructeur */ diff --git a/OrderStacks/model/gameActions/abstractRules/GameMode.cs b/OrderStacks/model/gameActions/abstractRules/GameMode.cs index 6109c9f..48b3c4a 100644 --- a/OrderStacks/model/gameActions/abstractRules/GameMode.cs +++ b/OrderStacks/model/gameActions/abstractRules/GameMode.cs @@ -108,9 +108,9 @@ namespace OrderStacks.model.gameActions.abstractRules } /** + * Liste de joueur * - * - * + * Fonction permettant de distribuer les cartes en début de partie */ protected void distribueCard(List players) { @@ -127,14 +127,50 @@ namespace OrderStacks.model.gameActions.abstractRules }); } + /** + * Liste de carte du joueur actif + * Joueur actif + * + * Fonction permettant au joueur actif de piocher une carte + */ public abstract void pioche(List currentHand, Player player); + /** + * Joueur actif + * Liste de carte du joeuur actif + * Liste des cartes jouées durant le tour du joueur actif + * Pile séléctionnée + * Valeur de la carte en train d'être joué + * + * Fonction permettant de tenter de jouer une carte + * + * Booléen de carte joué + */ public abstract bool playCard(decimal valueCard, List currentHand, int orderedStackSelected, Player player, List CurrentCardPlayed); + /** + * Liste de carte du joueur actif + * Liste des cartes jouées durant le tour du joueur actif + * Joueur actif + * + * Fonction permettant de lancer la fin du tour et de vérifier la fin du jeu + * + * Booléen de fin de jeu + */ public abstract bool endTurn(List currentHand, List CurrentCardPlayed, Player player); + /** + * Liste de carte du joueur actif + * + * Fonction permettant de vérifier si c'est la fin du jeu + */ public abstract void TestEndGame(List currentHand); + /** + * Fonction permettant de retourner le nombre de carte du deck + * + * Nombre de carte dans le deck + */ public int getScore() { return deck.size(); diff --git a/OrderStacks/model/gameActions/abstractRules/JouerUneCarte.cs b/OrderStacks/model/gameActions/abstractRules/JouerUneCarte.cs index ca249a7..2bc0d18 100644 --- a/OrderStacks/model/gameActions/abstractRules/JouerUneCarte.cs +++ b/OrderStacks/model/gameActions/abstractRules/JouerUneCarte.cs @@ -9,12 +9,39 @@ namespace OrderStacks.model.gameActions.abstractRules public Card OldCard { get; set; } + /** + * Piles de jeu + * + * Constructeur + */ protected JouerUneCarte(Piles ListOrderedStacks) : base(ListOrderedStacks) { } + /** + * Joueur actif + * Liste de carte du joeuur actif + * Liste des cartes jouées durant le tour du joueur actif + * Pile séléctionnée + * Valeur de la carte en train d'être joué + * + * Fonction permettant de tenter de jouer une carte + * + * Booléen de carte joué + */ public abstract bool play(decimal valueCard, List CurrentHand, int orderedStackSelected, Player player, List CurrentCardPlayed); + /** + * Joueur actif + * Liste des cartes jouées durant le tour du joueur actif + * Booléen d'ascendance + * Carte joué + * Pile joué + * + * Fonction permettant de tenter de jouer une carte + * + * Booléen de carte joué + */ protected abstract bool Rule(Card card, Stack stack, bool bottomUp, Player player, List CurrentCardPlayed); } } diff --git a/OrderStacks/model/gameActions/abstractRules/Piocher.cs b/OrderStacks/model/gameActions/abstractRules/Piocher.cs index fdb87aa..4b99c3c 100644 --- a/OrderStacks/model/gameActions/abstractRules/Piocher.cs +++ b/OrderStacks/model/gameActions/abstractRules/Piocher.cs @@ -7,10 +7,23 @@ namespace OrderStacks.model.gameActions.abstractRules { public abstract class Piocher : GameAction { + /** + * Piles de jeu + * + * Constructeur + */ public Piocher(Piles ListOrderedStacks) : base(ListOrderedStacks) { } + /** + * Joueur actif + * Liste de carte du joeuur actif + * Liste de carte non découverte + * Nombre maximum de carte dans la main pour le joueur actif + * + * Fonction permettant de faire piocher un joueur + */ public abstract void pioche(List CurrentHand, Deck deck, Player player, int nbMaxCard); } } diff --git a/OrderStacks/model/gameActions/abstractRules/TerminerSonTour.cs b/OrderStacks/model/gameActions/abstractRules/TerminerSonTour.cs index 6142276..53efd9d 100644 --- a/OrderStacks/model/gameActions/abstractRules/TerminerSonTour.cs +++ b/OrderStacks/model/gameActions/abstractRules/TerminerSonTour.cs @@ -6,12 +6,32 @@ namespace OrderStacks.model.gameActions.abstractRules { public abstract class TerminerSonTour : GameAction { + /** + * Piles de jeu + * + * Constructeur + */ protected TerminerSonTour(Piles ListOrderedStacks) : base(ListOrderedStacks) { } + /** + * Liste de carte du joeuur actif + * Liste des cartes jouées durant le tour du joueur actif + * + * Fonction permettant de terminer son tour + * + * Booléen indiquant si le changement de joueur peut se passer + */ public abstract bool end(List CurrentHand, List CurrentCardPlayed); + /** + * Liste de carte du joueur actif + * + * Fonction permettant de gérer le test de fin du jeu + * + * Booléen de fin du jeu + */ public bool Test(List CurrentHand) { if (CurrentHand.Count != 0) @@ -23,8 +43,19 @@ namespace OrderStacks.model.gameActions.abstractRules return false; } + /** + * Liste de carte du joueur actif + * Liste des cartes jouables + * + * Fonction permettant de chercher les cartes pouvants être jouées et les ajoutes à la liste des cartes jouables + */ protected abstract void tryToFindSoluce(List playableCard, List CurrentHand); + /** + * Liste des cartes jouables + * + * Fonction vérifiant que les règles de fin de jeu ne sont pas arrivé + */ protected abstract bool testEndGame(List playableCard); } } diff --git a/OrderStacks/model/gameActions/classic/GameModeClassic.cs b/OrderStacks/model/gameActions/classic/GameModeClassic.cs index 6ee064f..4c3029a 100644 --- a/OrderStacks/model/gameActions/classic/GameModeClassic.cs +++ b/OrderStacks/model/gameActions/classic/GameModeClassic.cs @@ -9,11 +9,22 @@ namespace OrderStacks.model.gameActions.classic { public class GameModeClassic : GameMode { - + /** + * Deck de carte + * Piles du jeu + * + * Constructeur + */ public GameModeClassic(Piles piles, Deck deck) : base(piles, deck) { } + /** + * Nombre de joueur + * Pseudo du/des joueur(s) + * + * Fonction permettant de charger les paramètres de jeu + */ override public void load(int nbPlayer, List players) { gameActions.Add(new PiocherClassic(Piles)); @@ -24,6 +35,12 @@ namespace OrderStacks.model.gameActions.classic distribueCard(players); } + /** + * Liste de carte du joueur actif + * Joueur actif + * + * Fonction permettant au joueur actif de piocher une carte + */ override public void pioche(List currentHand, Player player) { Message = ""; @@ -31,6 +48,17 @@ namespace OrderStacks.model.gameActions.classic quickSort(currentHand, 0, currentHand.Count - 1); } + /** + * Joueur actif + * Liste de carte du joeuur actif + * Liste des cartes jouées durant le tour du joueur actif + * Pile séléctionnée + * Valeur de la carte en train d'être joué + * + * Fonction permettant de tenter de jouer une carte + * + * Booléen de carte joué + */ override public bool playCard(decimal valueCard, List currentHand, int orderedStackSelected, Player player, List CurrentCardPlayed) { Message = ""; @@ -48,6 +76,15 @@ namespace OrderStacks.model.gameActions.classic } } + /** + * Liste de carte du joueur actif + * Liste des cartes jouées durant le tour du joueur actif + * Joueur actif + * + * Fonction permettant de lancer la fin du tour et de vérifier la fin du jeu + * + * Booléen de fin de jeu + */ override public bool endTurn(List currentHand, List CurrentCardPlayed, Player player) { Message = ""; @@ -65,6 +102,11 @@ namespace OrderStacks.model.gameActions.classic } } + /** + * Liste de carte du joueur actif + * + * Fonction permettant de vérifier si c'est la fin du jeu + */ override public void TestEndGame(List currentHand) { if (((TerminerSonTourClassic)gameActions[2]).Test(currentHand)) diff --git a/OrderStacks/model/gameActions/classic/JouerUneCarteClassic.cs b/OrderStacks/model/gameActions/classic/JouerUneCarteClassic.cs index cb87130..129c10a 100644 --- a/OrderStacks/model/gameActions/classic/JouerUneCarteClassic.cs +++ b/OrderStacks/model/gameActions/classic/JouerUneCarteClassic.cs @@ -8,11 +8,26 @@ namespace OrderStacks.model.gameActions.classic { public class JouerUneCarteClassic : JouerUneCarte { - + /** + * Piles de jeu + * + * Constructeur + */ public JouerUneCarteClassic(Piles ListOrderedStacks) : base(ListOrderedStacks) { } + /** + * Joueur actif + * Liste de carte du joeuur actif + * Liste des cartes jouées durant le tour du joueur actif + * Pile séléctionnée + * Valeur de la carte en train d'être joué + * + * Fonction permettant de tenter de jouer une carte + * + * Booléen de carte joué + */ override public bool play(decimal valueCard, List CurrentHand, int orderedStackSelected, Player player, List CurrentCardPlayed) { foreach (Card card in CurrentHand) @@ -48,6 +63,17 @@ namespace OrderStacks.model.gameActions.classic return false; } + /** + * Joueur actif + * Liste des cartes jouées durant le tour du joueur actif + * Booléen d'ascendance + * Carte joué + * Pile joué + * + * Fonction permettant de tenter de jouer une carte + * + * Booléen de carte joué + */ override protected bool Rule(Card card, Stack stack, bool bottomUp, Player player, List CurrentCardPlayed) { if ((bottomUp && card.Value.CompareTo(stack.Peek().Value) > 0) || (!bottomUp && card.Value.CompareTo(stack.Peek().Value) < 0) || card.Value.CompareTo(stack.Peek().Value - 10) == 0 || card.Value.CompareTo(stack.Peek().Value + 10) == 0) diff --git a/OrderStacks/model/gameActions/classic/PiocherClassic.cs b/OrderStacks/model/gameActions/classic/PiocherClassic.cs index 96f6cbc..b0edf09 100644 --- a/OrderStacks/model/gameActions/classic/PiocherClassic.cs +++ b/OrderStacks/model/gameActions/classic/PiocherClassic.cs @@ -9,11 +9,23 @@ namespace OrderStacks.model.gameActions.classic { public class PiocherClassic : Piocher { - + /** + * Piles de jeu + * + * Constructeur + */ public PiocherClassic(Piles ListOrderedStacks) : base(ListOrderedStacks) { } + /** + * Joueur actif + * Liste de carte du joeuur actif + * Liste de carte non découverte + * Nombre maximum de carte dans la main pour le joueur actif + * + * Fonction permettant de faire piocher un joueur + */ override public void pioche(List CurrentHand, Deck deck, Player player, int nbMaxCard) { int nbPickedCard = nbMaxCard - CurrentHand.Count; diff --git a/OrderStacks/model/gameActions/classic/TerminerSonTourClassic.cs b/OrderStacks/model/gameActions/classic/TerminerSonTourClassic.cs index 614e6f8..d842668 100644 --- a/OrderStacks/model/gameActions/classic/TerminerSonTourClassic.cs +++ b/OrderStacks/model/gameActions/classic/TerminerSonTourClassic.cs @@ -8,11 +8,23 @@ namespace OrderStacks.model.gameActions.classic { public class TerminerSonTourClassic : TerminerSonTour { - + /** + * Piles de jeu + * + * Constructeur + */ public TerminerSonTourClassic(Piles ListOrderedStacks) : base(ListOrderedStacks) { } + /** + * Liste de carte du joeuur actif + * Liste des cartes jouées durant le tour du joueur actif + * + * Fonction permettant de terminer son tour + * + * Booléen indiquant si le changement de joueur peut se passer + */ override public bool end(List CurrentHand, List CurrentCardPlayed) { if (CurrentHand.Count == 0 || CurrentCardPlayed.Count >= 2) @@ -27,6 +39,12 @@ namespace OrderStacks.model.gameActions.classic } + /** + * Liste de carte du joueur actif + * Liste des cartes jouables + * + * Fonction permettant de chercher les cartes pouvants être jouées et les ajoutes à la liste des cartes jouables + */ override protected void tryToFindSoluce(List playableCard, List CurrentHand) { int findDownCard = 0; @@ -152,19 +170,13 @@ namespace OrderStacks.model.gameActions.classic }); } + /** + * Liste des cartes jouables + * + * Fonction vérifiant que les règles de fin de jeu ne sont pas arrivé + */ override protected bool testEndGame(List playableCard) { - //if (playableCard.Count == 2) - //{ - // foreach (Card c in playableCard) - // { - // if (Equals(c.getName(), ThreeCard.CARD_THREE)) - // { - // return false; - // } - // } - //} - //else if (playableCard.Count < 2) { return false; diff --git a/OrderStacks/model/gameActions/decimals/GameModeDecimal.cs b/OrderStacks/model/gameActions/decimals/GameModeDecimal.cs index 729a3c5..b854a93 100644 --- a/OrderStacks/model/gameActions/decimals/GameModeDecimal.cs +++ b/OrderStacks/model/gameActions/decimals/GameModeDecimal.cs @@ -10,10 +10,22 @@ namespace OrderStacks.model.gameActions.decimals { public class GameModeDecimal : GameMode { + /** + * Deck de carte + * Piles du jeu + * + * Constructeur + */ public GameModeDecimal(Piles piles, Deck deck) : base(piles, deck) { } + /** + * Nombre de joueur + * Pseudo du/des joueur(s) + * + * Fonction permettant de charger les paramètres de jeu + */ override public void load(int nbPlayer, List players) { gameActions.Add(new PiocherClassic(Piles)); @@ -24,6 +36,12 @@ namespace OrderStacks.model.gameActions.decimals distribueCard(players); } + /** + * Liste de carte du joueur actif + * Joueur actif + * + * Fonction permettant au joueur actif de piocher une carte + */ override public void pioche(List currentHand, Player player) { Message = ""; @@ -31,6 +49,17 @@ namespace OrderStacks.model.gameActions.decimals quickSort(currentHand, 0, currentHand.Count - 1); } + /** + * Joueur actif + * Liste de carte du joeuur actif + * Liste des cartes jouées durant le tour du joueur actif + * Pile séléctionnée + * Valeur de la carte en train d'être joué + * + * Fonction permettant de tenter de jouer une carte + * + * Booléen de carte joué + */ override public bool playCard(decimal valueCard, List currentHand, int orderedStackSelected, Player player, List CurrentCardPlayed) { Message = ""; @@ -48,6 +77,15 @@ namespace OrderStacks.model.gameActions.decimals } } + /** + * Liste de carte du joueur actif + * Liste des cartes jouées durant le tour du joueur actif + * Joueur actif + * + * Fonction permettant de lancer la fin du tour et de vérifier la fin du jeu + * + * Booléen de fin de jeu + */ override public bool endTurn(List currentHand, List CurrentCardPlayed, Player player) { Message = ""; @@ -65,6 +103,11 @@ namespace OrderStacks.model.gameActions.decimals } } + /** + * Liste de carte du joueur actif + * + * Fonction permettant de vérifier si c'est la fin du jeu + */ override public void TestEndGame(List currentHand) { if (((TerminerSonTourDecimal)gameActions[2]).Test(currentHand)) diff --git a/OrderStacks/model/gameActions/decimals/JouerUneCarteDecimal.cs b/OrderStacks/model/gameActions/decimals/JouerUneCarteDecimal.cs index 2d4a9cb..25afe14 100644 --- a/OrderStacks/model/gameActions/decimals/JouerUneCarteDecimal.cs +++ b/OrderStacks/model/gameActions/decimals/JouerUneCarteDecimal.cs @@ -8,10 +8,26 @@ namespace OrderStacks.model.gameActions.decimals { public class JouerUneCarteDecimal : JouerUneCarte { + /** + * Piles de jeu + * + * Constructeur + */ public JouerUneCarteDecimal(Piles ListOrderedStacks) : base(ListOrderedStacks) { } + /** + * Joueur actif + * Liste de carte du joeuur actif + * Liste des cartes jouées durant le tour du joueur actif + * Pile séléctionnée + * Valeur de la carte en train d'être joué + * + * Fonction permettant de tenter de jouer une carte + * + * Booléen de carte joué + */ override public bool play(decimal valueCard, List CurrentHand, int orderedStackSelected, Player player, List CurrentCardPlayed) { foreach (Card card in CurrentHand) @@ -47,6 +63,17 @@ namespace OrderStacks.model.gameActions.decimals return false; } + /** + * Joueur actif + * Liste des cartes jouées durant le tour du joueur actif + * Booléen d'ascendance + * Carte joué + * Pile joué + * + * Fonction permettant de tenter de jouer une carte + * + * Booléen de carte joué + */ override protected bool Rule(Card card, Stack stack, bool bottomUp, Player player, List CurrentCardPlayed) { if ((bottomUp && card.Value > stack.Peek().Value) || (!bottomUp && card.Value < stack.Peek().Value)) diff --git a/OrderStacks/model/gameActions/decimals/TerminerSonTourDecimal.cs b/OrderStacks/model/gameActions/decimals/TerminerSonTourDecimal.cs index 796956c..452f566 100644 --- a/OrderStacks/model/gameActions/decimals/TerminerSonTourDecimal.cs +++ b/OrderStacks/model/gameActions/decimals/TerminerSonTourDecimal.cs @@ -8,10 +8,23 @@ namespace OrderStacks.model.gameActions.decimals { public class TerminerSonTourDecimal : TerminerSonTour { + /** + * Piles de jeu + * + * Constructeur + */ public TerminerSonTourDecimal(Piles ListOrderedStacks) : base(ListOrderedStacks) { } + /** + * Liste de carte du joeuur actif + * Liste des cartes jouées durant le tour du joueur actif + * + * Fonction permettant de terminer son tour + * + * Booléen indiquant si le changement de joueur peut se passer + */ override public bool end(List CurrentHand, List CurrentCardPlayed) { if (CurrentHand.Count == 0 || CurrentCardPlayed.Count >= 2) @@ -26,6 +39,12 @@ namespace OrderStacks.model.gameActions.decimals } + /** + * Liste de carte du joueur actif + * Liste des cartes jouables + * + * Fonction permettant de chercher les cartes pouvants être jouées et les ajoutes à la liste des cartes jouables + */ override protected void tryToFindSoluce(List playableCard, List CurrentHand) { int findDownCard = 0; @@ -151,6 +170,11 @@ namespace OrderStacks.model.gameActions.decimals }); } + /** + * Liste des cartes jouables + * + * Fonction vérifiant que les règles de fin de jeu ne sont pas arrivé + */ override protected bool testEndGame(List playableCard) { if (playableCard.Count < 2) diff --git a/OrderStacks/model/gameActions/fraction/GameModeFraction.cs b/OrderStacks/model/gameActions/fraction/GameModeFraction.cs index 7e45170..efc3435 100644 --- a/OrderStacks/model/gameActions/fraction/GameModeFraction.cs +++ b/OrderStacks/model/gameActions/fraction/GameModeFraction.cs @@ -10,10 +10,22 @@ namespace OrderStacks.model.gameActions.fraction { public class GameModeFraction : GameMode { + /** + * Deck de carte + * Piles du jeu + * + * Constructeur + */ public GameModeFraction(Piles piles, Deck deck) : base(piles, deck) { } + /** + * Nombre de joueur + * Pseudo du/des joueur(s) + * + * Fonction permettant de charger les paramètres de jeu + */ override public void load(int nbPlayer, List players) { gameActions.Add(new PiocherClassic(Piles)); @@ -24,6 +36,12 @@ namespace OrderStacks.model.gameActions.fraction distribueCard(players); } + /** + * Liste de carte du joueur actif + * Joueur actif + * + * Fonction permettant au joueur actif de piocher une carte + */ override public void pioche(List currentHand, Player player) { Message = ""; @@ -31,6 +49,17 @@ namespace OrderStacks.model.gameActions.fraction quickSort(currentHand, 0, currentHand.Count - 1); } + /** + * Joueur actif + * Liste de carte du joeuur actif + * Liste des cartes jouées durant le tour du joueur actif + * Pile séléctionnée + * Valeur de la carte en train d'être joué + * + * Fonction permettant de tenter de jouer une carte + * + * Booléen de carte joué + */ override public bool playCard(decimal valueCard, List currentHand, int orderedStackSelected, Player player, List CurrentCardPlayed) { Message = ""; @@ -48,6 +77,15 @@ namespace OrderStacks.model.gameActions.fraction } } + /** + * Liste de carte du joueur actif + * Liste des cartes jouées durant le tour du joueur actif + * Joueur actif + * + * Fonction permettant de lancer la fin du tour et de vérifier la fin du jeu + * + * Booléen de fin de jeu + */ override public bool endTurn(List currentHand, List CurrentCardPlayed, Player player) { Message = ""; @@ -65,6 +103,11 @@ namespace OrderStacks.model.gameActions.fraction } } + /** + * Liste de carte du joueur actif + * + * Fonction permettant de vérifier si c'est la fin du jeu + */ override public void TestEndGame(List currentHand) { if (((TerminerSonTourFraction)gameActions[2]).Test(currentHand)) diff --git a/OrderStacks/model/gameActions/fraction/JouerUneCarteFraction.cs b/OrderStacks/model/gameActions/fraction/JouerUneCarteFraction.cs index 1f3825b..9acf79a 100644 --- a/OrderStacks/model/gameActions/fraction/JouerUneCarteFraction.cs +++ b/OrderStacks/model/gameActions/fraction/JouerUneCarteFraction.cs @@ -9,10 +9,26 @@ namespace OrderStacks.model.gameActions.fraction { public class JouerUneCarteFraction : JouerUneCarte { + /** + * Piles de jeu + * + * Constructeur + */ public JouerUneCarteFraction(Piles ListOrderedStacks) : base(ListOrderedStacks) { } + /** + * Joueur actif + * Liste de carte du joeuur actif + * Liste des cartes jouées durant le tour du joueur actif + * Pile séléctionnée + * Valeur de la carte en train d'être joué + * + * Fonction permettant de tenter de jouer une carte + * + * Booléen de carte joué + */ override public bool play(decimal valueCard, List CurrentHand, int orderedStackSelected, Player player, List CurrentCardPlayed) { foreach (Card card in CurrentHand) @@ -48,6 +64,17 @@ namespace OrderStacks.model.gameActions.fraction return false; } + /** + * Joueur actif + * Liste des cartes jouées durant le tour du joueur actif + * Booléen d'ascendance + * Carte joué + * Pile joué + * + * Fonction permettant de tenter de jouer une carte + * + * Booléen de carte joué + */ override protected bool Rule(Card card, Stack stack, bool bottomUp, Player player, List CurrentCardPlayed) { if ((bottomUp && card.Value > stack.Peek().Value) || (!bottomUp && card.Value < stack.Peek().Value)) diff --git a/OrderStacks/model/gameActions/fraction/TerminerSonTourFraction.cs b/OrderStacks/model/gameActions/fraction/TerminerSonTourFraction.cs index 3dda59e..796ea32 100644 --- a/OrderStacks/model/gameActions/fraction/TerminerSonTourFraction.cs +++ b/OrderStacks/model/gameActions/fraction/TerminerSonTourFraction.cs @@ -9,10 +9,23 @@ namespace OrderStacks.model.gameActions.fraction { public class TerminerSonTourFraction : TerminerSonTour { + /** + * Piles de jeu + * + * Constructeur + */ public TerminerSonTourFraction(Piles ListOrderedStacks) : base(ListOrderedStacks) { } + /** + * Liste de carte du joeuur actif + * Liste des cartes jouées durant le tour du joueur actif + * + * Fonction permettant de terminer son tour + * + * Booléen indiquant si le changement de joueur peut se passer + */ public override bool end(List CurrentHand, List CurrentCardPlayed) { if (CurrentHand.Count == 0 || CurrentCardPlayed.Count >= 2) @@ -27,6 +40,11 @@ namespace OrderStacks.model.gameActions.fraction } } + /** + * Liste des cartes jouables + * + * Fonction vérifiant que les règles de fin de jeu ne sont pas arrivé + */ protected override bool testEndGame(List playableCard) { if (playableCard.Count < 2) @@ -36,6 +54,12 @@ namespace OrderStacks.model.gameActions.fraction return true; } + /** + * Liste de carte du joueur actif + * Liste des cartes jouables + * + * Fonction permettant de chercher les cartes pouvants être jouées et les ajoutes à la liste des cartes jouables + */ protected override void tryToFindSoluce(List playableCard, List CurrentHand) { int findMultipleCard = 0; diff --git a/OrderStacks/view/MainPage.xaml.cs b/OrderStacks/view/MainPage.xaml.cs index 4f2bb57..b0c9fa7 100644 --- a/OrderStacks/view/MainPage.xaml.cs +++ b/OrderStacks/view/MainPage.xaml.cs @@ -182,7 +182,6 @@ namespace OrderStacks.view break; case TouchActionType.Released: - break; case TouchActionType.Cancelled: if (textDictionary.ContainsKey(args.Id))