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

Ajout commentaire

Browse Source
master
cldupland 5 years ago
parent 891f524a4a
commit f7d6f41f00
17 changed files with 434 additions and 224 deletions
Show Stats Download Patch File Download Diff File

234
OrderStacks/Resx/AppResources.Designer.cs generated
Unescape View File

@ -1,57 +1,44 @@
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
// <auto-generated> // <auto-generated>
// Ce code a été généré par un outil. // This code was generated by a tool.
// Version du runtime :4.0.30319.42000 // Runtime Version:4.0.30319.42000
// //
// Les modifications apportées à ce fichier peuvent provoquer un comportement incorrect et seront perdues si // Changes to this file may cause incorrect behavior and will be lost if
// le code est régénéré. // the code is regenerated.
// </auto-generated> // </auto-generated>
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
namespace OrderStacks.Resx { namespace OrderStacks.Resx {
using System; using System;
using System.Reflection;
/// <summary> [System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
/// Une classe de ressource fortement typée destinée, entre autres, à la consultation des chaînes localisées. [System.Diagnostics.DebuggerNonUserCodeAttribute()]
/// </summary> [System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
// 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()]
public class AppResources { 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() { internal AppResources() {
} }
/// <summary> [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Advanced)]
/// Retourne l'instance ResourceManager mise en cache utilisée par cette classe. public static System.Resources.ResourceManager ResourceManager {
/// </summary>
[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
public static global::System.Resources.ResourceManager ResourceManager {
get { get {
if (object.ReferenceEquals(resourceMan, null)) { if (object.Equals(null, resourceMan)) {
global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("OrderStacks.Resx.AppResources", typeof(AppResources).Assembly); System.Resources.ResourceManager temp = new System.Resources.ResourceManager("OrderStacks.Resx.AppResources", typeof(AppResources).Assembly);
resourceMan = temp; resourceMan = temp;
} }
return resourceMan; return resourceMan;
} }
} }
/// <summary> [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Advanced)]
/// Remplace la propriété CurrentUICulture du thread actuel pour toutes public static System.Globalization.CultureInfo Culture {
/// les recherches de ressources à l'aide de cette classe de ressource fortement typée.
/// </summary>
[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
public static global::System.Globalization.CultureInfo Culture {
get { get {
return resourceCulture; return resourceCulture;
} }
@ -60,469 +47,306 @@ namespace OrderStacks.Resx {
} }
} }
/// <summary>
/// Recherche une chaîne localisée semblable à OrderStacks
///
///A votre disposition, un mode de jeu en local, jouable jusqu&apos;à 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&apos;application grâce aux images du soleil et lune..
/// </summary>
public static string StrAbout { public static string StrAbout {
get { get {
return ResourceManager.GetString("StrAbout", resourceCulture); return ResourceManager.GetString("StrAbout", resourceCulture);
} }
} }
/// <summary>
/// Recherche une chaîne localisée semblable à Pile ascendante.
/// </summary>
public static string StrAcendingStack { public static string StrAcendingStack {
get { get {
return ResourceManager.GetString("StrAcendingStack", resourceCulture); return ResourceManager.GetString("StrAcendingStack", resourceCulture);
} }
} }
/// <summary>
/// Recherche une chaîne localisée semblable à Jouer.
/// </summary>
public static string StrBtnPlay { public static string StrBtnPlay {
get { get {
return ResourceManager.GetString("StrBtnPlay", resourceCulture); return ResourceManager.GetString("StrBtnPlay", resourceCulture);
} }
} }
/// <summary>
/// Recherche une chaîne localisée semblable à La pile n&apos;est pas disponnible.
/// </summary>
public static string StrCantGetStack { public static string StrCantGetStack {
get { get {
return ResourceManager.GetString("StrCantGetStack", resourceCulture); return ResourceManager.GetString("StrCantGetStack", resourceCulture);
} }
} }
/// <summary>
/// Recherche une chaîne localisée semblable à La carte n&apos;existe pas .
/// </summary>
public static string StrCardDoesntExist { public static string StrCardDoesntExist {
get { get {
return ResourceManager.GetString("StrCardDoesntExist", resourceCulture); return ResourceManager.GetString("StrCardDoesntExist", resourceCulture);
} }
} }
/// <summary>
/// Recherche une chaîne localisée semblable à Vous devez jouer au minimum deux cartes par tour.
/// </summary>
public static string StrCardPlayedLessThanTwo { public static string StrCardPlayedLessThanTwo {
get { get {
return ResourceManager.GetString("StrCardPlayedLessThanTwo", resourceCulture); return ResourceManager.GetString("StrCardPlayedLessThanTwo", resourceCulture);
} }
} }
/// <summary>
/// Recherche une chaîne localisée semblable à Fermer.
/// </summary>
public static string StrCloseWind { public static string StrCloseWind {
get { get {
return ResourceManager.GetString("StrCloseWind", resourceCulture); return ResourceManager.GetString("StrCloseWind", resourceCulture);
} }
} }
/// <summary>
/// Recherche une chaîne localisée semblable à Pile descendante.
/// </summary>
public static string StrDownStack { public static string StrDownStack {
get { get {
return ResourceManager.GetString("StrDownStack", resourceCulture); return ResourceManager.GetString("StrDownStack", resourceCulture);
} }
} }
/// <summary>
/// Recherche une chaîne localisée semblable à Fin de tour.
/// </summary>
public static string StrEndTurn { public static string StrEndTurn {
get { get {
return ResourceManager.GetString("StrEndTurn", resourceCulture); return ResourceManager.GetString("StrEndTurn", resourceCulture);
} }
} }
/// <summary>
/// Recherche une chaîne localisée semblable à Entrez votre pseudo.
/// </summary>
public static string StrEnterPseudo { public static string StrEnterPseudo {
get { get {
return ResourceManager.GetString("StrEnterPseudo", resourceCulture); return ResourceManager.GetString("StrEnterPseudo", resourceCulture);
} }
} }
/// <summary>
/// Recherche une chaîne localisée semblable à A propos.
/// </summary>
public static string StrInfo { public static string StrInfo {
get { get {
return ResourceManager.GetString("StrInfo", resourceCulture); return ResourceManager.GetString("StrInfo", resourceCulture);
} }
} }
/// <summary>
/// Recherche une chaîne localisée semblable à La partie est terminée.
/// </summary>
public static string String3 { public static string String3 {
get { get {
return ResourceManager.GetString("String3", resourceCulture); return ResourceManager.GetString("String3", resourceCulture);
} }
} }
/// <summary>
/// Recherche une chaîne localisée semblable à Bravo vous avez gagné!.
/// </summary>
public static string String4 { public static string String4 {
get { get {
return ResourceManager.GetString("String4", resourceCulture); return ResourceManager.GetString("String4", resourceCulture);
} }
} }
/// <summary>
/// Recherche une chaîne localisée semblable à Lancer une partie.
/// </summary>
public static string StrLocalGame { public static string StrLocalGame {
get { get {
return ResourceManager.GetString("StrLocalGame", resourceCulture); return ResourceManager.GetString("StrLocalGame", resourceCulture);
} }
} }
/// <summary>
/// Recherche une chaîne localisée semblable à .
/// </summary>
public static string StrLose { public static string StrLose {
get { get {
return ResourceManager.GetString("StrLose", resourceCulture); return ResourceManager.GetString("StrLose", resourceCulture);
} }
} }
/// <summary>
/// Recherche une chaîne localisée semblable à Multijoueur.
/// </summary>
public static string StrMultiplayer { public static string StrMultiplayer {
get { get {
return ResourceManager.GetString("StrMultiplayer", resourceCulture); return ResourceManager.GetString("StrMultiplayer", resourceCulture);
} }
} }
/// <summary>
/// Recherche une chaîne localisée semblable à Nombre de cartes :.
/// </summary>
public static string StrNbCards { public static string StrNbCards {
get { get {
return ResourceManager.GetString("StrNbCards", resourceCulture); return ResourceManager.GetString("StrNbCards", resourceCulture);
} }
} }
/// <summary>
/// Recherche une chaîne localisée semblable à Joueurs :.
/// </summary>
public static string StrNbPlayers { public static string StrNbPlayers {
get { get {
return ResourceManager.GetString("StrNbPlayers", resourceCulture); return ResourceManager.GetString("StrNbPlayers", resourceCulture);
} }
} }
/// <summary>
/// Recherche une chaîne localisée semblable à Nombre de piles en jeu :.
/// </summary>
public static string StrNbStacksInGame { public static string StrNbStacksInGame {
get { get {
return ResourceManager.GetString("StrNbStacksInGame", resourceCulture); return ResourceManager.GetString("StrNbStacksInGame", resourceCulture);
} }
} }
/// <summary>
/// Recherche une chaîne localisée semblable à Suivant.
/// </summary>
public static string StrNext { public static string StrNext {
get { get {
return ResourceManager.GetString("StrNext", resourceCulture); return ResourceManager.GetString("StrNext", resourceCulture);
} }
} }
/// <summary>
/// Recherche une chaîne localisée semblable à Veuillez choisir un nombre de joueur ainsi que leur(s) nom(s).
/// </summary>
public static string StrPlayerSelections { public static string StrPlayerSelections {
get { get {
return ResourceManager.GetString("StrPlayerSelections", resourceCulture); return ResourceManager.GetString("StrPlayerSelections", resourceCulture);
} }
} }
/// <summary>
/// Recherche une chaîne localisée semblable à Entrez votre pseudo :.
/// </summary>
public static string StrPseudoGM { public static string StrPseudoGM {
get { get {
return ResourceManager.GetString("StrPseudoGM", resourceCulture); return ResourceManager.GetString("StrPseudoGM", resourceCulture);
} }
} }
/// <summary>
/// Recherche une chaîne localisée semblable à Rejouer.
/// </summary>
public static string StrRetry { public static string StrRetry {
get { get {
return ResourceManager.GetString("StrRetry", resourceCulture); return ResourceManager.GetString("StrRetry", resourceCulture);
} }
} }
/// <summary>
/// Recherche une chaîne localisée semblable à - L&apos;objectif est de battre la machine seul et/ou en coopération..
/// </summary>
public static string StrTiret1 { public static string StrTiret1 {
get { get {
return ResourceManager.GetString("StrTiret1", resourceCulture); return ResourceManager.GetString("StrTiret1", resourceCulture);
} }
} }
/// <summary>
/// Recherche une chaîne localisée semblable à - Une fois votre tour terminé, vous appuyez sur le boutton &quot;Fin de tour&quot; afin de passer au joueur suivant..
/// </summary>
public static string StrTiret10 { public static string StrTiret10 {
get { get {
return ResourceManager.GetString("StrTiret10", resourceCulture); return ResourceManager.GetString("StrTiret10", resourceCulture);
} }
} }
/// <summary>
/// Recherche une chaîne localisée semblable à - La partie est finie quand toutes les cartes sont jouées ou quand le joueur dont c&apos;est le tour ne peut plus jouer..
/// </summary>
public static string StrTiret11 { public static string StrTiret11 {
get { get {
return ResourceManager.GetString("StrTiret11", resourceCulture); return ResourceManager.GetString("StrTiret11", resourceCulture);
} }
} }
/// <summary>
/// Recherche une chaîne localisée semblable à - Afin de préparer la partie, vous disposez d&apos;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..
/// </summary>
public static string StrTiret12 { public static string StrTiret12 {
get { get {
return ResourceManager.GetString("StrTiret12", resourceCulture); return ResourceManager.GetString("StrTiret12", resourceCulture);
} }
} }
/// <summary>
/// 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.
/// </summary>
public static string StrTiret13 { public static string StrTiret13 {
get { get {
return ResourceManager.GetString("StrTiret13", resourceCulture); return ResourceManager.GetString("StrTiret13", resourceCulture);
} }
} }
/// <summary>
/// Recherche une chaîne localisée semblable à - Afin d&apos;atteindre l&apos;objectif, les joueurs disposent de 4 piles (par défaut): deux piles ascendantes vertes et deux piles descendantes rouges..
/// </summary>
public static string StrTiret2 { public static string StrTiret2 {
get { get {
return ResourceManager.GetString("StrTiret2", resourceCulture); return ResourceManager.GetString("StrTiret2", resourceCulture);
} }
} }
/// <summary>
/// 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..
/// </summary>
public static string StrTiret3 { public static string StrTiret3 {
get { get {
return ResourceManager.GetString("StrTiret3", resourceCulture); return ResourceManager.GetString("StrTiret3", resourceCulture);
} }
} }
/// <summary>
/// Recherche une chaîne localisée semblable à - Le but est de poser toutes les cartes du jeu sur les différentes piles..
/// </summary>
public static string StrTiret4 { public static string StrTiret4 {
get { get {
return ResourceManager.GetString("StrTiret4", resourceCulture); return ResourceManager.GetString("StrTiret4", resourceCulture);
} }
} }
/// <summary>
/// Recherche une chaîne localisée semblable à - Pour jouer, il suffit de faire glisser une carte sur la pile souhaitée..
/// </summary>
public static string StrTiret5 { public static string StrTiret5 {
get { get {
return ResourceManager.GetString("StrTiret5", resourceCulture); return ResourceManager.GetString("StrTiret5", resourceCulture);
} }
} }
/// <summary>
/// Recherche une chaîne localisée semblable à - Cette carte doit être plus grande que celle déjà présente s&apos;il s&apos;agit d&apos;une pile ascendante et plus petite si c&apos;est l&apos;inverse..
/// </summary>
public static string StrTiret6 { public static string StrTiret6 {
get { get {
return ResourceManager.GetString("StrTiret6", resourceCulture); return ResourceManager.GetString("StrTiret6", resourceCulture);
} }
} }
/// <summary>
/// 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&apos;on souhaite jouer soit uniquement plus petite d&apos;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&apos;on souhaite jouer soit uniquement plus grande d&apos;une dizaine que le carte sur la pile..
/// </summary>
public static string StrTiret7 { public static string StrTiret7 {
get { get {
return ResourceManager.GetString("StrTiret7", resourceCulture); return ResourceManager.GetString("StrTiret7", resourceCulture);
} }
} }
/// <summary>
/// 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..
/// </summary>
public static string StrTiret8 { public static string StrTiret8 {
get { get {
return ResourceManager.GetString("StrTiret8", resourceCulture); return ResourceManager.GetString("StrTiret8", resourceCulture);
} }
} }
/// <summary>
/// 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..
/// </summary>
public static string StrTiret9 { public static string StrTiret9 {
get { get {
return ResourceManager.GetString("StrTiret9", resourceCulture); return ResourceManager.GetString("StrTiret9", resourceCulture);
} }
} }
/// <summary>
/// Recherche une chaîne localisée semblable à OrderStacks.
/// </summary>
public static string StrTitle { public static string StrTitle {
get { get {
return ResourceManager.GetString("StrTitle", resourceCulture); return ResourceManager.GetString("StrTitle", resourceCulture);
} }
} }
/// <summary>
/// Recherche une chaîne localisée semblable à Règles.
/// </summary>
public static string StrTitleRules { public static string StrTitleRules {
get { get {
return ResourceManager.GetString("StrTitleRules", resourceCulture); return ResourceManager.GetString("StrTitleRules", resourceCulture);
} }
} }
/// <summary>
/// Recherche une chaîne localisée semblable à Valeurs :.
/// </summary>
public static string StrValueType { public static string StrValueType {
get { get {
return ResourceManager.GetString("StrValueType", resourceCulture); return ResourceManager.GetString("StrValueType", resourceCulture);
} }
} }
/// <summary>
/// Recherche une chaîne localisée semblable à Félicitation vous avez gagné.
/// </summary>
public static string StrWin { public static string StrWin {
get { get {
return ResourceManager.GetString("StrWin", resourceCulture); return ResourceManager.GetString("StrWin", resourceCulture);
} }
} }
/// <summary>
/// Recherche une chaîne localisée semblable à La carte choisie ne convient pas.
/// </summary>
public static string StrWrongStack { public static string StrWrongStack {
get { get {
return ResourceManager.GetString("StrWrongStack", resourceCulture); return ResourceManager.GetString("StrWrongStack", resourceCulture);
} }
} }
/// <summary>
/// Recherche une chaîne localisée semblable à Fractionnées.
/// </summary>
public static string TypeValuefractionated { public static string TypeValuefractionated {
get { get {
return ResourceManager.GetString("TypeValuefractionated", resourceCulture); return ResourceManager.GetString("TypeValuefractionated", resourceCulture);
} }
} }
/// <summary>
/// Recherche une chaîne localisée semblable à 2 Décimales.
/// </summary>
public static string TypeValueHundredth {
get {
return ResourceManager.GetString("TypeValueHundredth", resourceCulture);
}
}
/// <summary>
/// Recherche une chaîne localisée semblable à 2 Décimales (Fraction).
/// </summary>
public static string TypeValueHundredthFract { public static string TypeValueHundredthFract {
get { get {
return ResourceManager.GetString("TypeValueHundredthFract", resourceCulture); return ResourceManager.GetString("TypeValueHundredthFract", resourceCulture);
} }
} }
/// <summary>
/// Recherche une chaîne localisée semblable à Relatives.
/// </summary>
public static string TypeValueRelative { public static string TypeValueRelative {
get { get {
return ResourceManager.GetString("TypeValueRelative", resourceCulture); return ResourceManager.GetString("TypeValueRelative", resourceCulture);
} }
} }
/// <summary>
/// Recherche une chaîne localisée semblable à 1 Décimales.
/// </summary>
public static string TypeValueTenth {
get {
return ResourceManager.GetString("TypeValueTenth", resourceCulture);
}
}
/// <summary>
/// Recherche une chaîne localisée semblable à 1 Décimales (Fraction).
/// </summary>
public static string TypeValueTenthFract { public static string TypeValueTenthFract {
get { get {
return ResourceManager.GetString("TypeValueTenthFract", resourceCulture); return ResourceManager.GetString("TypeValueTenthFract", resourceCulture);
} }
} }
/// <summary>
/// Recherche une chaîne localisée semblable à 3 Décimales (Fraction).
/// </summary>
public static string TypeValueThousandthFract { public static string TypeValueThousandthFract {
get { get {
return ResourceManager.GetString("TypeValueThousandthFract", resourceCulture); return ResourceManager.GetString("TypeValueThousandthFract", resourceCulture);
} }
} }
/// <summary>
/// Recherche une chaîne localisée semblable à Entière.
/// </summary>
public static string TypeValueWhole { public static string TypeValueWhole {
get { get {
return ResourceManager.GetString("TypeValueWhole", resourceCulture); return ResourceManager.GetString("TypeValueWhole", resourceCulture);
} }
} }
/// <summary> public static string TypeValueTenth {
/// Recherche une chaîne localisée semblable à Thème clair :. get {
/// </summary> return ResourceManager.GetString("TypeValueTenth", resourceCulture);
}
}
public static string TypeValueHundredth {
get {
return ResourceManager.GetString("TypeValueHundredth", resourceCulture);
}
}
public static string WhiteTheme { public static string WhiteTheme {
get { get {
return ResourceManager.GetString("WhiteTheme", resourceCulture); return ResourceManager.GetString("WhiteTheme", resourceCulture);
} }
} }
/// <summary>
/// Recherche une chaîne localisée semblable à Erreur pseudo :.
/// </summary>
public static string WrongPseudo { public static string WrongPseudo {
get { get {
return ResourceManager.GetString("WrongPseudo", resourceCulture); return ResourceManager.GetString("WrongPseudo", resourceCulture);

2
OrderStacks/model/gameActions/abstractRules/GameAction.cs
Unescape View File

@ -9,7 +9,7 @@ namespace OrderStacks.model.gameActions.abstractRules
public string ErrorMessage { get; set; } = ""; public string ErrorMessage { get; set; } = "";
/** /**
*<param name="listOrderedStacks">Piles de jeu</param> * <param name="listOrderedStacks">Piles de jeu</param>
* *
* Constructeur * Constructeur
*/ */

40
OrderStacks/model/gameActions/abstractRules/GameMode.cs
Unescape View File

@ -108,9 +108,9 @@ namespace OrderStacks.model.gameActions.abstractRules
} }
/** /**
* <param name="players">Liste de joueur</param>
* *
* * Fonction permettant de distribuer les cartes en début de partie
*
*/ */
protected void distribueCard(List<Player> players) protected void distribueCard(List<Player> players)
{ {
@ -127,14 +127,50 @@ namespace OrderStacks.model.gameActions.abstractRules
}); });
} }
/**
* <param name="currentHand">Liste de carte du joueur actif</param>
* <param name="player">Joueur actif</param>
*
* Fonction permettant au joueur actif de piocher une carte
*/
public abstract void pioche(List<Card> currentHand, Player player); public abstract void pioche(List<Card> currentHand, Player player);
/**
* <param name="player">Joueur actif</param>
* <param name="currentHand">Liste de carte du joeuur actif</param>
* <param name="CurrentCardPlayed">Liste des cartes jouées durant le tour du joueur actif</param>
* <param name="orderedStackSelected">Pile séléctionnée</param>
* <param name="valueCard">Valeur de la carte en train d'être joué</param>
*
* Fonction permettant de tenter de jouer une carte
*
* <returns>Booléen de carte joué</returns>
*/
public abstract bool playCard(decimal valueCard, List<Card> currentHand, int orderedStackSelected, Player player, List<Card> CurrentCardPlayed); public abstract bool playCard(decimal valueCard, List<Card> currentHand, int orderedStackSelected, Player player, List<Card> CurrentCardPlayed);
/**
* <param name="currentHand">Liste de carte du joueur actif</param>
* <param name="CurrentCardPlayed">Liste des cartes jouées durant le tour du joueur actif</param>
* <param name="player">Joueur actif</param>
*
* Fonction permettant de lancer la fin du tour et de vérifier la fin du jeu
*
* <returns>Booléen de fin de jeu</returns>
*/
public abstract bool endTurn(List<Card> currentHand, List<Card> CurrentCardPlayed, Player player); public abstract bool endTurn(List<Card> currentHand, List<Card> CurrentCardPlayed, Player player);
/**
* <param name="currentHand">Liste de carte du joueur actif</param>
*
* Fonction permettant de vérifier si c'est la fin du jeu
*/
public abstract void TestEndGame(List<Card> currentHand); public abstract void TestEndGame(List<Card> currentHand);
/**
* Fonction permettant de retourner le nombre de carte du deck
*
* <returns>Nombre de carte dans le deck</returns>
*/
public int getScore() public int getScore()
{ {
return deck.size(); return deck.size();

27
OrderStacks/model/gameActions/abstractRules/JouerUneCarte.cs
Unescape View File

@ -9,12 +9,39 @@ namespace OrderStacks.model.gameActions.abstractRules
public Card OldCard { get; set; } public Card OldCard { get; set; }
/**
* <param name="listOrderedStacks">Piles de jeu</param>
*
* Constructeur
*/
protected JouerUneCarte(Piles ListOrderedStacks) : base(ListOrderedStacks) protected JouerUneCarte(Piles ListOrderedStacks) : base(ListOrderedStacks)
{ {
} }
/**
* <param name="player">Joueur actif</param>
* <param name="currentHand">Liste de carte du joeuur actif</param>
* <param name="CurrentCardPlayed">Liste des cartes jouées durant le tour du joueur actif</param>
* <param name="orderedStackSelected">Pile séléctionnée</param>
* <param name="valueCard">Valeur de la carte en train d'être joué</param>
*
* Fonction permettant de tenter de jouer une carte
*
* <returns>Booléen de carte joué</returns>
*/
public abstract bool play(decimal valueCard, List<Card> CurrentHand, int orderedStackSelected, Player player, List<Card> CurrentCardPlayed); public abstract bool play(decimal valueCard, List<Card> CurrentHand, int orderedStackSelected, Player player, List<Card> CurrentCardPlayed);
/**
* <param name="player">Joueur actif</param>
* <param name="CurrentCardPlayed">Liste des cartes jouées durant le tour du joueur actif</param>
* <param name="bottomUp">Booléen d'ascendance</param>
* <param name="card">Carte joué</param>
* <param name="stack">Pile joué</param>
*
* Fonction permettant de tenter de jouer une carte
*
* <returns>Booléen de carte joué</returns>
*/
protected abstract bool Rule(Card card, Stack<Card> stack, bool bottomUp, Player player, List<Card> CurrentCardPlayed); protected abstract bool Rule(Card card, Stack<Card> stack, bool bottomUp, Player player, List<Card> CurrentCardPlayed);
} }
} }

13
OrderStacks/model/gameActions/abstractRules/Piocher.cs
Unescape View File

@ -7,10 +7,23 @@ namespace OrderStacks.model.gameActions.abstractRules
{ {
public abstract class Piocher : GameAction public abstract class Piocher : GameAction
{ {
/**
* <param name="listOrderedStacks">Piles de jeu</param>
*
* Constructeur
*/
public Piocher(Piles ListOrderedStacks) : base(ListOrderedStacks) public Piocher(Piles ListOrderedStacks) : base(ListOrderedStacks)
{ {
} }
/**
* <param name="player">Joueur actif</param>
* <param name="CurrentHand">Liste de carte du joeuur actif</param>
* <param name="deck">Liste de carte non découverte</param>
* <param name="nbMaxCard">Nombre maximum de carte dans la main pour le joueur actif</param>
*
* Fonction permettant de faire piocher un joueur
*/
public abstract void pioche(List<Card> CurrentHand, Deck deck, Player player, int nbMaxCard); public abstract void pioche(List<Card> CurrentHand, Deck deck, Player player, int nbMaxCard);
} }
} }

31
OrderStacks/model/gameActions/abstractRules/TerminerSonTour.cs
Unescape View File

@ -6,12 +6,32 @@ namespace OrderStacks.model.gameActions.abstractRules
{ {
public abstract class TerminerSonTour : GameAction public abstract class TerminerSonTour : GameAction
{ {
/**
* <param name="listOrderedStacks">Piles de jeu</param>
*
* Constructeur
*/
protected TerminerSonTour(Piles ListOrderedStacks) : base(ListOrderedStacks) protected TerminerSonTour(Piles ListOrderedStacks) : base(ListOrderedStacks)
{ {
} }
/**
* <param name="CurrentHand">Liste de carte du joeuur actif</param>
* <param name="CurrentCardPlayed">Liste des cartes jouées durant le tour du joueur actif</param>
*
* Fonction permettant de terminer son tour
*
* <returns>Booléen indiquant si le changement de joueur peut se passer</returns>
*/
public abstract bool end(List<Card> CurrentHand, List<Card> CurrentCardPlayed); public abstract bool end(List<Card> CurrentHand, List<Card> CurrentCardPlayed);
/**
* <param name="CurrentHand">Liste de carte du joueur actif</param>
*
* Fonction permettant de gérer le test de fin du jeu
*
* <returns>Booléen de fin du jeu</returns>
*/
public bool Test(List<Card> CurrentHand) public bool Test(List<Card> CurrentHand)
{ {
if (CurrentHand.Count != 0) if (CurrentHand.Count != 0)
@ -23,8 +43,19 @@ namespace OrderStacks.model.gameActions.abstractRules
return false; return false;
} }
/**
* <param name="CurrentHand">Liste de carte du joueur actif</param>
* <param name="playableCard">Liste des cartes jouables</param>
*
* Fonction permettant de chercher les cartes pouvants être jouées et les ajoutes à la liste des cartes jouables
*/
protected abstract void tryToFindSoluce(List<Card> playableCard, List<Card> CurrentHand); protected abstract void tryToFindSoluce(List<Card> playableCard, List<Card> CurrentHand);
/**
* <param name="playableCard">Liste des cartes jouables</param>
*
* Fonction vérifiant que les règles de fin de jeu ne sont pas arrivé
*/
protected abstract bool testEndGame(List<Card> playableCard); protected abstract bool testEndGame(List<Card> playableCard);
} }
} }

44
OrderStacks/model/gameActions/classic/GameModeClassic.cs
Unescape View File

@ -9,11 +9,22 @@ namespace OrderStacks.model.gameActions.classic
{ {
public class GameModeClassic : GameMode public class GameModeClassic : GameMode
{ {
/**
* <param name="deck">Deck de carte</param>
* <param name="piles">Piles du jeu</param>
*
* Constructeur
*/
public GameModeClassic(Piles piles, Deck deck) : base(piles, deck) public GameModeClassic(Piles piles, Deck deck) : base(piles, deck)
{ {
} }
/**
* <param name="nbPlayer">Nombre de joueur</param>
* <param name="players">Pseudo du/des joueur(s)</param>
*
* Fonction permettant de charger les paramètres de jeu
*/
override public void load(int nbPlayer, List<Player> players) override public void load(int nbPlayer, List<Player> players)
{ {
gameActions.Add(new PiocherClassic(Piles)); gameActions.Add(new PiocherClassic(Piles));
@ -24,6 +35,12 @@ namespace OrderStacks.model.gameActions.classic
distribueCard(players); distribueCard(players);
} }
/**
* <param name="currentHand">Liste de carte du joueur actif</param>
* <param name="player">Joueur actif</param>
*
* Fonction permettant au joueur actif de piocher une carte
*/
override public void pioche(List<Card> currentHand, Player player) override public void pioche(List<Card> currentHand, Player player)
{ {
Message = ""; Message = "";
@ -31,6 +48,17 @@ namespace OrderStacks.model.gameActions.classic
quickSort(currentHand, 0, currentHand.Count - 1); quickSort(currentHand, 0, currentHand.Count - 1);
} }
/**
* <param name="player">Joueur actif</param>
* <param name="currentHand">Liste de carte du joeuur actif</param>
* <param name="CurrentCardPlayed">Liste des cartes jouées durant le tour du joueur actif</param>
* <param name="orderedStackSelected">Pile séléctionnée</param>
* <param name="valueCard">Valeur de la carte en train d'être joué</param>
*
* Fonction permettant de tenter de jouer une carte
*
* <returns>Booléen de carte joué</returns>
*/
override public bool playCard(decimal valueCard, List<Card> currentHand, int orderedStackSelected, Player player, List<Card> CurrentCardPlayed) override public bool playCard(decimal valueCard, List<Card> currentHand, int orderedStackSelected, Player player, List<Card> CurrentCardPlayed)
{ {
Message = ""; Message = "";
@ -48,6 +76,15 @@ namespace OrderStacks.model.gameActions.classic
} }
} }
/**
* <param name="currentHand">Liste de carte du joueur actif</param>
* <param name="CurrentCardPlayed">Liste des cartes jouées durant le tour du joueur actif</param>
* <param name="player">Joueur actif</param>
*
* Fonction permettant de lancer la fin du tour et de vérifier la fin du jeu
*
* <returns>Booléen de fin de jeu</returns>
*/
override public bool endTurn(List<Card> currentHand, List<Card> CurrentCardPlayed, Player player) override public bool endTurn(List<Card> currentHand, List<Card> CurrentCardPlayed, Player player)
{ {
Message = ""; Message = "";
@ -65,6 +102,11 @@ namespace OrderStacks.model.gameActions.classic
} }
} }
/**
* <param name="currentHand">Liste de carte du joueur actif</param>
*
* Fonction permettant de vérifier si c'est la fin du jeu
*/
override public void TestEndGame(List<Card> currentHand) override public void TestEndGame(List<Card> currentHand)
{ {
if (((TerminerSonTourClassic)gameActions[2]).Test(currentHand)) if (((TerminerSonTourClassic)gameActions[2]).Test(currentHand))

28
OrderStacks/model/gameActions/classic/JouerUneCarteClassic.cs
Unescape View File

@ -8,11 +8,26 @@ namespace OrderStacks.model.gameActions.classic
{ {
public class JouerUneCarteClassic : JouerUneCarte public class JouerUneCarteClassic : JouerUneCarte
{ {
/**
* <param name="listOrderedStacks">Piles de jeu</param>
*
* Constructeur
*/
public JouerUneCarteClassic(Piles ListOrderedStacks) : base(ListOrderedStacks) public JouerUneCarteClassic(Piles ListOrderedStacks) : base(ListOrderedStacks)
{ {
} }
/**
* <param name="player">Joueur actif</param>
* <param name="currentHand">Liste de carte du joeuur actif</param>
* <param name="CurrentCardPlayed">Liste des cartes jouées durant le tour du joueur actif</param>
* <param name="orderedStackSelected">Pile séléctionnée</param>
* <param name="valueCard">Valeur de la carte en train d'être joué</param>
*
* Fonction permettant de tenter de jouer une carte
*
* <returns>Booléen de carte joué</returns>
*/
override public bool play(decimal valueCard, List<Card> CurrentHand, int orderedStackSelected, Player player, List<Card> CurrentCardPlayed) override public bool play(decimal valueCard, List<Card> CurrentHand, int orderedStackSelected, Player player, List<Card> CurrentCardPlayed)
{ {
foreach (Card card in CurrentHand) foreach (Card card in CurrentHand)
@ -48,6 +63,17 @@ namespace OrderStacks.model.gameActions.classic
return false; return false;
} }
/**
* <param name="player">Joueur actif</param>
* <param name="CurrentCardPlayed">Liste des cartes jouées durant le tour du joueur actif</param>
* <param name="bottomUp">Booléen d'ascendance</param>
* <param name="card">Carte joué</param>
* <param name="stack">Pile joué</param>
*
* Fonction permettant de tenter de jouer une carte
*
* <returns>Booléen de carte joué</returns>
*/
override protected bool Rule(Card card, Stack<Card> stack, bool bottomUp, Player player, List<Card> CurrentCardPlayed) override protected bool Rule(Card card, Stack<Card> stack, bool bottomUp, Player player, List<Card> 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) 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)

14
OrderStacks/model/gameActions/classic/PiocherClassic.cs
Unescape View File

@ -9,11 +9,23 @@ namespace OrderStacks.model.gameActions.classic
{ {
public class PiocherClassic : Piocher public class PiocherClassic : Piocher
{ {
/**
* <param name="listOrderedStacks">Piles de jeu</param>
*
* Constructeur
*/
public PiocherClassic(Piles ListOrderedStacks) : base(ListOrderedStacks) public PiocherClassic(Piles ListOrderedStacks) : base(ListOrderedStacks)
{ {
} }
/**
* <param name="player">Joueur actif</param>
* <param name="CurrentHand">Liste de carte du joeuur actif</param>
* <param name="deck">Liste de carte non découverte</param>
* <param name="nbMaxCard">Nombre maximum de carte dans la main pour le joueur actif</param>
*
* Fonction permettant de faire piocher un joueur
*/
override public void pioche(List<Card> CurrentHand, Deck deck, Player player, int nbMaxCard) override public void pioche(List<Card> CurrentHand, Deck deck, Player player, int nbMaxCard)
{ {
int nbPickedCard = nbMaxCard - CurrentHand.Count; int nbPickedCard = nbMaxCard - CurrentHand.Count;

36
OrderStacks/model/gameActions/classic/TerminerSonTourClassic.cs
Unescape View File

@ -8,11 +8,23 @@ namespace OrderStacks.model.gameActions.classic
{ {
public class TerminerSonTourClassic : TerminerSonTour public class TerminerSonTourClassic : TerminerSonTour
{ {
/**
* <param name="listOrderedStacks">Piles de jeu</param>
*
* Constructeur
*/
public TerminerSonTourClassic(Piles ListOrderedStacks) : base(ListOrderedStacks) public TerminerSonTourClassic(Piles ListOrderedStacks) : base(ListOrderedStacks)
{ {
} }
/**
* <param name="CurrentHand">Liste de carte du joeuur actif</param>
* <param name="CurrentCardPlayed">Liste des cartes jouées durant le tour du joueur actif</param>
*
* Fonction permettant de terminer son tour
*
* <returns>Booléen indiquant si le changement de joueur peut se passer</returns>
*/
override public bool end(List<Card> CurrentHand, List<Card> CurrentCardPlayed) override public bool end(List<Card> CurrentHand, List<Card> CurrentCardPlayed)
{ {
if (CurrentHand.Count == 0 || CurrentCardPlayed.Count >= 2) if (CurrentHand.Count == 0 || CurrentCardPlayed.Count >= 2)
@ -27,6 +39,12 @@ namespace OrderStacks.model.gameActions.classic
} }
/**
* <param name="CurrentHand">Liste de carte du joueur actif</param>
* <param name="playableCard">Liste des cartes jouables</param>
*
* Fonction permettant de chercher les cartes pouvants être jouées et les ajoutes à la liste des cartes jouables
*/
override protected void tryToFindSoluce(List<Card> playableCard, List<Card> CurrentHand) override protected void tryToFindSoluce(List<Card> playableCard, List<Card> CurrentHand)
{ {
int findDownCard = 0; int findDownCard = 0;
@ -152,19 +170,13 @@ namespace OrderStacks.model.gameActions.classic
}); });
} }
/**
* <param name="playableCard">Liste des cartes jouables</param>
*
* Fonction vérifiant que les règles de fin de jeu ne sont pas arrivé
*/
override protected bool testEndGame(List<Card> playableCard) override protected bool testEndGame(List<Card> playableCard)
{ {
//if (playableCard.Count == 2)
//{
// foreach (Card c in playableCard)
// {
// if (Equals(c.getName(), ThreeCard.CARD_THREE))
// {
// return false;
// }
// }
//}
//else
if (playableCard.Count < 2) if (playableCard.Count < 2)
{ {
return false; return false;

43
OrderStacks/model/gameActions/decimals/GameModeDecimal.cs
Unescape View File

@ -10,10 +10,22 @@ namespace OrderStacks.model.gameActions.decimals
{ {
public class GameModeDecimal : GameMode public class GameModeDecimal : GameMode
{ {
/**
* <param name="deck">Deck de carte</param>
* <param name="piles">Piles du jeu</param>
*
* Constructeur
*/
public GameModeDecimal(Piles piles, Deck deck) : base(piles, deck) public GameModeDecimal(Piles piles, Deck deck) : base(piles, deck)
{ {
} }
/**
* <param name="nbPlayer">Nombre de joueur</param>
* <param name="players">Pseudo du/des joueur(s)</param>
*
* Fonction permettant de charger les paramètres de jeu
*/
override public void load(int nbPlayer, List<Player> players) override public void load(int nbPlayer, List<Player> players)
{ {
gameActions.Add(new PiocherClassic(Piles)); gameActions.Add(new PiocherClassic(Piles));
@ -24,6 +36,12 @@ namespace OrderStacks.model.gameActions.decimals
distribueCard(players); distribueCard(players);
} }
/**
* <param name="currentHand">Liste de carte du joueur actif</param>
* <param name="player">Joueur actif</param>
*
* Fonction permettant au joueur actif de piocher une carte
*/
override public void pioche(List<Card> currentHand, Player player) override public void pioche(List<Card> currentHand, Player player)
{ {
Message = ""; Message = "";
@ -31,6 +49,17 @@ namespace OrderStacks.model.gameActions.decimals
quickSort(currentHand, 0, currentHand.Count - 1); quickSort(currentHand, 0, currentHand.Count - 1);
} }
/**
* <param name="player">Joueur actif</param>
* <param name="currentHand">Liste de carte du joeuur actif</param>
* <param name="CurrentCardPlayed">Liste des cartes jouées durant le tour du joueur actif</param>
* <param name="orderedStackSelected">Pile séléctionnée</param>
* <param name="valueCard">Valeur de la carte en train d'être joué</param>
*
* Fonction permettant de tenter de jouer une carte
*
* <returns>Booléen de carte joué</returns>
*/
override public bool playCard(decimal valueCard, List<Card> currentHand, int orderedStackSelected, Player player, List<Card> CurrentCardPlayed) override public bool playCard(decimal valueCard, List<Card> currentHand, int orderedStackSelected, Player player, List<Card> CurrentCardPlayed)
{ {
Message = ""; Message = "";
@ -48,6 +77,15 @@ namespace OrderStacks.model.gameActions.decimals
} }
} }
/**
* <param name="currentHand">Liste de carte du joueur actif</param>
* <param name="CurrentCardPlayed">Liste des cartes jouées durant le tour du joueur actif</param>
* <param name="player">Joueur actif</param>
*
* Fonction permettant de lancer la fin du tour et de vérifier la fin du jeu
*
* <returns>Booléen de fin de jeu</returns>
*/
override public bool endTurn(List<Card> currentHand, List<Card> CurrentCardPlayed, Player player) override public bool endTurn(List<Card> currentHand, List<Card> CurrentCardPlayed, Player player)
{ {
Message = ""; Message = "";
@ -65,6 +103,11 @@ namespace OrderStacks.model.gameActions.decimals
} }
} }
/**
* <param name="currentHand">Liste de carte du joueur actif</param>
*
* Fonction permettant de vérifier si c'est la fin du jeu
*/
override public void TestEndGame(List<Card> currentHand) override public void TestEndGame(List<Card> currentHand)
{ {
if (((TerminerSonTourDecimal)gameActions[2]).Test(currentHand)) if (((TerminerSonTourDecimal)gameActions[2]).Test(currentHand))

27
OrderStacks/model/gameActions/decimals/JouerUneCarteDecimal.cs
Unescape View File

@ -8,10 +8,26 @@ namespace OrderStacks.model.gameActions.decimals
{ {
public class JouerUneCarteDecimal : JouerUneCarte public class JouerUneCarteDecimal : JouerUneCarte
{ {
/**
* <param name="listOrderedStacks">Piles de jeu</param>
*
* Constructeur
*/
public JouerUneCarteDecimal(Piles ListOrderedStacks) : base(ListOrderedStacks) public JouerUneCarteDecimal(Piles ListOrderedStacks) : base(ListOrderedStacks)
{ {
} }
/**
* <param name="player">Joueur actif</param>
* <param name="currentHand">Liste de carte du joeuur actif</param>
* <param name="CurrentCardPlayed">Liste des cartes jouées durant le tour du joueur actif</param>
* <param name="orderedStackSelected">Pile séléctionnée</param>
* <param name="valueCard">Valeur de la carte en train d'être joué</param>
*
* Fonction permettant de tenter de jouer une carte
*
* <returns>Booléen de carte joué</returns>
*/
override public bool play(decimal valueCard, List<Card> CurrentHand, int orderedStackSelected, Player player, List<Card> CurrentCardPlayed) override public bool play(decimal valueCard, List<Card> CurrentHand, int orderedStackSelected, Player player, List<Card> CurrentCardPlayed)
{ {
foreach (Card card in CurrentHand) foreach (Card card in CurrentHand)
@ -47,6 +63,17 @@ namespace OrderStacks.model.gameActions.decimals
return false; return false;
} }
/**
* <param name="player">Joueur actif</param>
* <param name="CurrentCardPlayed">Liste des cartes jouées durant le tour du joueur actif</param>
* <param name="bottomUp">Booléen d'ascendance</param>
* <param name="card">Carte joué</param>
* <param name="stack">Pile joué</param>
*
* Fonction permettant de tenter de jouer une carte
*
* <returns>Booléen de carte joué</returns>
*/
override protected bool Rule(Card card, Stack<Card> stack, bool bottomUp, Player player, List<Card> CurrentCardPlayed) override protected bool Rule(Card card, Stack<Card> stack, bool bottomUp, Player player, List<Card> CurrentCardPlayed)
{ {
if ((bottomUp && card.Value > stack.Peek().Value) || (!bottomUp && card.Value < stack.Peek().Value)) if ((bottomUp && card.Value > stack.Peek().Value) || (!bottomUp && card.Value < stack.Peek().Value))

24
OrderStacks/model/gameActions/decimals/TerminerSonTourDecimal.cs
Unescape View File

@ -8,10 +8,23 @@ namespace OrderStacks.model.gameActions.decimals
{ {
public class TerminerSonTourDecimal : TerminerSonTour public class TerminerSonTourDecimal : TerminerSonTour
{ {
/**
* <param name="listOrderedStacks">Piles de jeu</param>
*
* Constructeur
*/
public TerminerSonTourDecimal(Piles ListOrderedStacks) : base(ListOrderedStacks) public TerminerSonTourDecimal(Piles ListOrderedStacks) : base(ListOrderedStacks)
{ {
} }
/**
* <param name="CurrentHand">Liste de carte du joeuur actif</param>
* <param name="CurrentCardPlayed">Liste des cartes jouées durant le tour du joueur actif</param>
*
* Fonction permettant de terminer son tour
*
* <returns>Booléen indiquant si le changement de joueur peut se passer</returns>
*/
override public bool end(List<Card> CurrentHand, List<Card> CurrentCardPlayed) override public bool end(List<Card> CurrentHand, List<Card> CurrentCardPlayed)
{ {
if (CurrentHand.Count == 0 || CurrentCardPlayed.Count >= 2) if (CurrentHand.Count == 0 || CurrentCardPlayed.Count >= 2)
@ -26,6 +39,12 @@ namespace OrderStacks.model.gameActions.decimals
} }
/**
* <param name="CurrentHand">Liste de carte du joueur actif</param>
* <param name="playableCard">Liste des cartes jouables</param>
*
* Fonction permettant de chercher les cartes pouvants être jouées et les ajoutes à la liste des cartes jouables
*/
override protected void tryToFindSoluce(List<Card> playableCard, List<Card> CurrentHand) override protected void tryToFindSoluce(List<Card> playableCard, List<Card> CurrentHand)
{ {
int findDownCard = 0; int findDownCard = 0;
@ -151,6 +170,11 @@ namespace OrderStacks.model.gameActions.decimals
}); });
} }
/**
* <param name="playableCard">Liste des cartes jouables</param>
*
* Fonction vérifiant que les règles de fin de jeu ne sont pas arrivé
*/
override protected bool testEndGame(List<Card> playableCard) override protected bool testEndGame(List<Card> playableCard)
{ {
if (playableCard.Count < 2) if (playableCard.Count < 2)

43
OrderStacks/model/gameActions/fraction/GameModeFraction.cs
Unescape View File

@ -10,10 +10,22 @@ namespace OrderStacks.model.gameActions.fraction
{ {
public class GameModeFraction : GameMode public class GameModeFraction : GameMode
{ {
/**
* <param name="deck">Deck de carte</param>
* <param name="piles">Piles du jeu</param>
*
* Constructeur
*/
public GameModeFraction(Piles piles, Deck deck) : base(piles, deck) public GameModeFraction(Piles piles, Deck deck) : base(piles, deck)
{ {
} }
/**
* <param name="nbPlayer">Nombre de joueur</param>
* <param name="players">Pseudo du/des joueur(s)</param>
*
* Fonction permettant de charger les paramètres de jeu
*/
override public void load(int nbPlayer, List<Player> players) override public void load(int nbPlayer, List<Player> players)
{ {
gameActions.Add(new PiocherClassic(Piles)); gameActions.Add(new PiocherClassic(Piles));
@ -24,6 +36,12 @@ namespace OrderStacks.model.gameActions.fraction
distribueCard(players); distribueCard(players);
} }
/**
* <param name="currentHand">Liste de carte du joueur actif</param>
* <param name="player">Joueur actif</param>
*
* Fonction permettant au joueur actif de piocher une carte
*/
override public void pioche(List<Card> currentHand, Player player) override public void pioche(List<Card> currentHand, Player player)
{ {
Message = ""; Message = "";
@ -31,6 +49,17 @@ namespace OrderStacks.model.gameActions.fraction
quickSort(currentHand, 0, currentHand.Count - 1); quickSort(currentHand, 0, currentHand.Count - 1);
} }
/**
* <param name="player">Joueur actif</param>
* <param name="currentHand">Liste de carte du joeuur actif</param>
* <param name="CurrentCardPlayed">Liste des cartes jouées durant le tour du joueur actif</param>
* <param name="orderedStackSelected">Pile séléctionnée</param>
* <param name="valueCard">Valeur de la carte en train d'être joué</param>
*
* Fonction permettant de tenter de jouer une carte
*
* <returns>Booléen de carte joué</returns>
*/
override public bool playCard(decimal valueCard, List<Card> currentHand, int orderedStackSelected, Player player, List<Card> CurrentCardPlayed) override public bool playCard(decimal valueCard, List<Card> currentHand, int orderedStackSelected, Player player, List<Card> CurrentCardPlayed)
{ {
Message = ""; Message = "";
@ -48,6 +77,15 @@ namespace OrderStacks.model.gameActions.fraction
} }
} }
/**
* <param name="currentHand">Liste de carte du joueur actif</param>
* <param name="CurrentCardPlayed">Liste des cartes jouées durant le tour du joueur actif</param>
* <param name="player">Joueur actif</param>
*
* Fonction permettant de lancer la fin du tour et de vérifier la fin du jeu
*
* <returns>Booléen de fin de jeu</returns>
*/
override public bool endTurn(List<Card> currentHand, List<Card> CurrentCardPlayed, Player player) override public bool endTurn(List<Card> currentHand, List<Card> CurrentCardPlayed, Player player)
{ {
Message = ""; Message = "";
@ -65,6 +103,11 @@ namespace OrderStacks.model.gameActions.fraction
} }
} }
/**
* <param name="currentHand">Liste de carte du joueur actif</param>
*
* Fonction permettant de vérifier si c'est la fin du jeu
*/
override public void TestEndGame(List<Card> currentHand) override public void TestEndGame(List<Card> currentHand)
{ {
if (((TerminerSonTourFraction)gameActions[2]).Test(currentHand)) if (((TerminerSonTourFraction)gameActions[2]).Test(currentHand))

27
OrderStacks/model/gameActions/fraction/JouerUneCarteFraction.cs
Unescape View File

@ -9,10 +9,26 @@ namespace OrderStacks.model.gameActions.fraction
{ {
public class JouerUneCarteFraction : JouerUneCarte public class JouerUneCarteFraction : JouerUneCarte
{ {
/**
* <param name="listOrderedStacks">Piles de jeu</param>
*
* Constructeur
*/
public JouerUneCarteFraction(Piles ListOrderedStacks) : base(ListOrderedStacks) public JouerUneCarteFraction(Piles ListOrderedStacks) : base(ListOrderedStacks)
{ {
} }
/**
* <param name="player">Joueur actif</param>
* <param name="currentHand">Liste de carte du joeuur actif</param>
* <param name="CurrentCardPlayed">Liste des cartes jouées durant le tour du joueur actif</param>
* <param name="orderedStackSelected">Pile séléctionnée</param>
* <param name="valueCard">Valeur de la carte en train d'être joué</param>
*
* Fonction permettant de tenter de jouer une carte
*
* <returns>Booléen de carte joué</returns>
*/
override public bool play(decimal valueCard, List<Card> CurrentHand, int orderedStackSelected, Player player, List<Card> CurrentCardPlayed) override public bool play(decimal valueCard, List<Card> CurrentHand, int orderedStackSelected, Player player, List<Card> CurrentCardPlayed)
{ {
foreach (Card card in CurrentHand) foreach (Card card in CurrentHand)
@ -48,6 +64,17 @@ namespace OrderStacks.model.gameActions.fraction
return false; return false;
} }
/**
* <param name="player">Joueur actif</param>
* <param name="CurrentCardPlayed">Liste des cartes jouées durant le tour du joueur actif</param>
* <param name="bottomUp">Booléen d'ascendance</param>
* <param name="card">Carte joué</param>
* <param name="stack">Pile joué</param>
*
* Fonction permettant de tenter de jouer une carte
*
* <returns>Booléen de carte joué</returns>
*/
override protected bool Rule(Card card, Stack<Card> stack, bool bottomUp, Player player, List<Card> CurrentCardPlayed) override protected bool Rule(Card card, Stack<Card> stack, bool bottomUp, Player player, List<Card> CurrentCardPlayed)
{ {
if ((bottomUp && card.Value > stack.Peek().Value) || (!bottomUp && card.Value < stack.Peek().Value)) if ((bottomUp && card.Value > stack.Peek().Value) || (!bottomUp && card.Value < stack.Peek().Value))

24
OrderStacks/model/gameActions/fraction/TerminerSonTourFraction.cs
Unescape View File

@ -9,10 +9,23 @@ namespace OrderStacks.model.gameActions.fraction
{ {
public class TerminerSonTourFraction : TerminerSonTour public class TerminerSonTourFraction : TerminerSonTour
{ {
/**
* <param name="listOrderedStacks">Piles de jeu</param>
*
* Constructeur
*/
public TerminerSonTourFraction(Piles ListOrderedStacks) : base(ListOrderedStacks) public TerminerSonTourFraction(Piles ListOrderedStacks) : base(ListOrderedStacks)
{ {
} }
/**
* <param name="CurrentHand">Liste de carte du joeuur actif</param>
* <param name="CurrentCardPlayed">Liste des cartes jouées durant le tour du joueur actif</param>
*
* Fonction permettant de terminer son tour
*
* <returns>Booléen indiquant si le changement de joueur peut se passer</returns>
*/
public override bool end(List<Card> CurrentHand, List<Card> CurrentCardPlayed) public override bool end(List<Card> CurrentHand, List<Card> CurrentCardPlayed)
{ {
if (CurrentHand.Count == 0 || CurrentCardPlayed.Count >= 2) if (CurrentHand.Count == 0 || CurrentCardPlayed.Count >= 2)
@ -27,6 +40,11 @@ namespace OrderStacks.model.gameActions.fraction
} }
} }
/**
* <param name="playableCard">Liste des cartes jouables</param>
*
* Fonction vérifiant que les règles de fin de jeu ne sont pas arrivé
*/
protected override bool testEndGame(List<Card> playableCard) protected override bool testEndGame(List<Card> playableCard)
{ {
if (playableCard.Count < 2) if (playableCard.Count < 2)
@ -36,6 +54,12 @@ namespace OrderStacks.model.gameActions.fraction
return true; return true;
} }
/**
* <param name="CurrentHand">Liste de carte du joueur actif</param>
* <param name="playableCard">Liste des cartes jouables</param>
*
* Fonction permettant de chercher les cartes pouvants être jouées et les ajoutes à la liste des cartes jouables
*/
protected override void tryToFindSoluce(List<Card> playableCard, List<Card> CurrentHand) protected override void tryToFindSoluce(List<Card> playableCard, List<Card> CurrentHand)
{ {
int findMultipleCard = 0; int findMultipleCard = 0;

1
OrderStacks/view/MainPage.xaml.cs
Unescape View File

@ -182,7 +182,6 @@ namespace OrderStacks.view
break; break;
case TouchActionType.Released: case TouchActionType.Released:
break;
case TouchActionType.Cancelled: case TouchActionType.Cancelled:
if (textDictionary.ContainsKey(args.Id)) if (textDictionary.ContainsKey(args.Id))

Write Preview
Loading…
Cancel
Save