' lighness1024! programmatO EURL 23/4/2
' programme d'apprentissage

' on cr‚‚ un TYPE DE VARIABLE PERSONNALISE
' un type de variable personnalis‚ est en fait une composition
' de plusieurs variables de type de base
TYPE Joueur
    x AS INTEGER
    y AS INTEGER
    score AS LONG
END TYPE
' apres avoir cr‚‚ un type on va d‚clarer un tableau de variable de ce type
DIM j(0 TO 1) AS Joueur
' a partir d'ici j'ai cr‚‚ un tableau de 2 ‚l‚ments (0 et 1)
' du type de variable Joueur
' par exemple pour acceder a la variable y du joueur 1
' j(0).y = MachinTruc
' ou alors au points du joueur 2:
' if j(1).score >= 2000
' Si ca n'avais pas ‚t‚ un tableau il aurait fallu faire ceci:
' DIM toto as Joueur
' et on aurait acc‚d‚ comme ceci:
' toto.x = 50
' etc....

' on est pas oblig‚ de cr‚‚ des types, par exemple pour g‚rer les coordonn‚es
' et la direction de d‚placement de la balle je vais utiliser des variables
' isol‚es non d‚clar‚es ke je vais initialiser plus bas dans le programme
' (juste avant la boucle principale DO LOOP)

'on passe en mose d'ecran 13 320*200*8 (8bits = 256 couleurs)
SCREEN 13
' ensuite on affiche menu avec une tabulation cr‚e par la virgule
PRINT , "Menu"
' locate permet de fixer la position du curseur a
' l'endroit en ligne, colonne ou on le veu dans l'ecran
LOCATE 5  ' on pourrait aussi ecrire LOCATE 3, 1
'passe en rouge (les 16 premieres couleurs sont classiques:
' 0: noir   0+8: gris fonc‚
' 1: bleu   1+8: bleu clair
' 2: vert   2+8: vert clair
' 3: cyan   3+8: cyan clair
' 4: rouge  4+8: rouge clair
' 5: rose   5+8: rose clair
' 6: marron 6+8: jaune
' 7: gris   15: blanc
COLOR 4
PRINT "pressez une touche pour lancer le jeu"
PRINT "si vous ratez 20 fois vous perdez !"
' attendre l'appui sur une touche
SLEEP
' effacer l'ecran
CLS
' on fait une mini benchmark pour regler a peu pres la pause:
' on enregistre le temps dans t ("t" tout court est une variable single
' equivalent a "t!")
t = TIMER
' on fait une boucle vide j'uska une position fixe (1000000)
PRINT "benchmark en cours..."
FOR pause# = 0 TO 1000000
NEXT
' on calcul le delta temps (delta temps = t2 - t1)
dt = TIMER - t
IF dt = 0 THEN
    ' si on chope 0 c ke ya pas eu de temps pour faire la boucle
    PRINT "ordi trop puissant bye bye"
    SLEEP
    SYSTEM
END IF
' on prend l'inverse du temps pour faire une pause plus longue
' dans le jeu plus l'ordi est rapide.
temps# = (15000 / dt)   ' (15000 est un ajustement)

'efface l'ecran
CLS
' on initialise les positions des barres:
'ordi:
j(0).x = 320 / 2 - 10
j(0).y = 20
' joueur
j(1).x = 320 / 2 - 10   ' la largeur de la barre = 20 donc pour centrer
                        ' il faut enlever 20/2 a la position x
                        ' car la position x correspond au coin sup‚rieur
                        ' gauche de la barre
                        ' 320 = largeur de l'ecran
j(1).y = 180
' les scores sont a 0 par defaut
'variables de la balle:
bx% = 320 / 2
by% = 100     ' moiti‚ de l'ecran en hauteur. la balle fait 1 pixel
directionX% = 0   ' vers le joueur 0 (ordi)
DirectionY% = 1   ' vers la droite

'demarrer une boucle
' cette boucle va etre la boucle principale du programme
' a chaque passage on va verifier si il y a une touche
' et si oui on va faire qqch en cons‚quence (changer les coordonn‚es par
' exemple)
DO
    ' inkey$ renvoie le buffer clavier et le vide
    ' le buffer clavier est un espace memoire contenant toute les touches
    ' appuy‚es jusqu'a qu'on vienne le lire et le vider
    ' si on presse une touche alphanumerique la chaine k$ fera 1 octet
    ' si on presse une touche de controle (touches de direction...)
    ' la chaine fera 2 octets

    k$ = INKEY$

    ' au permier passage de la boucle ceci ne sert a rien
    ' mais au prochains passage cela servira a effacer les palette au cas
    ' ou le joueur la d‚place on ne verra plus l'ancienne position
    ' on dessine en noir pour effacer.
    ' voir en bas de la boucle pour mieu comprendre ces fonctions
    LINE (j(0).x, j(0).y)-STEP(20, 3), 0, BF
    LINE (j(1).x, j(1).y)-STEP(20, 3), 0, BF
    PSET (bx%, by%), 0
    IF LEN(k$) THEN
        ' si on a appuy‚ sur une touche
        ' on met right$ pour r‚cuperer le dernier caractere de la chaine
        ' (au cas ou elle fasse 2 caracteres)
        ' ASC retourne le Numero du caractere en ASCII
        ' voir l'aide a "ASCII char table"
        SELECT CASE ASC(RIGHT$(k$, 1))
        ' select case permet d'executer seulement le code
        ' correspondant a la valeur de la variable asc(k$)
        ' si asc(k$) = 27 alors le code en dessous de CASE 27 sera execut‚
        ' jusqu'au prochain CASE ou jusqu'au END SELECT
        ' la valeur qu'il regarde est celle que l'on a mis apres SELECT CASE
        ' ici ASC(RIGHT$(k$, 1)) (ce qui permet d'avoir le code ASCII)
        CASE 77
        ' touche droite
            ' on augmente de 8 pixels pour faire d‚placer la barre
            j(1).x = j(1).x + 8
            ' on empeche de d‚passer les bords
            IF j(1).x > 300 THEN j(1).x = 300
        CASE 75
        ' touche gauche
            ' on diminue
            j(1).x = j(1).x - 8
            IF j(1).x < 0 THEN j(1).x = 0
            ' le principe pour eviter de d‚passer le bord de l'ecran
            ' est de fixer la limite de coordonn‚e a 300 pixels de la gauche
            ' (origine) car la palette fait 20 pixels et la largeur
            ' de l'ecran 320.
        CASE 27
        ' echap
        ' system agit comme END et arrete le programme
        SYSTEM
        ' fin du QuelleTouche?(key$)
        END SELECT
        ' le gros probleme avec inkey$ c'est qu'il d‚pend de la rapidit‚
        ' de r‚p‚tition des touches r‚lgl‚e dans le driver le clavier
    ' fin du SI(touche appuy‚e)
    END IF

    ' dans cette zone du programme meme si on a pas touch‚ au clavier
    ' le code est execut‚ de toute maniere
    ' car nous ne somme pas dans un bloc conditionnel (IF ou SELECT CASE)
    ' nous somme dans un bloc d'une boucle DO LOOP
    ' donc ce code sera execut‚ plusieurs fois, et meme pr‚cis‚ment
    ' a chaque tour de boucle
    
    ' la balle ne s'arrete jamais donc on va g‚rer les d‚placements ici:
    ' on la d‚place de 3 pixels en 3.
    IF directionX% = 0 THEN
        bx% = bx% - 1
    ELSEIF directionX% = 1 THEN
        bx% = bx% + 1
    END IF
    IF DirectionY% = 0 THEN
        by% = by% - 1
    ELSEIF DirectionY% = 1 THEN
        by% = by% + 1
    END IF
    
    'detection des collisions:
    IF bx% >= 320 THEN
        ' la balle touche le bord droit de l'ecran
        ' on inverse la direction
        directionX% = 0
    ELSEIF bx% <= 0 THEN   ' elseif permet d'etre d‚pendant du IF d'au dessus
                           ' si le if du dessus est execut‚, ce elseif ne sera
                           ' pas execut‚ (en aucun cas) meme si dans
                           ' le bloc du dessus on mettai -50 dans bx%
                           ' ( ce qui est <= 0 donc qui pourrait faire marcher
                           ' ce bloc, mais etant donn‚ que c'est un elseif et
                           ' bien non).
        directionX% = 1
    END IF
    ' by est ind‚pendant donc on fait un autre bloc IF END IF
    IF by% >= 200 THEN
        ' la balle touche le bord droit de l'ecran
        ' on inverse la direction
        DirectionY% = 0
        ' on augmente le score du joueur 0:
        j(0).score = j(0).score + 1
    ELSEIF by% <= 0 THEN
        DirectionY% = 1
        j(1).score = j(1).score + 1
    END IF
    'detection des collisions avec les joueurs:
    FOR verif% = 0 TO 1
        ' on v‚rifie les 2 joueurs dans une boulce
        ' pour avoir un code plus court
        ' plus flexible, et ceci est possible uniquement
        ' parce ke les joueurs sont un tableau !
        IF bx% >= j(verif%).x AND bx% <= j(verif%).x + 20 AND by% >= j(verif%).y AND by% <= j(verif%).y + 3 THEN
            ' la balle est sur la barre d'un joueur
            ' alors on fait rebondir en fonction de l'ancienne direction
            IF DirectionY% = 0 THEN DirectionY% = 1 ELSE DirectionY% = 0
        END IF
    NEXT

    ' intelligence artificielle:
    ' limiter la vitesse de d‚placement:
    IF (TIMER - tempo) > .01 THEN   ' a 3 pixels toutes les 10 millisecondes
        tempo = TIMER
        ' si  la balle d‚borde, il faut la suivre !
        IF bx% < j(0).x THEN bouge% = -1   'gauche   (n'y voyez rien de politique :)
        IF bx% > j(0).x + 20 THEN bouge% = 1  'droite
        ' le probleme c ke si on la rat‚e, il ne faut pas la bloquer SOUS nous !
        IF by% + 15 > j(0).y THEN
            ' on va au bon endroit:
            j(0).x = j(0).x + 5 * bouge%
        ELSE
            'on inverse la direction:
            j(0).x = j(0).x - 5 * bouge%
        END IF
    END IF
    ' empecher de d‚border:
    IF j(0).x <= 0 THEN j(0).x = 0
    IF j(0).x >= 300 THEN j(0).x = 300

    ' on trace les rectangle (barres)
    ' line trace une ligne du point x1,y1 au point x2,y2
    ' si on rajoute STEP cela permet de donner des coordonn‚es
    ' relatives (sans STEP j'aurais du mette "j(0).x + 20" etc... (coordonn‚es absolues)
    ' si on rajoute BF on trace un rectangle plein au lieu d'une
    ' diagonale. 7 et 14 sont les couleurs
    ' le repere d'affichage est un repere cart‚sien
    ' o— le 0 est en haut a gauche.
    ' donc plus on augmente plus on descend
    LINE (j(0).x, j(0).y)-STEP(20, 3), 7, BF
    LINE (j(1).x, j(1).y)-STEP(20, 3), 14, BF
    ' pset dessine un simple pixel (ici la balle) en bleu 11.
    PSET (bx%, by%), 11

    ' si la balle a ‚t‚ perdue 20 fois dans l'un ou l'autre des camps
    IF j(0).score >= 20 OR j(1).score >= 20 THEN
        ' un des joueurs gagne !!!
        PRINT "Scores:"
        PRINT "ordi:"; j(0).score
        PRINT "vous:"; j(1).score
        IF j(0).score >= 20 THEN
            CLS
            PRINT "l'ordi gagne"
            SLEEP
            SYSTEM
        ELSE
            CLS
            PRINT "vous gagnez"
            SLEEP
            SYSTEM
        END IF
    END IF

    ' la technique de la boucle vide est plus pr‚cise que l'affreux TIMER
    ' cette boucle vide permet d'arreter un peu la boucle pendant un
    ' temps court de maniere a avoir une vitesse de jeu raisonable
    ' le # indique que pause est une variable DOUBLE a virgule
    ' flotante donc tres lente.
    ' temps# est d‚termin‚ plus haut avec la benchmark
    ' plus temps# sera grand plus la boucle sera longue
    ' donc plus l'ordi est puissant plus il faut attendre
    ' c'est pour ca ke l'on prenait l'inverse du temps
    FOR pause# = 0 TO temps#
    NEXT

LOOP   ' ici on retourne en haut au niveau du "DO"

' normalement ya pas moyen d'arriver ici vu ke pour quitter il faut
' taper ESC et j'ai mis SYSTEM sous le CASE 27
' ce qui arrete le programme a ce niveau la.
' pour venir ici il aurait fallu marquer EXIT DO
' cela aurait permis de continuer le programme ici apres avoir
' tap‚ ESC.