@echo off
setlocal EnableDelayedExpansion
title Morpion - Par Flammrock

rem On définit la taille de notre morpion (ici du 3x3)
set Morpion.Size=3

rem On définit le nombre de croix ou de ronds à aligner pour gagner (de base c'est 3)
set Morpion.AlignVictory=3

rem On appelle une "fonction" et on lui passe le nom de la variable qui contiendra toutes les données
call :Morpion.Create mon_objet_morpion !Morpion.Size! !Morpion.AlignVictory!

rem On dessine notre morpion
call :Morpion.Draw mon_objet_morpion

rem On définit le nombre de tour et on l'initialise à 0, on va l'augmenter de 1 à chaque fois qu'un joueur va jouer
set Morpion.Round=0



rem On définit nos 2 joueurs (on pourrait par exemple utiliser un set /p ici ;) )
rem [CODE]
rem
rem    set /p temp.name=Nom du Joueur 1:
rem    set /p temp.symbol=Symbole du Joueur 1:
rem    call :Morpion.Add_Player mon_objet_morpion "!temp.name!" "!temp.symbol!"
rem
rem    set /p temp.name=Nom du Joueur 2:
rem    set /p temp.symbol=Symbole du Joueur 2:
rem    call :Morpion.Add_Player mon_objet_morpion "!temp.name!" "!temp.symbol!"
rem
rem [/CODE]

rem comme c'est un "exemple", je met directe des noms de joueurs lol (pas le temps de niaiser)
call :Morpion.Add_Player mon_objet_morpion "Vimper" "X"
call :Morpion.Add_Player mon_objet_morpion "Flammrock" "O"
rem petite remarque: on pourrait ajouter autant de joueur que l'on veut xDDD





rem On va loop à l'infini jusqu'à ce qu'un des joueurs gagne (ou pas, s'il y a match nul)
:game

    rem On efface tout
    cls

    rem On affiche le tour actuel
    echo;Tour !Morpion.Round!

    rem On sélectionne le joueur qui doit jouer
    call :Morpion.Get_Player mon_objet_morpion mon_joueur !Morpion.Round!

    rem On dit c'est à qui de joueur
    echo;"!mon_joueur.name!" doit jouer (il a les "!mon_joueur.symbol!")

    rem On dessine la grille
    call :Morpion.Draw mon_objet_morpion

    rem On fait jouer le joueur en lui demandant à quel case il veut mettre son symbole
    call :Morpion.Play_Player mon_objet_morpion mon_joueur

    rem On capture l'erreur et on la traite suivant sa valeur
    if "%errorlevel%"=="1" (
        echo;[Erreur] Veuillez saisir un nombre positif valide de l'ID d'une case
    ) else if "%errorlevel%"=="2" (
        echo;[Erreur] Nombre trop grand
    ) else if "%errorlevel%"=="3" (
        echo;[Erreur] Case non vide
    )
    if not "%errorlevel%"=="0" (
        set /p ".=Appuyer sur une touche pour continuer de jouer..."<nul
        pause>nul
        goto :game
    )

    rem On vérifie l'état actuel du morpion,
    rem on check si toutes les cases sont pleines ou pas
    rem et on regarde s'il n'y a pas éventuellement un gagnant
    call :Morpion.Check mon_objet_morpion

    rem On regarde s'il y a un gagnant ou s'il y a match nul
    if "%errorlevel%"=="1" (
        rem Si on arrive là, c'est qu'un des joueurs a gagné, gg à lui xD

        rem On efface tout
        cls

        rem On affiche qui a gagné (on met pas le nom du joueur dans le cas où les joueurs jouent en équipent)
        rem On aurait pu mettre que le joueur "Vimper" avait les "O" comme le joueur "Flammrock" et dans ce cas, il aurait été dans
        rem la même équipe
        echo;Les "!mon_objet_morpion.Victory!" sont les gagnants
        echo;


    ) else if "%errorlevel%"=="2" (
        rem Par contre si on arrive là, c'est que c'est match nul

        rem On efface tout
        cls

        rem On affiche qui a gagné (on met pas le nom du joueur dans le cas où les joueurs jouent en équipent)
        rem On aurait pu mettre que le joueur "Vimper" avait les "O" comme le joueur "Flammrock" et dans ce cas, il aurait été dans
        rem la même équipe
        echo;MATCH NUL
        echo;

    )
    if not "%errorlevel%"=="0" (
        rem On dessine la grille
        call :Morpion.Draw mon_objet_morpion

        rem On demande si les joueurs veulent rejouer
        set /p "continue=Souhaitez-vous continuer ? (y/n)"

        if /i "!continue!"=="y" (
          rem Si on arrive là, les joueurs souhaitent rejouer
          rem donc on réinitialise le jeu
          call :Morpion.Reset mon_objet_morpion

          rem On n'oublie pas de reset les autres variables (bon y'en a qu'une ici mdr)
          set Morpion.Round=0

          rem Et hop, on retourne au label :game
          goto :game

        ) else (
           rem Sinon, on quitte
           exit
        )


    )



    rem On passe au tour suivant
    set /a Morpion.Round+=1

goto :game




rem On veut surtout pas arriver ici, si c'est le cas, on quitte directe pour ne pas faire planter le script
pause>nul&exit


:Morpion.Create <output:object> <input:size> <input:alignvictory>

    rem On définit la taille de notre morpion
    set %~1.Size=%~2

    rem On définit le nombre de croix à aligner pour gagner
    set %~1.AlignVictory=%~3

    rem On définit la longueur (les indices commencent généralement à 0, donc il faut prendre l'habitude dès maintenat ;) )
    set /a %~1.Length=%~2-1

    rem On défnit le nombre de joueur qu'il y aura, pour l'instant on met 0 car là il a pas de joueurs
    set %~1.Players.Length=0

    rem On remplie chaque case notre grille d'un espace
    call :Morpion.Reset "%~1"

    rem la fonction c'est terminé, on quitte la fonction
    rem et on revient là où on en était avant d'appeler cette "fonction" avec le call
exit /b 0


:Morpion.Reset <output:object>

    rem On créé notre grille avec les coordonnées x et y
    for /l %%y in (0,1,!%~1.Length!) do (
        for /l %%x in (0,1,!%~1.Length!) do (

            rem On initialise chaque case avec un espace (les ronds et les croix c'est pour plus tard)
            set "%~1.Grid[%%y][%%x]= "

        )
    )


    rem la fonction c'est terminé, on quitte la fonction
    rem et on revient là où on en était avant d'appeler cette "fonction" avec le call
exit /b 0



:Morpion.Draw <input:object>

    rem voici ce qu'on cherche à dessiner:
    rem ,-------,
    rem |       |
    rem |   X   |   . . .
    rem |       |
    rem '-------'
    rem    .
    rem    .
    rem    .

    rem L'indice de la case que l'on traite
    set index=1

    for /l %%y in (0,1,!%~1.Length!) do (

        rem On stocke d'abord tout dans cette variable
        rem (on dessine tout ça ligne par ligne, ici c'est case par case mais l'idée est la même)
        set line1=
        set line2=
        set line3=
        set line4=
        set line5=

        for /l %%x in (0,1,!%~1.Length!) do (

            rem Je pense que juste ça suffit (parce qu'un morpion à 1000 cases LOL)
            set "space=      "
            if !index! gtr 9 set "space=     "
            if !index! gtr 99 set "space=    "
            if !index! gtr 999 set "space=   "

            rem Rien que là, on arrive un voir la case et à voir un peu près à quoi ça va ressembler
            set "line1=!line1!,-------"
            set "line2=!line2!|!space!!index!"
            set "line3=!line3!|   !%~1.Grid[%%y][%%x]!   "
            set "line4=!line4!|       "
            set "line5=!line5!'-------"

            set /a index+=1

        )

        set "line1=!line1!,"
        set "line2=!line2!|"
        set "line3=!line3!|"
        set "line4=!line4!|"
        set "line5=!line5!'"

        rem On affiche la case
        echo;!line1!
        echo;!line2!
        echo;!line3!
        echo;!line4!


    )

    rem On affiche la ligne 5 ici car la ligne 1 fait déjà office du bas (par répétition)
    echo;!line5!


    rem la fonction c'est terminé, on quitte la fonction
    rem et on revient là où on en était avant d'appeler cette "fonction" avec le call
exit /b 0



:Morpion.Add_Player <output:object> <input:name> <input:symbol>

    rem On ajoute notre joueur
    set "%~1.Players[!%~1.Players.Length!].name=%~2"
    set "%~1.Players[!%~1.Players.Length!].symbol=%~3"

    rem On incrémente de 1 le nombre de joueurs
    set /a %~1.Players.Length+=1

    rem la fonction c'est terminé, on quitte la fonction
    rem et on revient là où on en était avant d'appeler cette "fonction" avec le call
exit /b 0


:Morpion.Get_Player <output:object> <output:object_player> <input:round>

    rem C'est juste un peu de math, c'est de l'arithmétique modulaire
    rem (un truc que l'on utilise tout les jours sans qu'on s'en rende compte)
    set /a temp.ID=%~3 %% !%~1.Players.Length!

    rem On transforme la variable temp.ID en %%i (petite astuce c'est cadeau)
    for %%i in ("!temp.ID!") do (

        rem On copie l'objet et on le met dans l'objet
        rem que l'on doit renvoyer (je sais pas si t'es à l'aise avec ce genre de voca)
        set %~2.name=!%~1.Players[%%~i].name!
        set %~2.symbol=!%~1.Players[%%~i].symbol!

    )



    rem la fonction c'est terminé, on quitte la fonction
    rem et on revient là où on en était avant d'appeler cette "fonction" avec le call
exit /b 0


:Morpion.Play_Player <output:object> <output:object_player>

    rem On demande au joueur de rentrer l'ID d'une case
    set /p temp.input=ID Case:

    rem On vérifie s'il s'agit d'un nombre positif
    set /a temp.input=!temp.input!-1

    rem Si c'est pas un nombre positif, on retourne une erreur qui sera "capturer" dans la "boucle infinie" du jeu xDD
    if "!temp.input!"=="-1" exit /b 1

    rem On vérifie que ce nombre rentré est inférieur au nombre de case
    set /a temp.size=!%~1.Size!*!%~1.Size!
    if !temp.input! geq !temp.size! exit /b 2

    rem On convertit l'indice de la case en coordonnées x et y
    set /a temp.X=!temp.input! %% !%~1.Size!
    set /a temp.Y=!temp.input! / !%~1.Size!


    for %%x in ("!temp.X!") do for %%y in ("!temp.Y!") do (

        rem Si la case n'est pas vide, on retourne une erreur
        if not "!%~1.Grid[%%~y][%%~x]!"==" " exit /b 3

        rem Si on arrive là, on peut supposer que tout est correct
        rem et donc on met dans la case le symbole du joueur qui est entrain de jouer
        set "%~1.Grid[%%~y][%%~x]=!%~2.symbol!"

    )


    rem la fonction c'est terminé, on quitte la fonction
    rem et on revient là où on en était avant d'appeler cette "fonction" avec le call
exit /b 0



:Morpion.Check <output:object>

    rem On vérifie tout d'abord si toutes les cases du morpion sont déjà pleines, dans ce cas c'est match nul
    rem et on renvoie 2
    set index=0
    for /l %%y in (0,1,!%~1.Length!) do (

        for /l %%x in (0,1,!%~1.Length!) do (

            rem On compte chaque case vide
            if "!%~1.Grid[%%y][%%x]!"==" " set /a index+=1

        )

    )

    rem Si la variable index est égale à 0, c'est qu'il n'y pas plus de cases vides,
    rem donc aucun des joueurs peu jouer, donc la partie fini sur une nul
    if "!index!"=="0" exit /b 2

    rem On vérifie d'abord sur les lignes
    rem [X][X][X] . . . .
    rem [O][O][O]
    rem [V][V][V]
    rem  .        .
    rem  .          .
    rem  .            .
    rem  .              .
    for /l %%y in (0,1,!%~1.Length!) do (

        set temp.victory.symbol=
        set temp.victory.count=0

        for /l %%x in (0,1,!%~1.Length!) do (

            if "!%~1.Grid[%%y][%%x]!"==" " (
               set temp.victory.symbol=
               set temp.victory.count=0
            ) else if "!%~1.Grid[%%y][%%x]!"=="!temp.victory.symbol!" (
                set /a temp.victory.count+=1
            ) else (
                set temp.victory.count=1
                set "temp.victory.symbol=!%~1.Grid[%%y][%%x]!"
            )

        )

        rem Si on a compté successivement un nombre de fois le même symbole supérieur ou égale à !%~1.AlignVictory!, alors
        rem le ou les joueurs correspondant à ce symbole ont gagné
        if !temp.victory.count! geq !%~1.AlignVictory! (
            set "%~1.Victory=!temp.victory.symbol!"
            exit /b 1
        )

    )

    rem Si on arrive là, c'est qu'il n'y pas encore de gagnants
    rem Du coup on vérifie sur les colonnes
    rem [X][o][v] . . . .
    rem [x][O][v]
    rem [x][o][V]
    rem  .        .
    rem  .          .
    rem  .            .
    rem  .              .
    for /l %%x in (0,1,!%~1.Length!) do (

        set temp.victory.symbol=
        set temp.victory.count=0

        for /l %%y in (0,1,!%~1.Length!) do (

            if "!%~1.Grid[%%y][%%x]!"==" " (
               set temp.victory.symbol=
               set temp.victory.count=0
            ) else if "!%~1.Grid[%%y][%%x]!"=="!temp.victory.symbol!" (
                set /a temp.victory.count+=1
            ) else (
                set temp.victory.count=1
                set "temp.victory.symbol=!%~1.Grid[%%y][%%x]!"
            )

        )

        rem Si on a compté successivement un nombre de fois le même symbole supérieur ou égale à !%~1.AlignVictory!, alors
        rem le ou les joueurs correspondant à ce symbole ont gagné
        if !temp.victory.count! geq !%~1.AlignVictory! (
            set "%~1.Victory=!temp.victory.symbol!"
            exit /b 1
        )

    )

    rem Et si on est toujours là (oui monsieur), ba on en profite pour vérifier les diagonals
    for /l %%y in (0,1,!%~1.Length!) do (

        for /l %%x in (0,1,!%~1.Length!) do (

            set temp.victory.symbol=
            set temp.victory.count=0

            set temp.X=%%x
            set temp.Y=%%y

            rem On check les diagonales descendantes
            rem [X][ ][ ] . . . .
            rem [ ][X][ ]
            rem [ ][ ][X]
            rem  .        .
            rem  .          .
            rem  .            .
            rem  .              .
            for /l %%i in (1,1,!%~1.AlignVictory!) do (


                for %%w in ("!temp.Y!") do for %%v in ("!temp.X!") do (

                    if "!%~1.Grid[%%~w][%%~v]!"=="" (
                        set temp.victory.symbol=
                        set temp.victory.count=0
                    ) else if "!%~1.Grid[%%~w][%%~v]!"==" " (
                        set temp.victory.symbol=
                        set temp.victory.count=0
                    ) else if "!%~1.Grid[%%~w][%%~v]!"=="!temp.victory.symbol!" (
                        set /a temp.victory.count+=1
                    ) else (
                        set temp.victory.count=1
                        set "temp.victory.symbol=!%~1.Grid[%%~w][%%~v]!"
                    )

                )
                set /a temp.X+=1
                set /a temp.Y+=1

            )

            rem Si on a compté successivement un nombre de fois le même symbole supérieur ou égale à !%~1.AlignVictory!, alors
            rem le ou les joueurs correspondant à ce symbole ont gagné
            if !temp.victory.count! geq !%~1.AlignVictory! (
                set "%~1.Victory=!temp.victory.symbol!"
                exit /b 1
            )


            set temp.victory.symbol=
            set temp.victory.count=0

            set temp.X=%%x
            set temp.Y=%%y

            rem On check les diagonales ascendantes
            rem . . . . [ ][ ][X]
            rem         [ ][X][ ]
            rem         [X][ ][ ]
            rem        .       .
            rem      .         .
            rem    .           .
            rem  .             .
            for /l %%i in (1,1,!%~1.AlignVictory!) do (

                for %%w in ("!temp.Y!") do for %%v in ("!temp.X!") do (

                    if "!%~1.Grid[%%~w][%%~v]!"=="" (
                        set temp.victory.symbol=
                        set temp.victory.count=0
                    ) else if "!%~1.Grid[%%~w][%%~v]!"==" " (
                        set temp.victory.symbol=
                        set temp.victory.count=0
                    ) else if "!%~1.Grid[%%~w][%%~v]!"=="!temp.victory.symbol!" (
                        set /a temp.victory.count+=1
                    ) else (
                        set temp.victory.count=1
                        set "temp.victory.symbol=!%~1.Grid[%%~w][%%~v]!"
                    )

                )

                set /a temp.X-=1
                set /a temp.Y+=1

            )

            rem Si on a compté successivement un nombre de fois le même symbole supérieur ou égale à !%~1.AlignVictory!, alors
            rem le ou les joueurs correspondant à ce symbole ont gagné
            if !temp.victory.count! geq !%~1.AlignVictory! (
                set "%~1.Victory=!temp.victory.symbol!"
                exit /b 1
            )

        )

    )


    rem la fonction c'est terminé, on quitte la fonction
    rem et on revient là où on en était avant d'appeler cette "fonction" avec le call
exit /b 0