diff --git a/OrderStacks/Resx/AppResources.Designer.cs b/OrderStacks/Resx/AppResources.Designer.cs index 3a20ece..39f0a72 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,98 +47,60 @@ 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); @@ -176,108 +125,72 @@ namespace OrderStacks.Resx { } } - /// - /// 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); @@ -302,36 +215,24 @@ namespace OrderStacks.Resx { } } - /// - /// 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); @@ -401,83 +302,54 @@ namespace OrderStacks.Resx { } } - /// - /// 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); @@ -502,108 +374,72 @@ namespace OrderStacks.Resx { } } - /// - /// 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/Resx/AppResources.Designer.cs.orig b/OrderStacks/Resx/AppResources.Designer.cs.orig new file mode 100644 index 0000000..98624ca --- /dev/null +++ b/OrderStacks/Resx/AppResources.Designer.cs.orig @@ -0,0 +1,458 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.42000 +// +// 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; + + + [System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")] + [System.Diagnostics.DebuggerNonUserCodeAttribute()] + [System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + public class AppResources { + + private static System.Resources.ResourceManager resourceMan; + + private static System.Globalization.CultureInfo resourceCulture; + + [System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal AppResources() { + } + + [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Advanced)] + public static System.Resources.ResourceManager ResourceManager { + get { + if (object.Equals(null, resourceMan)) { + System.Resources.ResourceManager temp = new System.Resources.ResourceManager("OrderStacks.Resx.AppResources", typeof(AppResources).Assembly); + resourceMan = temp; + } + return resourceMan; + } + } + + [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Advanced)] + public static System.Globalization.CultureInfo Culture { + get { + return resourceCulture; + } + set { + resourceCulture = value; + } + } + + public static string StrAbout { + get { + return ResourceManager.GetString("StrAbout", resourceCulture); + } + } + + public static string StrAcendingStack { + get { + return ResourceManager.GetString("StrAcendingStack", resourceCulture); + } + } + + public static string StrBtnPlay { + get { + return ResourceManager.GetString("StrBtnPlay", resourceCulture); + } + } + + public static string StrCantGetStack { + get { + return ResourceManager.GetString("StrCantGetStack", resourceCulture); + } + } + + public static string StrCardDoesntExist { + get { + return ResourceManager.GetString("StrCardDoesntExist", resourceCulture); + } + } + + public static string StrCardPlayedLessThanTwo { + get { + return ResourceManager.GetString("StrCardPlayedLessThanTwo", resourceCulture); + } + } + + public static string StrCloseWind { + get { + return ResourceManager.GetString("StrCloseWind", resourceCulture); + } + } + + public static string StrDownStack { + get { + return ResourceManager.GetString("StrDownStack", resourceCulture); + } + } + + public static string StrEndTurn { + get { + return ResourceManager.GetString("StrEndTurn", resourceCulture); + } + } + + public static string StrEnterPseudo { + get { + return ResourceManager.GetString("StrEnterPseudo", resourceCulture); + } + } + +<<<<<<< HEAD + /// + /// Recherche une chaîne localisée semblable à Concernant les fractions :. + /// + public static string StrFracValue { + get { + return ResourceManager.GetString("StrFracValue", resourceCulture); + } + } + + /// + /// Recherche une chaîne localisée semblable à A propos. + /// +======= +>>>>>>> 442c8aff0057af0fc6fe27dabbd922cfbbd9082c + public static string StrInfo { + get { + return ResourceManager.GetString("StrInfo", resourceCulture); + } + } + + public static string String3 { + get { + return ResourceManager.GetString("String3", resourceCulture); + } + } + + public static string String4 { + get { + return ResourceManager.GetString("String4", resourceCulture); + } + } + + public static string StrLocalGame { + get { + return ResourceManager.GetString("StrLocalGame", resourceCulture); + } + } + + public static string StrLose { + get { + return ResourceManager.GetString("StrLose", resourceCulture); + } + } + + public static string StrMultiplayer { + get { + return ResourceManager.GetString("StrMultiplayer", resourceCulture); + } + } + + public static string StrNbCards { + get { + return ResourceManager.GetString("StrNbCards", resourceCulture); + } + } + + public static string StrNbPlayers { + get { + return ResourceManager.GetString("StrNbPlayers", resourceCulture); + } + } + + public static string StrNbStacksInGame { + get { + return ResourceManager.GetString("StrNbStacksInGame", resourceCulture); + } + } + + public static string StrNext { + get { + return ResourceManager.GetString("StrNext", resourceCulture); + } + } + + public static string StrPlayerSelections { + get { + return ResourceManager.GetString("StrPlayerSelections", resourceCulture); + } + } + + public static string StrPseudoGM { + get { + return ResourceManager.GetString("StrPseudoGM", resourceCulture); + } + } + + public static string StrRetry { + get { + return ResourceManager.GetString("StrRetry", resourceCulture); + } + } + +<<<<<<< HEAD + /// + /// Recherche une chaîne localisée semblable à Regles particulères :. + /// + public static string StrSpecRules { + get { + return ResourceManager.GetString("StrSpecRules", resourceCulture); + } + } + + /// + /// Recherche une chaîne localisée semblable à - L'objectif est de battre la machine seul et/ou en coopération.. + /// +======= +>>>>>>> 442c8aff0057af0fc6fe27dabbd922cfbbd9082c + public static string StrTiret1 { + get { + return ResourceManager.GetString("StrTiret1", resourceCulture); + } + } + + public static string StrTiret10 { + get { + return ResourceManager.GetString("StrTiret10", resourceCulture); + } + } + + public static string StrTiret11 { + get { + return ResourceManager.GetString("StrTiret11", resourceCulture); + } + } + + public static string StrTiret12 { + get { + return ResourceManager.GetString("StrTiret12", resourceCulture); + } + } + + public static string StrTiret13 { + get { + return ResourceManager.GetString("StrTiret13", resourceCulture); + } + } + + /// + /// Recherche une chaîne localisée semblable à Sur les fractions décimales, il est possible de descendre sur une pile ascendant de 0,1 0,01 ou 0,001 si le numérateur de la carte que l'on souhaite jouer et plus petit de 0.1 0.01 ou 0.001 par rapport à celui de la carte posée sur la pile. Il est possible de monter sur une pile descendante de 0,1 0,01 ou 0,001 si le numérateur de la carte que l'on souhaite jouer et plus grand de 0.1 0.01 ou 0.001 par rapport à celui de la carte posée sur la pile. [le reste de la chaîne a été tronqué]";. + /// + public static string StrTiret14 { + get { + return ResourceManager.GetString("StrTiret14", resourceCulture); + } + } + + /// + /// Recherche une chaîne localisée semblable à Il est possible de descendre de 0.1 sur une pile ascendante uniquement si la carte que l'on souhaite jouer à un dixième de moins que la carte posée sur la pile et que les deux cartes possèdent le même nombre de chiffres après la virgule. Cette spécificité s'applique également avec les valeurs possédant 2 ou 3 chiffres après la virgule.. + /// + public static string StrTiret15 { + get { + return ResourceManager.GetString("StrTiret15", resourceCulture); + } + } + + /// + /// Recherche une chaîne localisée semblable à Il est possible de monter de 0.1 sur une pile ascendante uniquement si la carte que l'on souhaite jouer à un dixième de plus que la carte posée sur la pile et que les deux cartes possèdent le même nombre de chiffres après la virgule. Cette spécificité s'applique également avec les valeurs possédant 2 ou 3 chiffres après la virgule.. + /// + public static string StrTiret16 { + get { + return ResourceManager.GetString("StrTiret16", resourceCulture); + } + } + + /// + /// Recherche une chaîne localisée semblable à Concernant les fractions : Il est possible de descendre sur une pile ascendante si le numérateur de la carte que l'on souhaite jouer est un multiple plus petit que celui du numérateur de la carte posée sur la pile. Il est également possible de descendre sur une pile ascendante si le dénominateur de la carte que l'on souhaite jouer est un multiple plus petit que le dénominateur de la carte posée sur la pile. . + /// + public static string StrTiret17 { + get { + return ResourceManager.GetString("StrTiret17", resourceCulture); + } + } + + /// + /// Recherche une chaîne localisée semblable à Il est possible de monter sur une pile decendante si le numérateur de la carte que l'on souhaite jouer est un multiple plus grand que celui du numérateur de la carte posée sur la pile. Il est également possible de monter sur une pile descendante si le dénominateur de la carte que l'on souhaite jouer est un multiple plus grand que le dénominateur de la carte posée sur la pile.. + /// + public static string StrTiret18 { + get { + return ResourceManager.GetString("StrTiret18", resourceCulture); + } + } + + /// + /// Recherche une chaîne localisée semblable à Sur les valeurs décimales, il est possible de descendre sur une pile ascendant de 0,1 si la carte que l'on souhaite jouer ainsi que la carte posée sur la pile possède qu'un chiffre après la virgule. Il en va de même pour les cartes avec deux et trois chiffres après la virgule.. + /// + public static string StrTiret19 { + get { + return ResourceManager.GetString("StrTiret19", 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); + } + } + + public static string StrTiret3 { + get { + return ResourceManager.GetString("StrTiret3", resourceCulture); + } + } + + public static string StrTiret4 { + get { + return ResourceManager.GetString("StrTiret4", resourceCulture); + } + } + + public static string StrTiret5 { + get { + return ResourceManager.GetString("StrTiret5", resourceCulture); + } + } + + public static string StrTiret6 { + get { + return ResourceManager.GetString("StrTiret6", resourceCulture); + } + } + + public static string StrTiret7 { + get { + return ResourceManager.GetString("StrTiret7", resourceCulture); + } + } + + public static string StrTiret8 { + get { + return ResourceManager.GetString("StrTiret8", resourceCulture); + } + } + + public static string StrTiret9 { + get { + return ResourceManager.GetString("StrTiret9", resourceCulture); + } + } + + public static string StrTitle { + get { + return ResourceManager.GetString("StrTitle", resourceCulture); + } + } + + public static string StrTitleRules { + get { + return ResourceManager.GetString("StrTitleRules", resourceCulture); + } + } + +<<<<<<< HEAD + /// + /// Recherche une chaîne localisée semblable à Concernant les fractions décimales et les valeurs décimales :. + /// + public static string StrValueFracDec { + get { + return ResourceManager.GetString("StrValueFracDec", resourceCulture); + } + } + + /// + /// Recherche une chaîne localisée semblable à Valeurs :. + /// +======= +>>>>>>> 442c8aff0057af0fc6fe27dabbd922cfbbd9082c + public static string StrValueType { + get { + return ResourceManager.GetString("StrValueType", resourceCulture); + } + } + + public static string StrWin { + get { + return ResourceManager.GetString("StrWin", resourceCulture); + } + } + + public static string StrWrongStack { + get { + return ResourceManager.GetString("StrWrongStack", resourceCulture); + } + } + + public static string TypeValuefractionated { + get { + return ResourceManager.GetString("TypeValuefractionated", resourceCulture); + } + } + + public static string TypeValueHundredthFract { + get { + return ResourceManager.GetString("TypeValueHundredthFract", resourceCulture); + } + } + + public static string TypeValueRelative { + get { + return ResourceManager.GetString("TypeValueRelative", resourceCulture); + } + } + + public static string TypeValueTenthFract { + get { + return ResourceManager.GetString("TypeValueTenthFract", resourceCulture); + } + } + + public static string TypeValueThousandthFract { + get { + return ResourceManager.GetString("TypeValueThousandthFract", resourceCulture); + } + } + + public static string TypeValueWhole { + get { + return ResourceManager.GetString("TypeValueWhole", resourceCulture); + } + } + + 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); + } + } + + public static string WrongPseudo { + get { + return ResourceManager.GetString("WrongPseudo", resourceCulture); + } + } + } +} diff --git a/OrderStacks/model/Card/Card.cs b/OrderStacks/model/Card/Card.cs index 05a0af2..4a0cda2 100644 --- a/OrderStacks/model/Card/Card.cs +++ b/OrderStacks/model/Card/Card.cs @@ -1,12 +1,16 @@ -using System; -using System.ComponentModel; - -namespace OrderStacks.model.card +namespace OrderStacks.model.card { public abstract class Card { + /** + * Valeur de la carte + */ public decimal Value { get; set; } + /** + * Valeur de la carte + * Constructeur + */ public Card(decimal value) { Value = value; @@ -17,7 +21,14 @@ namespace OrderStacks.model.card return Value.ToString(); } + /** + * Fonction permettant de retourner le nom du type de carte + */ public abstract string getName(); + + /** + * Fonction permettant d'activer les effets rapides + */ public abstract bool rapidEffect(); } diff --git a/OrderStacks/model/Card/cardType/ClassicCard.cs b/OrderStacks/model/Card/cardType/ClassicCard.cs index f8c5374..70cc645 100644 --- a/OrderStacks/model/Card/cardType/ClassicCard.cs +++ b/OrderStacks/model/Card/cardType/ClassicCard.cs @@ -2,9 +2,15 @@ { public class ClassicCard : Card { - + /** + * Type de carte + */ public static readonly string CARD_CLASSIC = "ClassicCard"; + /** + * Valeur de la carte + * Constructeur + */ public ClassicCard(decimal value) : base(value) { diff --git a/OrderStacks/model/Card/cardType/FractionCard.cs b/OrderStacks/model/Card/cardType/FractionCard.cs index 4fa2fb1..39a0740 100644 --- a/OrderStacks/model/Card/cardType/FractionCard.cs +++ b/OrderStacks/model/Card/cardType/FractionCard.cs @@ -5,9 +5,20 @@ namespace OrderStacks.model.card.cardType public class FractionCard : Card { + /** + * Type de carte + */ public static readonly string CARD_FRACTION = "FractionCard"; + + /** + * Fraction que représente la carte + */ public Fraction Fraction { get; set; } + /** + * Fraction qui est représenté sur la carte + * Constructeur + */ public FractionCard(Fraction value) : base(value.Result()) { Fraction = value; @@ -18,7 +29,7 @@ namespace OrderStacks.model.card.cardType return false; } - override public String getName() + override public string getName() { return CARD_FRACTION; } diff --git a/OrderStacks/model/Card/rapidCard/EndGameCard.cs b/OrderStacks/model/Card/rapidCard/EndGameCard.cs index 6fa6409..838b254 100644 --- a/OrderStacks/model/Card/rapidCard/EndGameCard.cs +++ b/OrderStacks/model/Card/rapidCard/EndGameCard.cs @@ -4,9 +4,15 @@ namespace OrderStacks.model.card.rapidCard { public class EndGameCard : RapidCard { - + /** + * Type de carte + */ public static readonly string CARD_ENDGAME = "EndGameCard"; + /** + * Valeur de la carte + * Constructeur + */ public EndGameCard(int value) :base(value) { diff --git a/OrderStacks/model/Card/rapidCard/RapidCard.cs b/OrderStacks/model/Card/rapidCard/RapidCard.cs index 48feea6..aa412ad 100644 --- a/OrderStacks/model/Card/rapidCard/RapidCard.cs +++ b/OrderStacks/model/Card/rapidCard/RapidCard.cs @@ -4,6 +4,10 @@ namespace OrderStacks.model.card.rapidCard { public abstract class RapidCard : Card { + /** + * Valeur de la carte + * Constructeur + */ public RapidCard(int value) : base(value) { } diff --git a/OrderStacks/model/Card/rapidCard/ThreeCard.cs b/OrderStacks/model/Card/rapidCard/ThreeCard.cs index 1720609..b9cec86 100644 --- a/OrderStacks/model/Card/rapidCard/ThreeCard.cs +++ b/OrderStacks/model/Card/rapidCard/ThreeCard.cs @@ -4,9 +4,15 @@ namespace OrderStacks.model.card.rapidCard { public class ThreeCard : RapidCard { - + /** + * Type de carte + */ public static readonly string CARD_THREE = "ThreeCard"; + /** + * Valeur de la carte + * Constructeur + */ public ThreeCard(int value) :base(value) { diff --git a/OrderStacks/model/Fraction.cs b/OrderStacks/model/Fraction.cs index 1c398b5..ee5c6bb 100644 --- a/OrderStacks/model/Fraction.cs +++ b/OrderStacks/model/Fraction.cs @@ -8,6 +8,13 @@ namespace OrderStacks.model public int Denominateur; public int SizeMax; + /** + * Numérateur de la fraction + * Dénominateur de la fraction + * Nombre maximal de chiffre présent dans la fraction + * + * Constructeur + */ public Fraction(int numerateur, int denominateur, int sizeMax) { Numerateur = numerateur; @@ -15,6 +22,11 @@ namespace OrderStacks.model SizeMax = sizeMax; } + /** + * Fraction testé + * + * Fonction de permettant de regarder si deux fractions sont multiple sans posséder le même chiffre ou un numérateur/dénominateur égale à 1 + */ public bool isMultiple(Fraction fraction) { bool numIsZero = false; @@ -81,6 +93,13 @@ namespace OrderStacks.model return false; } + /** + * Fraction testé + * + * Fonction permettant de savoir si deux fractions paossèdent des diviseurs commums + * + * Booléen de possession de diviseur commun + */ public bool testDiviseurCommun(Fraction fraction) { if (PGCD(Numerateur, fraction.Numerateur) == Numerateur || PGCD(Denominateur, fraction.Denominateur) == Denominateur) @@ -90,6 +109,13 @@ namespace OrderStacks.model return false; } + /** + * Numérateur + * + * Fonction permettant de retourner le PGCD (Plus Grand Commun Diviseur) de deux fractions + * + * Plus Grand Commun Diviseur + */ private int PGCD(int a, int b) { int temp = a % b; @@ -98,6 +124,11 @@ namespace OrderStacks.model return PGCD(b, temp); } + /** + * Fonction permettant d'obtenir la valeur décimale de la fraction + * + * Valeur décimale de la fraction + */ public decimal Result() { decimal result = (decimal)Numerateur / (decimal)Denominateur; diff --git a/OrderStacks/model/Parametreur.cs b/OrderStacks/model/Parametreur.cs index 3392f5b..ee6a82d 100644 --- a/OrderStacks/model/Parametreur.cs +++ b/OrderStacks/model/Parametreur.cs @@ -10,17 +10,30 @@ namespace OrderStacks.model public List players = new List(); public int NbPlayer { get; set; } + /** + * Mode de jeu utilisé + * + * Constructeur + */ public Parametreur(GameMode gameMode) { GameMode = gameMode; } + /** + * Fonction permettant de préparer le jeu + */ public void Prepare() { NbPlayer = players.Count; GameMode.load(NbPlayer, players); } + /** + *Joueur à ajouter + * + * Fonction permettant d'ajouter un joueur + */ public void AddPlayer(Player player) { if (player != null) @@ -29,6 +42,11 @@ namespace OrderStacks.model } } + /** + * Fonction permettant de retourner le nombre de cartes restantes à jouer + * + * Nombre de carte restante à jouer + */ public string getScore() { int score = GameMode.getScore(); diff --git a/OrderStacks/model/Player.cs b/OrderStacks/model/Player.cs index 944e371..8cd0d23 100644 --- a/OrderStacks/model/Player.cs +++ b/OrderStacks/model/Player.cs @@ -12,12 +12,21 @@ namespace OrderStacks.model private List cardList = new List(); public event EventHandler HandCardChanged; - + /** + *Pseudo du joueur + * + * Constructeur + */ public Player(string pseudo) { Pseudo = pseudo; } + /** + * Carte pioché + * + * Fonction permettant d'ajouter une carte pioché à la main de l'utilisateur + */ public void pioche(Card card) { cardList.Add(card); @@ -25,6 +34,11 @@ namespace OrderStacks.model OnCardDrawable(new HandCardChangedEventArgs(card, position)); } + /** + * Carte joué + * + * Fonction permettant de jouer une carte de la main du joueur + */ public void joue(Card card) { int position = cardList.IndexOf(card); @@ -37,11 +51,21 @@ namespace OrderStacks.model // return cardList.AsReadOnly(); //} + /** + * Fonction permettant de retourner la liste de carte du joueur + * + * Liste de cartes + */ public List getCardList() { return cardList; } + /** + * Argument de l'événement + * + * Evénement permettant de notifier que la main a changé + */ protected internal void OnCardDrawable(HandCardChangedEventArgs args) { HandCardChanged?.Invoke(this, args); diff --git a/OrderStacks/model/deck/CentaineDeck.cs b/OrderStacks/model/deck/CentaineDeck.cs index bad555e..a8bd3a2 100644 --- a/OrderStacks/model/deck/CentaineDeck.cs +++ b/OrderStacks/model/deck/CentaineDeck.cs @@ -5,6 +5,12 @@ namespace OrderStacks.model.deck { public class CentaineDeck : Deck { + /** + * Valeur minimale du deck + * Valeur maximale du deck + * Nombre de carte dans le deck + * Constructeur + */ public CentaineDeck(int nbCard, decimal borneMin, decimal borneMax) : base(nbCard) { Random random = new Random(); @@ -13,7 +19,7 @@ namespace OrderStacks.model.deck while (deck.Count < nbCard && deck.Count < (borneMaxRandom - borneMinRandom)) { int value = random.Next(borneMinRandom, borneMaxRandom); - InsertionDichotomique(deck, 0, deck.Count-1, new FractionCard(new Fraction(value, 100, 3))); + InsertionDichotomique(0, deck.Count-1, new FractionCard(new Fraction(value, 100, 3))); } } } diff --git a/OrderStacks/model/deck/ClassicDeck.cs b/OrderStacks/model/deck/ClassicDeck.cs index 793ae76..cdbd321 100644 --- a/OrderStacks/model/deck/ClassicDeck.cs +++ b/OrderStacks/model/deck/ClassicDeck.cs @@ -5,13 +5,19 @@ namespace OrderStacks.model.deck { public class ClassicDeck : Deck { + /** + * Valeur minimale du deck + * Valeur maximale du deck + * Nombre de carte dans le deck + * Constructeur + */ public ClassicDeck(int nbCard, int borneMin, int borneMax) : base(nbCard) { Random random = new Random(); while (deck.Count < nbCard && deck.Count < (borneMax - borneMin)) { int value = random.Next(borneMin, borneMax); - InsertionDichotomique(deck, 0, deck.Count-1, new ClassicCard(value)); + InsertionDichotomique(0, deck.Count-1, new ClassicCard(value)); } } } diff --git a/OrderStacks/model/deck/Decimal1.cs b/OrderStacks/model/deck/Decimal1.cs index 5f2174f..6374043 100644 --- a/OrderStacks/model/deck/Decimal1.cs +++ b/OrderStacks/model/deck/Decimal1.cs @@ -5,13 +5,19 @@ namespace OrderStacks.model.deck { public class Decimal1Deck : Deck { + /** + * Valeur minimale du deck + * Valeur maximale du deck + * Nombre de carte dans le deck + * Constructeur + */ public Decimal1Deck(int nbCard, int borneMin, int borneMax) : base(nbCard) { Random random = new Random(); while (deck.Count < nbCard && deck.Count < (borneMax - borneMin)) { decimal value = random.Next(borneMin, borneMax) * 0.1m; - InsertionDichotomique(deck, 0, deck.Count - 1, new ClassicCard(value)); + InsertionDichotomique(0, deck.Count - 1, new ClassicCard(value)); } } } diff --git a/OrderStacks/model/deck/Decimal2.cs b/OrderStacks/model/deck/Decimal2.cs index 1fa2db0..a5123a3 100644 --- a/OrderStacks/model/deck/Decimal2.cs +++ b/OrderStacks/model/deck/Decimal2.cs @@ -5,13 +5,19 @@ namespace OrderStacks.model.deck { public class Decimal2Deck : Deck { + /** + * Valeur minimale du deck + * Valeur maximale du deck + * Nombre de carte dans le deck + * Constructeur + */ public Decimal2Deck(int nbCard, int borneMin, int borneMax) : base(nbCard) { Random random = new Random(); while (deck.Count < nbCard && deck.Count < (borneMax - borneMin)) { decimal value = random.Next(borneMin, borneMax) * 0.01m; - InsertionDichotomique(deck, 0, deck.Count - 1, new ClassicCard(value)); + InsertionDichotomique(0, deck.Count - 1, new ClassicCard(value)); } } } diff --git a/OrderStacks/model/deck/Deck.cs b/OrderStacks/model/deck/Deck.cs index c3aa45b..2cbe944 100644 --- a/OrderStacks/model/deck/Deck.cs +++ b/OrderStacks/model/deck/Deck.cs @@ -6,31 +6,53 @@ namespace OrderStacks.model.deck { public abstract class Deck { - protected List deck = new List(); protected int nbCard; + /** + * Nombre de carte dans le deck + * Constructeur + */ protected Deck(int nbCard) { this.nbCard = nbCard; } + /** + * Fonction retournant le nombre de carte dans le deck + */ public int size() { return deck.Count; } + /** + * Index supprimé + * Fonction permettant de retirer un index du deck + */ public void removeAt(int index) { deck.RemoveAt(index); } + /** + * Index de la carte chercher + * Fonction retournant la carte contenu dans l'index + * Carte à la position chercher + */ public Card getCard(int index) { return deck[index]; } - protected void InsertionDichotomique(List deck, int start, int end, Card card) + /** + * Carte que l'on souhaite insérer + * Début de la plage de recherche + * Fin de la plage de recherche + * Fonction permet d'insérer dichotomiquement une carte + * N'insére pas de carte en double + */ + protected void InsertionDichotomique(int start, int end, Card card) { if (deck.Count == 0) { @@ -75,12 +97,12 @@ namespace OrderStacks.model.deck { if (comparateur < 0) { - InsertionDichotomique(deck, mediane, end, card); + InsertionDichotomique(mediane, end, card); return; } else { - InsertionDichotomique(deck, start, mediane, card); + InsertionDichotomique(start, mediane, card); return; } } diff --git a/OrderStacks/model/deck/DizaineDeck.cs b/OrderStacks/model/deck/DizaineDeck.cs index 9afeb6e..69f8b3f 100644 --- a/OrderStacks/model/deck/DizaineDeck.cs +++ b/OrderStacks/model/deck/DizaineDeck.cs @@ -5,6 +5,12 @@ namespace OrderStacks.model.deck { public class DizaineDeck : Deck { + /** + * Valeur minimale du deck + * Valeur maximale du deck + * Nombre de carte dans le deck + * Constructeur + */ public DizaineDeck(int nbCard, decimal borneMin, decimal borneMax) : base(nbCard) { Random random = new Random(); @@ -13,7 +19,7 @@ namespace OrderStacks.model.deck while (deck.Count < nbCard && deck.Count < (borneMaxRandom - borneMinRandom)) { int value = random.Next(borneMinRandom, borneMaxRandom); - InsertionDichotomique(deck, 0, deck.Count-1, new FractionCard(new Fraction(value, 10, 2))); + InsertionDichotomique(0, deck.Count-1, new FractionCard(new Fraction(value, 10, 2))); } } } diff --git a/OrderStacks/model/deck/FractionDeck.cs b/OrderStacks/model/deck/FractionDeck.cs index 62aacdb..0e9f693 100644 --- a/OrderStacks/model/deck/FractionDeck.cs +++ b/OrderStacks/model/deck/FractionDeck.cs @@ -7,7 +7,10 @@ namespace OrderStacks.model.deck { /** - * Fonction permettant de créer un jeu de carte pour jouer avec les fractions + * Valeur minimale du deck + * Valeur maximale du deck + * Nombre de carte dans le deck + * Constructeur */ public FractionDeck(int nbCard, decimal borneMin, decimal borneMax) : base(nbCard) { @@ -19,7 +22,7 @@ namespace OrderStacks.model.deck { if (deck.Count < nbCard) { - InsertionDichotomique(deck, 0, deck.Count - 1, new FractionCard(new Fraction(i, j, 2))); + InsertionDichotomique(0, deck.Count - 1, new FractionCard(new Fraction(i, j, 2))); } else { @@ -43,7 +46,7 @@ namespace OrderStacks.model.deck denominateur /= pgcd; pgcd = PGCD(numerateur, denominateur); } - InsertionDichotomique(deck, 0, deck.Count - 1, new FractionCard(new Fraction(numerateur, denominateur, 2))); + InsertionDichotomique(0, deck.Count - 1, new FractionCard(new Fraction(numerateur, denominateur, 2))); } } } diff --git a/OrderStacks/model/deck/MilliemeDeck.cs b/OrderStacks/model/deck/MilliemeDeck.cs index 24e18b0..c22bc92 100644 --- a/OrderStacks/model/deck/MilliemeDeck.cs +++ b/OrderStacks/model/deck/MilliemeDeck.cs @@ -5,6 +5,12 @@ namespace OrderStacks.model.deck { public class MilliemeDeck : Deck { + /** + * Valeur minimale du deck + * Valeur maximale du deck + * Nombre de carte dans le deck + * Constructeur + */ public MilliemeDeck(int nbCard, decimal borneMin, decimal borneMax) : base(nbCard) { Random random = new Random(); @@ -13,7 +19,7 @@ namespace OrderStacks.model.deck while (deck.Count < nbCard && deck.Count < (borneMaxRandom - borneMinRandom)) { int value = random.Next(borneMinRandom, borneMaxRandom); - InsertionDichotomique(deck, 0, deck.Count-1, new FractionCard(new Fraction(value, 1000, 4))); + InsertionDichotomique(0, deck.Count-1, new FractionCard(new Fraction(value, 1000, 4))); } } } diff --git a/OrderStacks/model/deck/RelativeDeck.cs b/OrderStacks/model/deck/RelativeDeck.cs index 9b6256d..35fdd1e 100644 --- a/OrderStacks/model/deck/RelativeDeck.cs +++ b/OrderStacks/model/deck/RelativeDeck.cs @@ -5,13 +5,19 @@ namespace OrderStacks.model.deck { public class RelativeDeck : Deck { + /** + * Valeur minimale du deck + * Valeur maximale du deck + * Nombre de carte dans le deck + * Constructeur + */ public RelativeDeck(int nbCard, int borneMin, int borneMax) : base(nbCard) { Random random = new Random(); while (deck.Count < nbCard && deck.Count < (borneMax - borneMin)) { int value = random.Next(borneMin, borneMax); - InsertionDichotomique(deck, 0, deck.Count-1, new ClassicCard(value)); + InsertionDichotomique(0, deck.Count-1, new ClassicCard(value)); } } } diff --git a/OrderStacks/model/event/HandCardChangeEventArgs.cs b/OrderStacks/model/event/HandCardChangeEventArgs.cs index 36c6d76..1d64b8a 100644 --- a/OrderStacks/model/event/HandCardChangeEventArgs.cs +++ b/OrderStacks/model/event/HandCardChangeEventArgs.cs @@ -9,6 +9,11 @@ namespace OrderStacks.model.@event public Card NewCard { get; set; } public int Position { get; set; } + /** + * Nouvelle carte ajouté dans la main + * Position de la carte dans la main + * Constructeur + */ public HandCardChangedEventArgs(Card newCard, int position) { NewCard = newCard; diff --git a/OrderStacks/model/event/PlayerChangedEventArgs.cs b/OrderStacks/model/event/PlayerChangedEventArgs.cs index 2fa39ac..bb68cdc 100644 --- a/OrderStacks/model/event/PlayerChangedEventArgs.cs +++ b/OrderStacks/model/event/PlayerChangedEventArgs.cs @@ -7,9 +7,14 @@ namespace OrderStacks.model.@event public class PlayerChangedEventArgs : EventArgs { - public String Pseudo; + public string Pseudo; public List NewCurrentHand; + /** + * Nouvelle liste de carte active + * Pseudo du nouvelle utilisateur actif + * Constructeur + */ public PlayerChangedEventArgs(List newCurrentHand, string pseudo) { NewCurrentHand = newCurrentHand; diff --git a/OrderStacks/model/event/TopRangeChangedEventArgs.cs b/OrderStacks/model/event/TopRangeChangedEventArgs.cs index 7e21359..49e0e49 100644 --- a/OrderStacks/model/event/TopRangeChangedEventArgs.cs +++ b/OrderStacks/model/event/TopRangeChangedEventArgs.cs @@ -10,7 +10,13 @@ namespace OrderStacks.model.@event public Card OldTopRangeCard { get; set; } public int NumStackChanged { get; set; } - public TopRangeChangedEventArgs(Card newTopRangeCard, Card oldTopRangeCard, int numStackChanged) + /** + * Index de la pile changé + * Nouvelle carte en haut de la pile + * Ancienne carte en haut de la pile + * Constructeur + */ + public TopRangeChangedEventArgs(int numStackChanged, Card newTopRangeCard, Card oldTopRangeCard) { NewTopRangeCard = newTopRangeCard; OldTopRangeCard = oldTopRangeCard; diff --git a/OrderStacks/model/gameActions/abstractRules/GameAction.cs b/OrderStacks/model/gameActions/abstractRules/GameAction.cs index c05a1bb..4ac91bf 100644 --- a/OrderStacks/model/gameActions/abstractRules/GameAction.cs +++ b/OrderStacks/model/gameActions/abstractRules/GameAction.cs @@ -8,6 +8,11 @@ namespace OrderStacks.model.gameActions.abstractRules protected Piles ListOrderedStacks { get; set; } public string ErrorMessage { get; set; } = ""; + /** + * Piles de jeu + * + * Constructeur + */ protected GameAction(Piles listOrderedStacks) { ListOrderedStacks = listOrderedStacks; diff --git a/OrderStacks/model/gameActions/abstractRules/GameMode.cs b/OrderStacks/model/gameActions/abstractRules/GameMode.cs index 8384623..48b3c4a 100644 --- a/OrderStacks/model/gameActions/abstractRules/GameMode.cs +++ b/OrderStacks/model/gameActions/abstractRules/GameMode.cs @@ -33,7 +33,12 @@ namespace OrderStacks.model.gameActions.abstractRules #endregion - + /** + * Deck de carte + * Piles du jeu + * + * Constructeur + */ protected GameMode(Piles piles, Deck deck) { gameActions = new List(); @@ -41,6 +46,12 @@ namespace OrderStacks.model.gameActions.abstractRules this.deck = deck; } + /** + * Nombre de joueur + * Pseudo du/des joueur(s) + * + * Fonction permettant de charger les paramètres de jeu + */ public abstract void load(int nbPlayer, List players); protected void defineNbMaxCard(int nbPlayer) @@ -62,6 +73,13 @@ namespace OrderStacks.model.gameActions.abstractRules } } + /** + * Liste de carte + * Index de départ + * Index de fin + * + * Fonction de tri + */ protected void quickSort(List ar, int start, int end) { if (start < end) @@ -89,6 +107,11 @@ namespace OrderStacks.model.gameActions.abstractRules } } + /** + * Liste de joueur + * + * Fonction permettant de distribuer les cartes en début de partie + */ protected void distribueCard(List players) { players.ForEach(player => @@ -104,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/model/manager/GameManager.cs b/OrderStacks/model/manager/GameManager.cs index f595a93..1d24e1b 100644 --- a/OrderStacks/model/manager/GameManager.cs +++ b/OrderStacks/model/manager/GameManager.cs @@ -11,8 +11,6 @@ namespace OrderStacks.model.manager public abstract class GameManager: INotifyPropertyChanged { - /* 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 parametreur; protected List CurrentCardPlayed = new List(); public string EndMessage { get; set; } = ""; @@ -34,14 +32,29 @@ namespace OrderStacks.model.manager public event EventHandler EndGame; public event EventHandler PlayerChanged; public event PropertyChangedEventHandler PropertyChanged; + /** + * Nom de la propriété qui change + * Evénement permettant de notifier qu'une propriété a changé + */ public virtual void OnPropertyChanged(string info) { PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(info)); } + /** + * Argument(s) de l'événement + * Source de l'événement + * Evenement permettant de notifier la fin du jeu + */ public void OnEndGame(object source, EventArgs args) { EndGame?.Invoke(source, args); } + + /** + * Argument(s) de l'événement + * Source de l'événement + * Evenement permettant de changer de joueur actif + */ protected internal void OnPlayerChanged(object source, PlayerChangedEventArgs args) { currentIndexPlayer += 1; @@ -77,7 +90,10 @@ namespace OrderStacks.model.manager #endregion - + /** + * Parametreur de la partie + * Constructeur + */ protected GameManager(Parametreur parametreur) { this.parametreur = parametreur; @@ -92,7 +108,12 @@ namespace OrderStacks.model.manager } - + /** + * Pile sélectionnée pour essayer de poser la carte + *Valeur de la carte séléctionnée + * Fonction permettant de tenter de jouer une carte + * Booléen de carte joué + */ public bool joue(int orderedStackSelected, decimal valueCard) { bool isPlayed = parametreur.GameMode.playCard(valueCard, currentHand, orderedStackSelected, parametreur.players[currentIndexPlayer], CurrentCardPlayed); // Mettre le joueur actif @@ -100,6 +121,10 @@ namespace OrderStacks.model.manager return isPlayed; } + /** + * Fonction permettant de terminer son tour et notifier si le jeu est fini + * Booléen de fin de jeu + */ public bool endTurn() { if(parametreur.GameMode.endTurn(currentHand, CurrentCardPlayed, parametreur.players[currentIndexPlayer])) @@ -120,6 +145,10 @@ namespace OrderStacks.model.manager } } + /** + * Fonction permettant de retourner les piles + * Piles du jeu + */ public Piles getPiles() { return parametreur.GameMode.Piles; diff --git a/OrderStacks/model/manager/MultiplayerGameManager.cs b/OrderStacks/model/manager/MultiplayerGameManager.cs index 81c8fa0..cf910f4 100644 --- a/OrderStacks/model/manager/MultiplayerGameManager.cs +++ b/OrderStacks/model/manager/MultiplayerGameManager.cs @@ -2,6 +2,10 @@ { public abstract class MultiplayerGameManager : GameManager { + /** + * Parametreur de la partie + * Constructeur + */ protected MultiplayerGameManager(Parametreur parametreur) : base(parametreur) { } diff --git a/OrderStacks/model/manager/SoloGameManager.cs b/OrderStacks/model/manager/SoloGameManager.cs index 47346cc..a4aec9c 100644 --- a/OrderStacks/model/manager/SoloGameManager.cs +++ b/OrderStacks/model/manager/SoloGameManager.cs @@ -2,7 +2,10 @@ namespace OrderStacks.model.manager { public class SoloGameManager : GameManager { - + /** + * Parametreur de la partie + * Constructeur + */ public SoloGameManager(Parametreur parametreur) : base(parametreur) { diff --git a/OrderStacks/model/manager/multiplayer/LocalGameManager.cs b/OrderStacks/model/manager/multiplayer/LocalGameManager.cs deleted file mode 100644 index c6b07f6..0000000 --- a/OrderStacks/model/manager/multiplayer/LocalGameManager.cs +++ /dev/null @@ -1,9 +0,0 @@ -namespace OrderStacks.model.manager -{ - public class LocalGameManager : MultiplayerGameManager - { - public LocalGameManager(Parametreur parametreur) : base(parametreur) - { - } - } -} diff --git a/OrderStacks/model/manager/multiplayer/RemoteGameManager.cs b/OrderStacks/model/manager/multiplayer/RemoteGameManager.cs index d1ff34a..382352b 100644 --- a/OrderStacks/model/manager/multiplayer/RemoteGameManager.cs +++ b/OrderStacks/model/manager/multiplayer/RemoteGameManager.cs @@ -2,6 +2,10 @@ { public class RemoteGameManager : MultiplayerGameManager { + /** + * Parametreur de la partie + * Constructeur + */ public RemoteGameManager(Parametreur parametreur) : base(parametreur) { } diff --git a/OrderStacks/model/piles/ClassicPiles.cs b/OrderStacks/model/piles/ClassicPiles.cs index e459e6d..3fd2e24 100644 --- a/OrderStacks/model/piles/ClassicPiles.cs +++ b/OrderStacks/model/piles/ClassicPiles.cs @@ -4,7 +4,11 @@ namespace OrderStacks.model.piles { public class ClassicPiles : Piles { - + /** + * Nombre de pile + * + * Constructeur + */ public ClassicPiles(int nbPile) : base(nbPile) { for (int i = 0; i < nbPile; i++) diff --git a/OrderStacks/model/piles/FractionPiles.cs b/OrderStacks/model/piles/FractionPiles.cs index d6463df..7753847 100644 --- a/OrderStacks/model/piles/FractionPiles.cs +++ b/OrderStacks/model/piles/FractionPiles.cs @@ -4,6 +4,11 @@ namespace OrderStacks.model.piles { public class FractionPiles : Piles { + /** + * Nombre de pile + * + * Constructeur + */ public FractionPiles(int nbPile) : base(nbPile) { for (int i = 0; i < nbPile; i++) diff --git a/OrderStacks/model/piles/Piles.cs b/OrderStacks/model/piles/Piles.cs index 2fb1842..69a6130 100644 --- a/OrderStacks/model/piles/Piles.cs +++ b/OrderStacks/model/piles/Piles.cs @@ -9,6 +9,11 @@ namespace OrderStacks.model.piles protected List> ListOrderedStacks { get; set; } = new List>(); public int Size { get; set; } + /** + * Nombre de pile + * + * Constructeur + */ public Piles(int nbPile) { Size = nbPile; @@ -18,6 +23,13 @@ namespace OrderStacks.model.piles } } + /** + * Index de la pile + * + * Fonction permettant de retourner une pile grâce à son index + * + * Pile de carte + */ public Stack getStack(int i) { return ListOrderedStacks[i]; diff --git a/OrderStacks/model/piles/Piles0To1.cs b/OrderStacks/model/piles/Piles0To1.cs index e19b507..dbf61a7 100644 --- a/OrderStacks/model/piles/Piles0To1.cs +++ b/OrderStacks/model/piles/Piles0To1.cs @@ -4,6 +4,11 @@ namespace OrderStacks.model.piles { public class Piles0To1 : Piles { + /** + * Nombre de pile + * + * Constructeur + */ public Piles0To1(int nbPile) : base(nbPile) { for (int i = 0; i < nbPile; i++) diff --git a/OrderStacks/model/piles/Piles0To10.cs b/OrderStacks/model/piles/Piles0To10.cs index ee2d3c9..c16111a 100644 --- a/OrderStacks/model/piles/Piles0To10.cs +++ b/OrderStacks/model/piles/Piles0To10.cs @@ -4,6 +4,11 @@ namespace OrderStacks.model.piles { public class Piles0To10 : Piles { + /** + * Nombre de pile + * + * Constructeur + */ public Piles0To10(int nbPile) : base(nbPile) { for (int i = 0; i < nbPile; i++) diff --git a/OrderStacks/model/piles/PilesMoins50To50.cs b/OrderStacks/model/piles/PilesMoins50To50.cs index 1f4fc06..bfedd41 100644 --- a/OrderStacks/model/piles/PilesMoins50To50.cs +++ b/OrderStacks/model/piles/PilesMoins50To50.cs @@ -4,6 +4,11 @@ namespace OrderStacks.model.piles { public class PilesMoins51To51 : Piles { + /** + * Nombre de pile + * + * Constructeur + */ public PilesMoins51To51(int nbPile) : base(nbPile) { for (int i = 0; i < nbPile; i++) diff --git a/OrderStacks/model/piles/PilesMoins5To5.cs b/OrderStacks/model/piles/PilesMoins5To5.cs index 204a27a..9825936 100644 --- a/OrderStacks/model/piles/PilesMoins5To5.cs +++ b/OrderStacks/model/piles/PilesMoins5To5.cs @@ -4,7 +4,11 @@ namespace OrderStacks.model.piles { public class PilesMoins5To5 : Piles { - + /** + * Nombre de pile + * + * Constructeur + */ public PilesMoins5To5(int nbPile) : base(nbPile) { for (int i = 0; i < nbPile; i++) diff --git a/OrderStacks/view/MainPage.xaml.cs b/OrderStacks/view/MainPage.xaml.cs index a3bcfa4..b0c9fa7 100644 --- a/OrderStacks/view/MainPage.xaml.cs +++ b/OrderStacks/view/MainPage.xaml.cs @@ -33,7 +33,10 @@ namespace OrderStacks.view /** * Liste des pseudos des joueurs * Nombre de piles pour jouer - * Version du jeu joué + * Version du jeu pour jouer + * Nombre de cartes pour jouer + * + * Constructeur */ public MainPage(List playersNames, int nbPile, int indexMode, int nbCard) { @@ -71,9 +74,10 @@ namespace OrderStacks.view /** - * Evénement permettant d'afficher les messages d'alertes générés dans le model * Instance qui envoi l'événement * Argument(s) de l'événement + * + * Evénement permettant d'afficher les messages d'alertes générés dans le model */ private void OnAlertChanged(object sender, EventArgs args) { @@ -86,9 +90,10 @@ namespace OrderStacks.view /** - * Evénement permettant de peindre la surface du canvas * Instance qui envoi l'événement * Arguments de l'événement + * + * Evénement permettant de peindre la surface du canvas */ public void OnCanvasViewPaintSurface(object sender, SKPaintSurfaceEventArgs args) { @@ -115,10 +120,11 @@ namespace OrderStacks.view /** - * Evénement qui permet de gérer le Drag and Drop. - * Il permet de traiter le clic, le mouvement, le relachement du clic et la fin de traitement d'un clic. * Instance qui envoi l'événement * Arguments de l'événement + * + * Evénement qui permet de gérer le Drag and Drop. + * Il permet de traiter le clic, le mouvement, le relachement du clic et la fin de traitement d'un clic. */ public void OnTouchEffectAction(object sender, TouchActionEventArgs args) { @@ -177,7 +183,6 @@ namespace OrderStacks.view case TouchActionType.Released: - case TouchActionType.Cancelled: if (textDictionary.ContainsKey(args.Id)) { @@ -216,7 +221,7 @@ namespace OrderStacks.view /** - * Fonction permettant de déployer visuellement les piles + * Fonction permettant de placer les piles (piles non dessinées) */ private void InflateStack() { @@ -271,7 +276,7 @@ namespace OrderStacks.view /** - * Fonction permettant de déployer visuellement les cartes contenues dans la main du joueur actif + * Fonction permettant de placer les cartes contenues dans la main du joueur actif (cartes non dessinées) */ private void InflateHand() { @@ -314,9 +319,10 @@ namespace OrderStacks.view /** - * Evénement traitant la fin du jeu * Instance qui envoi l'événement * Argument(s) de l'événement + * + * Evénement traitant la fin du jeu */ private void OnEndGame(object sender, EventArgs args) { @@ -334,9 +340,11 @@ namespace OrderStacks.view } /** - * Fonction permettant de lancer le déplacement d'une carte sur une pile * Index de la pile joué * Valeur de la carte joué + * + * Fonction permettant de tenter de jouer une carte + * * Booléen qui indique si la carte a pu être joué */ private bool Played(int numStack, decimal value) @@ -351,9 +359,10 @@ namespace OrderStacks.view /** - * Evénement permettant de relancer le jeu avec les mêmes paramètres de jeu * Instance qui envoi l'événement - * Argument de l'événement + * Argument(s) de l'événement + * + * Evénement permettant de relancer le jeu avec les mêmes paramètres */ private void Retry(object sender, EventArgs args) { @@ -389,9 +398,10 @@ namespace OrderStacks.view /** - * Evénement permettant de lancer la fin du tour d'un joueur * Instance qui envoi l'événement - * Argument de l'événement + * Argument(s) de l'événement + * + * Evénement permettant de lancer la fin du tour d'un joueur */ private async void EndTurn(object sender, EventArgs args) { @@ -413,9 +423,10 @@ namespace OrderStacks.view /** - * Evénement permettant de naviguer entre les différentes pages de l'application * Instance qui envoi l'événement - * Argument de l'événement + * Argument(s) de l'événement + * + * Evénement permettant de naviguer entre les différentes pages de l'application */ private async void PlayToHome(object sender, EventArgs args) { diff --git a/OrderStacks/view/TouchManipulationCard.cs b/OrderStacks/view/TouchManipulationCard.cs index 18fe2a7..9f3039d 100644 --- a/OrderStacks/view/TouchManipulationCard.cs +++ b/OrderStacks/view/TouchManipulationCard.cs @@ -25,8 +25,11 @@ namespace OrderStacks.view /** - * Objet dessiné - * Carte qui est dessiné par le textPaint + * Objet à dessiner + * Carte dessinée dans le textPaint + * Taille de l'espace entre le centre de la carte et la bordure sur l'axe des x + * + * Constructeur */ public TouchManipulationCard(SKPaint textPaint, CardVM value, float width) { @@ -37,6 +40,7 @@ namespace OrderStacks.view display = Value.ToString(); + // Permet de traiter les fractions if (Value.GetType() == typeof(FractionCardVM)) { textPaint1 = new SKPaint(); @@ -71,9 +75,9 @@ namespace OrderStacks.view public SKMatrix InitialMatrix { set; get; } /** - * Fonction permettant de dessiner l'objet que contient l'instance dans un canvas donné avec une couleur donnée * Canvas où l'on souhaite dessiner l'objet contenu dans l'instance - * Couleur qui sera prise par l'objet + * + * Fonction permettant de dessiner l'objet que contient l'instance dans un canvas donné */ public void Paint(SKCanvas canvas) { @@ -88,6 +92,7 @@ namespace OrderStacks.view SKRect card; + // Permet de traiter les fractions if (Value.GetType() == typeof(FractionCardVM)) { card = new SKRect(-width, -height - textPaint.TextSize, width + textPaint.MeasureText(Math.Pow(10, ((FractionCardVM)(Value)).Fraction.SizeMax-1).ToString()), height); @@ -103,6 +108,7 @@ namespace OrderStacks.view card = new SKRect(-width, -height - textPaint.TextSize, width + textPaint.MeasureText(display), height); } + // Permet de traiter les fractions if (Value.GetType() == typeof(FractionCardVM)) { int sizeMax = ((FractionCardVM)(Value)).Fraction.SizeMax; @@ -163,8 +169,9 @@ namespace OrderStacks.view } /** - * Fonction permettant de changer la couleur de l'objet contenu dans l'instance * Nouvelle couleur que l'on souhaite attribué à l'objet contenu dans l'instance + * + * Fonction permettant de changer la couleur de l'objet contenu dans l'instance */ public void ChangeColor(SKColor color) { @@ -172,8 +179,10 @@ namespace OrderStacks.view } /** - * Fonction permettant de savoir si le point qu'on lui passe est dans la zone où l'objet est dessiné * Point que l'on souhaite tester + * + * Fonction permettant de savoir si le point qu'on lui passe est dans la zone où l'objet est dessiné + * * Booléen qui indique si le point donné est dans la zone où l'objet en instance est dessiné */ public bool HitTest(SKPoint location) @@ -188,6 +197,8 @@ namespace OrderStacks.view // Check if it's in the untransformed bitmap rectangle SKRect rect; + + // Permet de traiter les fractions if (Value.GetType() == typeof(FractionCardVM)) { rect = new SKRect(-width, -height - textPaint.TextSize, width + textPaint.MeasureText(Math.Pow(10, ((FractionCardVM)(Value)).Fraction.SizeMax - 1).ToString()), height); @@ -202,11 +213,12 @@ namespace OrderStacks.view } /** + * Index que l'on souhaite traiter + * Type d'évenement lancé + * Nouveau point + * * Evénement qui permet de gérer le Drag and Drop. * Il permet de traiter le clic, le mouvement, le relachement du clic et la fin de traitement d'un objet. - * Index de la position que l'on souhaite traiter - * Type d'évenement lancé - * Nouveau point que l'on souhaite traiter */ public void ProcessTouchEvent(long id, TouchActionType type, SKPoint location) { diff --git a/OrderStacks/viewmodel/CardVM.cs b/OrderStacks/viewmodel/CardVM.cs index b6ad627..f47ac74 100644 --- a/OrderStacks/viewmodel/CardVM.cs +++ b/OrderStacks/viewmodel/CardVM.cs @@ -22,6 +22,7 @@ namespace OrderStacks.viewmodel /** * Nom de la propriété + * * Fonction permettant de notifier qu'une propriété a changé */ protected virtual void OnPropertyChanged(string info) @@ -31,6 +32,7 @@ namespace OrderStacks.viewmodel /** * Card représenté + * * Constructeur */ public CardVM(Card view) diff --git a/OrderStacks/viewmodel/FractionCardVM.cs b/OrderStacks/viewmodel/FractionCardVM.cs index f419946..19cc130 100644 --- a/OrderStacks/viewmodel/FractionCardVM.cs +++ b/OrderStacks/viewmodel/FractionCardVM.cs @@ -15,7 +15,7 @@ namespace OrderStacks.viewmodel get { return fraction; } set { - this.fraction = value; + fraction = value; View.Fraction = value; OnPropertyChanged("Value"); } @@ -23,6 +23,7 @@ namespace OrderStacks.viewmodel /** * FractionCard représenté + * * Constructeur */ public FractionCardVM(FractionCard view) : base(view) @@ -33,6 +34,7 @@ namespace OrderStacks.viewmodel /** * Fonction permettant de retourner le nombre maximum de chiffre présent en numérateur et/ou en dénominateur. + * * Nombre maximum de chiffre présent en numérateur et/ou dénominateur */ public string getDisplayMax() diff --git a/OrderStacks/viewmodel/Main.cs b/OrderStacks/viewmodel/Main.cs index c810161..20e3635 100644 --- a/OrderStacks/viewmodel/Main.cs +++ b/OrderStacks/viewmodel/Main.cs @@ -44,6 +44,7 @@ namespace OrderStacks.viewmodel /** * Nom de la propriété + * * Fonction permettant de notifier qu'une propriété a changé */ protected virtual void OnPropertyChanged(string info) @@ -69,6 +70,7 @@ namespace OrderStacks.viewmodel * Nombre de carte maximal pour les piles * Nombre de piles * Pseudo(s) du/des joueur(s) + * * Constructeur */ public Main(List playersNames, int nbPile, int nbCard, int indexMode) @@ -149,6 +151,7 @@ namespace OrderStacks.viewmodel /** * Fonction permettant de retourner une vue des piles ordonnées + * * Vue des piles ordonnées */ public IReadOnlyList> getListOrderedStacks() @@ -159,6 +162,7 @@ namespace OrderStacks.viewmodel /** * Source de l'événement * Argument(s) de l'événement + * * Evénement permettant de déclencher le changement de joueur. */ protected internal void OnPlayerChanged(object source, PlayerChangedEventArgs args) @@ -182,6 +186,7 @@ namespace OrderStacks.viewmodel /** * Argument(s) de l'événement * Source de l'événement + * * Evénement permettant de déclencher la fin du jeu. */ public void OnEndGame(object source, EventArgs args) @@ -193,7 +198,9 @@ namespace OrderStacks.viewmodel /** * Numéro de la pile séléctionnée pour jouer * Valeur de la carte joué + * * Fonction permettant de demander à jouer une carte puis de retourner si elle a été joué + * * Booléen de carte joué */ public bool played(int numStack, decimal valueCard) @@ -227,6 +234,7 @@ namespace OrderStacks.viewmodel /** * Fonction permettant de changer de joueur. + * * Booléen de fin de jeu */ public bool endTurn() diff --git a/OrderStacks/viewmodel/PlayerVM.cs b/OrderStacks/viewmodel/PlayerVM.cs index bc9fd1d..032b59d 100644 --- a/OrderStacks/viewmodel/PlayerVM.cs +++ b/OrderStacks/viewmodel/PlayerVM.cs @@ -13,6 +13,7 @@ namespace OrderStacks.viewmodel /** * Player représenté + * * Constructeur */ public PlayerVM(Player view) @@ -28,6 +29,7 @@ namespace OrderStacks.viewmodel /** * Argument(s) de l'événement * Source de l'événement + * * Evénement permettant à l'utilisateur de changer les cartes qu'il possède (supprimé et/ou piocher une carte). */ private void OnHandCardChanged(object sender, HandCardChangedEventArgs args) @@ -44,6 +46,7 @@ namespace OrderStacks.viewmodel /** * Carte piocher + * * Fonction permettant de piocher une carte */ public void pioche(CardVM card) @@ -53,6 +56,7 @@ namespace OrderStacks.viewmodel /** * Fonction permettant de retourner les cartes possédées par l'utilisateur. + * * Liste des cartes possédé par l'utilisateur */ public List getCardList()