[..] Gui Par dessus tout.

[zesteph]

bonjour
as tu pu faire fonctionné ton script?
car j'ai le meme soucis que toi et je bloque malgrés les recherches

[ZDS]

Bonjour,

C'est peut être pas une bonne idée de déterrer un topic dont les derniers messages expliquent que ce n'est pas possible, tout simplement à cause de la façon dont Windows gère les programmes (à l'écran) en plein écran avec traitement par la CG (si tu vois "Plein-écran", "DirectX" et "3D", pas la peine d'aller plus loin, c'est pas possible de passer par dessus avec une simple GUI).

La seule façon de piloter un processus depuis un jeu tel que Counter Strike est par les raccourcis clavier, et uniquement si derrière tu ne t'amuses pas à faire de l'affichage (un chargement de GUI ou même un simple MsgBox te réduira le jeu dans la barre des tâches et le mettra en pause - ou pas - tant que ton script sera au premier plan). Mais bon ça limite pas mal les choses, et on se retrouve avec des choses comme des bots (va voir ailleurs tout de suite ^^), ou du TS (autant utiliser TS dans ce cas) ou encore du log bête et méchant => Utilité d'un tel script : quasi nulle (j'insiste sur le quasi ^^).

L'autre méthode qui ne posera pas de souci est de lancer CS dans un mode fenêtré. Là tu n'auras plus de souci à gérer tes premiers/derniers plans entre les fenêtres (CS et ton script seront tous deux gérés pareils par Windows). Mais bon, si c'est comme le premier Counter ou les UnReal Tournament, bonjour le rafraichissement pourri

A bientôt.

[zesteph]

CS n'est pas le seul jeu sur terre mais ce post correspond a ce que je cherche pour league of legends (avoir un overlay d'information de timer pendant le jeu)
et sur toutes mes recherches, ce post correspond le plus à mes questions.

sur des sites us autoit, ils parlent d api directx, et comme la communauté fr est efficace, je demande ici, car labas pas plus d info.

merci quand meme.

[ZDS]

Re,

je me doutais bien qu'il s'agissait d'informations ou de log de ce style (mais autant décourager les boters ^^). Comme dit, il faut donc se pencher sur le coté DX. Si (comme moi) tu as la flemme, l'alternative serait de ne pas utiliser de fenêtre à ton script (pas une GUI classique en tout cas), cf l'exemple de code "Clock.au3" fourni dans les exemples avancés GUI AutoIt :

► Afficher le texteClock.au3

Code : Tout sélectionner

#include <GDIPlus.au3>
#include <WinAPI.au3>
#include <GuiConstantsEx.au3>
#include <WindowsConstants.au3>

Opt("MustDeclareVars", 1)

; ===============================================================================================================================
; Description ...: Simple clock using layered windows
; Author ........: Paul Campbell (PaulIA)
; Notes .........:
; ===============================================================================================================================

; ===============================================================================================================================
; Global constants
; ===============================================================================================================================

Global Const $iCenter           = 200
Global Const $iDotOpacity       = 250
Global Const $iHourRad          = 140
Global Const $iMinRad           = 200
Global Const $iOpacity          = 128
Global Const $nPI               = 3.1415926535897932384626433832795
Global Const $iRadius           = 200
Global Const $iSecRad           = 200
Global Const $iTickLen          = 0.02

Global Const $AC_SRC_ALPHA      = 1

Global Enum $eScrDC=0, $eMemDC, $eBitmap, $eWidth, $eHeight, $eGraphic, $ePen, $eCap, $eBrush, $eFormat, $eFamily, $eFont, $eLayout, $eLast

; ===============================================================================================================================
; Global variables
; ===============================================================================================================================

Global $hDial, $hTime, $hHour, $hMin, $hSec, $hDot, $aTime, $aHour, $aMin, $aSec, $aCurr[3][2], $aLast[3][2]

; ===============================================================================================================================
; Main
; ===============================================================================================================================

ClockInit()
DialDraw ()
Draw     ()
DotDraw  ()
ClockLoop()
ClockDone()

; ===============================================================================================================================
; Finalize clock
; ===============================================================================================================================
Func ClockDone()
  ; Finalize GDI+ resources
  TimeDone()
  HourDone()
  MinDone ()
  SecDone ()

  ; Finalize GDI+ library
  _GDIPlus_Shutdown()
EndFunc

; ===============================================================================================================================
; Initialize clock
; ===============================================================================================================================
Func ClockInit()
  Local $iX, $iY

  ; Calculate the dial frame caption size
  $iX = -(_WinAPI_GetSystemMetrics($SM_CXFRAME))
  $iY = -(_WinAPI_GetSystemMetrics($SM_CYCAPTION) + _WinAPI_GetSystemMetrics($SM_CYFRAME))

  ; Allocate the window resources
  $hDial = GUICreate("Clock", $iRadius * 2, $iRadius * 2,  -1,  -1, 0, BitOR($WS_EX_LAYERED, $WS_EX_TOPMOST))
  GUISetState()
  $hTime = GUICreate("Time" , $iRadius * 2, $iRadius * 2, $iX, $iY, 0, BitOR($WS_EX_LAYERED, $WS_EX_MDICHILD), $hDial)
  GUISetState()
  $hHour = GUICreate("Hour" , $iRadius * 2, $iRadius * 2, $iX, $iY, 0, BitOR($WS_EX_LAYERED, $WS_EX_MDICHILD), $hDial)
  GUISetState()
  $hMin  = GUICreate("Min"  , $iRadius * 2, $iRadius * 2, $iX, $iY, 0, BitOR($WS_EX_LAYERED, $WS_EX_MDICHILD), $hDial)
  GUISetState()
  $hSec  = GUICreate("Sec"  , $iRadius * 2, $iRadius * 2, $iX, $iY, 0, BitOR($WS_EX_LAYERED, $WS_EX_MDICHILD), $hDial)
  GUISetState()
  $hDot  = GUICreate("Dot"  , $iRadius * 2, $iRadius * 2, $iX, $iY, 0, BitOR($WS_EX_LAYERED, $WS_EX_MDICHILD), $hDial)
  GUISetState()

  ; Initialize GDI+ library
  _GDIPlus_Startup()

  ; Initialize GDI+ resources
  TimeInit()
  HourInit()
  MinInit ()
  SecInit ()

  ; Hook non client hit test message so we can move the clock
  GUIRegisterMsg($WM_NCHITTEST, "WM_NCHITTEST")
EndFunc

; ===============================================================================================================================
; Loop until user exits
; ===============================================================================================================================
Func ClockLoop()
  do
    Draw()
  until GUIGetMsg() = $GUI_EVENT_CLOSE
EndFunc

; ===============================================================================================================================
; Draw the center dot
; ===============================================================================================================================
Func DotDraw()
  Local $aDot

  $aDot = ResourceInit($iRadius * 2, $iRadius * 2)
  _GDIPlus_GraphicsFillEllipse($aDot[$eGraphic], $iRadius-10, $iRadius-10, 20, 20)
  ResourceSet ($hDot, $aDot, $iDotOpacity)
  ResourceDone($aDot)
EndFunc

; ===============================================================================================================================
; Draw the clock elements
; ===============================================================================================================================
Func Draw()
  ; Calculate current time element position
  $aLast = $aCurr
  $aCurr[0][0] = $iCenter + Cos(TimeToRadians("sec" )) * $iSecRad
  $aCurr[0][1] = $iCenter - Sin(TimeToRadians("sec" )) * $iSecRad
  $aCurr[1][0] = $iCenter + Cos(TimeToRadians("min" )) * $iMinRad
  $aCurr[1][1] = $iCenter - Sin(TimeToRadians("min" )) * $iMinRad
  $aCurr[2][0] = $iCenter + Cos(TimeToRadians("hour")) * $iHourRad
  $aCurr[2][1] = $iCenter - Sin(TimeToRadians("hour")) * $iHourRad

  ; Draw time elements
  TimeDraw()
  HourDraw()
  MinDraw ()
  SecDraw ()
EndFunc

; ===============================================================================================================================
; Draw the clock dial
; ===============================================================================================================================
Func DialDraw()
  Local $aDial, $hPen1, $hPen2, $iI, $iN, $iX1, $iY1, $iX2, $iY2

  $aDial = ResourceInit($iRadius * 2, $iRadius * 2)
  $hPen1 = _GDIPlus_PenCreate()
  $hPen2 = _GDIPlus_PenCreate(0xFF0000FF, 4)
  for $iI = 0 to 2 * $nPI Step $nPI / 30
    $iX1 = $iCenter + Cos($iI) * ($iRadius * (1.00 - $iTickLen))
    $iY1 = $iCenter - Sin($iI) * ($iRadius * (1.00 - $iTickLen))
    $iX2 = $iCenter + Cos($iI) * $iRadius
    $iY2 = $iCenter - Sin($iI) * $iRadius
    if Mod($iN, 5) = 0 then
      _GDIPlus_GraphicsDrawLine($aDial[$eGraphic], $iX1, $iY1, $iX2, $iY2, $hPen2)
    else
      _GDIPlus_GraphicsDrawLine($aDial[$eGraphic], $iX1, $iY1, $iX2, $iY2, $hPen1)
    endif
    $iN += 1
  next
  _GDIPlus_PenDispose($hPen2)
  _GDIPlus_PenDispose($hPen1)

  ResourceSet ($hDial, $aDial)
  ResourceDone($aDial)
EndFunc

; ===============================================================================================================================
; Finalize resources for the hour hand
; ===============================================================================================================================
Func HourDone()
  _GDIPlus_PenDispose($aHour[$ePen])
  _GDIPlus_ArrowCapDispose($aHour[$eCap])
  ResourceDone($aHour)
EndFunc

; ===============================================================================================================================
; Draw the hour hand
; ===============================================================================================================================
Func HourDraw()
  if ($aLast[2][0] = $aCurr[2][0]) and ($aLast[2][1] = $aCurr[2][1]) then Return
  _GDIPlus_GraphicsDrawLine($aHour[$eGraphic], $iCenter, $iCenter, $aCurr[2][0], $aCurr[2][1], $aHour[$ePen])
  ResourceSet($hHour, $aHour)
EndFunc

; ===============================================================================================================================
; Initialize resources for the hour hand
; ===============================================================================================================================
Func HourInit()
  $aHour = ResourceInit($iRadius * 2, $iRadius * 2)
  $aHour[$ePen] = _GDIPlus_PenCreate(0xFFFF00FF)
  $aHour[$eCap] = _GDIPlus_ArrowCapCreate($iHourRad / 2, 8)
  _GDIPlus_PenSetCustomEndCap($aHour[$ePen], $aHour[$eCap])
EndFunc

; ===============================================================================================================================
; Finalize resources for the minute hand
; ===============================================================================================================================
Func MinDone()
  _GDIPlus_PenDispose($aMin[$ePen])
  _GDIPlus_ArrowCapDispose($aMin[$eCap])
  ResourceDone($aMin)
EndFunc

; ===============================================================================================================================
; Draw the minute hand
; ===============================================================================================================================
Func MinDraw()
  if ($aLast[1][0] = $aCurr[1][0]) and ($aLast[1][1] = $aCurr[1][1]) then Return
  _GDIPlus_GraphicsFillRect($aMin[$eGraphic], 0, 0, $iRadius * 2, $iRadius * 2)
  _GDIPlus_GraphicsDrawLine($aMin[$eGraphic], $iCenter, $iCenter, $aCurr[1][0], $aCurr[1][1], $aMin[$ePen])
  ResourceSet($hMin, $aMin)
EndFunc

; ===============================================================================================================================
; Initialize resources for the minute hand
; ===============================================================================================================================
Func MinInit()
  $aMin = ResourceInit($iRadius * 2, $iRadius * 2)
  $aMin[$ePen] = _GDIPlus_PenCreate(0xFFFF0000)
  $aMin[$eCap] = _GDIPlus_ArrowCapCreate($iMinRad / 2, 8)
  _GDIPlus_PenSetCustomEndCap($aMin[$ePen], $aMin[$eCap])
EndFunc

; ===============================================================================================================================
; Finalize resources for the second hand
; ===============================================================================================================================
Func SecDone()
  _GDIPlus_PenDispose($aSec[$ePen])
  ResourceDone($aSec)
EndFunc

; ===============================================================================================================================
; Draw the second hand
; ===============================================================================================================================
Func SecDraw()
  if ($aLast[0][0] = $aCurr[0][0]) and ($aLast[0][1] = $aCurr[0][1]) then Return
  _GDIPlus_GraphicsFillRect($aSec[$eGraphic], 0, 0, $iRadius * 2, $iRadius * 2)
  _GDIPlus_GraphicsDrawLine($aSec[$eGraphic], $iCenter, $iCenter, $aCurr[0][0], $aCurr[0][1], $aSec[$ePen])
  ResourceSet($hSec, $aSec)
EndFunc

; ===============================================================================================================================
; Initialize resources for the second hand
; ===============================================================================================================================
Func SecInit()
  $aSec = ResourceInit($iRadius * 2, $iRadius * 2)
  $aSec[$ePen] = _GDIPlus_PenCreate(0xFF000000)
EndFunc

; ===============================================================================================================================
; Finalize drawing resources
; ===============================================================================================================================
Func ResourceDone(ByRef $aInfo)
  _GDIPlus_GraphicsDispose($aInfo[$eGraphic])
  _WinAPI_ReleaseDC   (0, $aInfo[$eScrDC])
  _WinAPI_DeleteObject($aInfo[$eBitmap])
  _WinAPI_DeleteDC    ($aInfo[$eMemDC ])
EndFunc

; ===============================================================================================================================
; Initialize bitmap resources
; ===============================================================================================================================
Func ResourceInit($iWidth, $iHeight)
  Local $aInfo[$eLast + 1]

  $aInfo[$eScrDC  ] = _WinAPI_GetDC(0)
  $aInfo[$eMemDC  ] = _WinAPI_CreateCompatibleDC($aInfo[$eScrDC])
  $aInfo[$eBitmap ] = _WinAPI_CreateCompatibleBitmap($aInfo[$eScrDC], $iWidth, $iHeight)
  _WinAPI_SelectObject($aInfo[$eMemDC], $aInfo[$eBitmap])
  $aInfo[$eWidth  ] = $iWidth
  $aInfo[$eHeight ] = $iHeight
  $aInfo[$eGraphic] = _GDIPlus_GraphicsCreateFromHDC($aInfo[$eMemDC])
  _GDIPlus_GraphicsFillRect($aInfo[$eGraphic], 0, 0, $iRadius * 2, $iRadius * 2)
  Return $aInfo
EndFunc

; ===============================================================================================================================
; Update layered window with resource information
; ===============================================================================================================================
Func ResourceSet($hGUI, ByRef $aInfo, $iAlpha=-1)
  Local $pSize, $tSize, $pSource, $tSource, $pBlend, $tBlend

  if $iAlpha = -1 then $iAlpha = $iOpacity
  $tSize   = DllStructCreate($tagSIZE)
  $pSize   = DllStructGetPtr($tSize  )
  DllStructSetData($tSize, "X", $aInfo[$eWidth ])
  DllStructSetData($tSize, "Y", $aInfo[$eHeight])
  $tSource = DllStructCreate($tagPOINT)
  $pSource = DllStructGetPtr($tSource)
  $tBlend  = DllStructCreate($tagBLENDFUNCTION)
  $pBlend  = DllStructGetPtr($tBlend )
  DllStructSetData($tBlend, "Alpha" , $iAlpha      )
  DllStructSetData($tBlend, "Format", $AC_SRC_ALPHA)
  _WinAPI_UpdateLayeredWindow($hGUI, $aInfo[$eScrDC], 0, $pSize, $aInfo[$eMemDC], $pSource, 0, $pBlend, $ULW_ALPHA)
EndFunc

; ===============================================================================================================================
; Finalize resources for the digital time
; ===============================================================================================================================
Func TimeDone()
  _GDIPlus_FontDispose        ($aTime[$eFont  ])
  _GDIPlus_FontFamilyDispose  ($aTime[$eFamily])
  _GDIPlus_StringFormatDispose($aTime[$eFormat])
  _GDIPlus_BrushDispose       ($aTime[$eBrush ])
  ResourceDone($aTime)
EndFunc

; ===============================================================================================================================
; Draw the digital time
; ===============================================================================================================================
Func TimeDraw()
  Local $sString, $aSize

  if ($aLast[0][0] = $aCurr[0][0]) and ($aLast[0][1] = $aCurr[0][1]) then Return
  $sString = StringFormat("%02d:%02d:%02d", @HOUR, @MIN, @SEC)
  $aSize   = _GDIPlus_GraphicsMeasureString($aTime[$eGraphic], $sString, $aTime[$eFont], $aTime[$eLayout], $aTime[$eFormat])
  DllStructSetData($aTime[$eLayout], "X", $iRadius - (DllStructGetData($aSize[0], "Width") / 2))
  DllStructSetData($aTime[$eLayout], "Y", $iRadius / 3)
  _GDIPlus_GraphicsFillRect($aTime[$eGraphic], 0, 0, $iRadius * 2, $iRadius * 2)
  _GDIPlus_GraphicsDrawStringEx($aTime[$eGraphic], $sString, $aTime[$eFont], $aTime[$eLayout], $aTime[$eFormat], $aTime[$eBrush])
  ResourceSet($hTime, $aTime)
EndFunc

; ===============================================================================================================================
; Initialize resources for the digital time
; ===============================================================================================================================
Func TimeInit()
  $aTime = ResourceInit($iRadius * 2, $iRadius * 2)
  $aTime[$eBrush ] = _GDIPlus_BrushCreateSolid(0xFF008080)
  $aTime[$eFormat] = _GDIPlus_StringFormatCreate()
  $aTime[$eFamily] = _GDIPlus_FontFamilyCreate("Arial")
  $aTime[$eFont  ] = _GDIPlus_FontCreate($aTime[$eFamily], 24, 1)
  $aTime[$eLayout] = _GDIPlus_RectFCreate(0, 0, $iRadius * 2, 40)
EndFunc

; ===============================================================================================================================
; Convert time value to radians
; ===============================================================================================================================
Func TimeToRadians($sTimeType)
  Switch $sTimeType
    case "sec"
      Return ($nPI / 2) - (@SEC  * ($nPI / 30))
    case "min"
      Return ($nPI / 2) - (@MIN  * ($nPI / 30)) - (Int(@SEC / 10) * ($nPI / 180))
    case "hour"
      Return ($nPI / 2) - (@HOUR * ($nPI / 6 )) - (@MIN / 12) * ($nPI / 30)
  EndSwitch
EndFunc

; ===============================================================================================================================
; Handle the WM_NCHITTEST message so our window can be dragged
; ===============================================================================================================================
Func WM_NCHITTEST($hWnd, $iMsg, $iwParam, $ilParam)
  if $hWnd = $hDial then Return $HTCAPTION
EndFunc

Avec cet exemple une GUI est généré mais tu as moyen de passer outre. Voila pour le coté affichage d'info (ça marchait à peu près avec DSLA mais avec des couleurs dégueulasses ^^).
Ensuite comme je disais, l'interaction avec une GUI est à proscrire si tu veux garder la main sur ton jeu. Le plus rapide à mettre en place : des raccourcis clavier, cf HotKeySet.

Après il y a surement mieux et plus efficace. Mais là sans machine pour faire des tests propres, je te dis juste ce qui me semble le plus facile à mettre en oeuvre de suite.

Bonne chance en tout cas !

[zesteph]

justement le script clock que j ai vu en cherchant me convient mais je le comprends pas pour l affichage car c'est exactement ce que je cherche mais pas d'affichage lorsque le jeu est lancé
car apres oui des hotkeys seront utiliser pour declenchez des timer et les reinit
je vais continuer en a chercher

[Zippo]

Salut tout le monde,

Je vois que mon post a été relancé !
J'ai testé le Clock.au3 mais il ne passe pas à travers css encore une fois ...

J'espère que Zesteph qu'il trouvera la solution ! Et bien sur nous l'a faire part !=)

[timmalos]

Joueur de league of legends, je pense utiliser de simples HotKey pour le draguon/baron/bleu/rouge, avec un simple Beep() pour avertir de la fin du Timer. Ainsi pas besoin de GUI. 2 Beep = Baron, 1 Beep=Draguon. 2 Beep Aigu = Bleu, 1 Beep Aidu = Rouge, etc...

[zesteph]

humm tu m'interesses timmalos

[sksbir]

bonjour

j'interviens ici parce que zesteph m'a demandé de modifié un script d'exemple que j'avais posté ici à propos de compteurs qui se décomptent en parallèles dans une GUI...

Le code d'origine ne fonctionne que via la GUI (en cliquant dessus) et zesteph m'a donc demandé de modifier le code pour utiliser plutôt des hotkeys, mais sans me dire pourquoi il voulait faire la modif ( petit cachotier va )

Voici donc un code opérationnel avec des hotkeys, la GUI ne servant qu'à afficher les compteurs.
Comme précédemment, il y a le risque d'une certaine imprécision si le compteur est élevé au départ

On active les compteurs avec CTRL+ALT+u CTRL+ALT+i CTRL+ALT+o et CTRL+ALT+p
Si le compteur est en activité, la hotkey le remet à zéro.

Pour votre besoin, il faudra remplacer les valeurs dans le tableau de constantes , et en particulier, remplacer les "sonxxx_compteurY" par des chemins d'accès à des fichiers sons jouables avec soundplay, et ça jouera les fichiers sons au lieu de bloquer tout le script sur l'affichage d'un avertisssement...

amusez vous bien

► Afficher le texte

Code : Tout sélectionner

#include <GUIConstantsEx.au3>

Dim Const $LEGENDE_COMPTEUR[4][6]=[ ["Compteur1",30,"^!u","sondeb_compteur1","son20s_compteur1","sonfin_compteur1"], _
                                    ["Compteur2",25,"^!i","sondeb_compteur2","son20s_compteur2","sonfin_compteur2"], _
                                    ["Compteur3",30,"^!o","sondeb_compteur3","son20s_compteur3","sonfin_compteur3"], _
                                    ["Compteur4",24,"^!p","sondeb_compteur4","son20s_compteur4","sonfin_compteur4"] ]

Dim $GUI_BTN_COMPTEUR[UBound($LEGENDE_COMPTEUR)]


; mise en place des hotkeys

For $CPT = 0 To UBound($LEGENDE_COMPTEUR)-1
    $RC=HotKeySet($LEGENDE_COMPTEUR[$CPT][2],"HK_actionBouton")
    If $RC=0 Then
        MsgBox(16,"Erreur","Erreur mise en place hotkey pour " & $LEGENDE_COMPTEUR[$CPT][2])
        Exit 8
    EndIf
Next




AutoItSetOption("GUIOnEventMode", 1)
$GUI_COMPTEURS=GUICreate("Suivi des compteurs",200,UBound($LEGENDE_COMPTEUR)*30+30)

GUISetOnEvent($GUI_EVENT_CLOSE, "gui_clic_close", $GUI_COMPTEURS)

For $CPT=0 To UBound($LEGENDE_COMPTEUR)-1
    GUICtrlCreateLabel($LEGENDE_COMPTEUR[$CPT][0],50,15+$CPT*30)
    $GUI_BTN_COMPTEUR[$CPT]=GUICtrlCreateButton($LEGENDE_COMPTEUR[$CPT][1],5,10+$CPT*30,40)
    GUICtrlSetBkColor(-1,"0x00FFFF")
    ;; GUICtrlSetOnEvent(-1, "GUI_actionBouton")
Next

GUISetState(@SW_SHOW,$GUI_COMPTEURS)

Func gui_clic_close()
    Exit
EndFunc

Func HK_actionBouton()

    Local $TROUVE=0
    local $CPT=0
    ; recherche sur quel bouton on a cliqué
    ;;For $CPT=0 To UBound($LEGENDE_COMPTEUR)-1
    ;;  If @GUI_CtrlId = $GUI_BTN_COMPTEUR[$CPT] Then
    ;;      $TROUVE=1
    ;;      ExitLoop
    ;;  EndIf
    ;;Next

    ; recherche quelle hotkey a été utilisée.
    For $CPT=0 To UBound($LEGENDE_COMPTEUR)-1
        If @HotKeyPressed  = $LEGENDE_COMPTEUR[$CPT][2] Then
            $TROUVE=1
            ExitLoop
        EndIf
    Next


    If $TROUVE Then
        $ETAT=GUICtrlRead($GUI_BTN_COMPTEUR[$CPT])
        ; changement d'état du compteur selon une logique 3 états ( initial, en cours, à zéro )
        If ($ETAT<$LEGENDE_COMPTEUR[$CPT][1]) And ($ETAT>0) Then
            $ETAT=0
            GUICtrlSetBkColor($GUI_BTN_COMPTEUR[$CPT],"0xFF0000")
        Elseif $ETAT=0 Then
            $ETAT=$LEGENDE_COMPTEUR[$CPT][1]
            GUICtrlSetBkColor($GUI_BTN_COMPTEUR[$CPT],"0x00FFFF")
        ElseIf $ETAT=$LEGENDE_COMPTEUR[$CPT][1] Then
            $ETAT-=1
            GUICtrlSetBkColor($GUI_BTN_COMPTEUR[$CPT],"0x00FF00")
            If FileExists($LEGENDE_COMPTEUR[$CPT][3]) Then
                SoundPlay($LEGENDE_COMPTEUR[$CPT][3])
            Else
                MsgBox(32,"Attention","le son " & $LEGENDE_COMPTEUR[$CPT][3] & " devrait etre joué, mais fichier absent")
            EndIf
        EndIf
        GUICtrlSetData($GUI_BTN_COMPTEUR[$CPT],$ETAT)
    EndIf

EndFunc


While 1
    Sleep(999)
    For $CPT=0 To UBound($LEGENDE_COMPTEUR)-1
        $ETAT=GUICtrlRead($GUI_BTN_COMPTEUR[$CPT])
        If ($ETAT<$LEGENDE_COMPTEUR[$CPT][1]) And ($ETAT>0) Then
            $ETAT-=1
            GUICtrlSetData($GUI_BTN_COMPTEUR[$CPT],$ETAT)
            If $ETAT<=0 Then
                GUICtrlSetBkColor($GUI_BTN_COMPTEUR[$CPT],"0xFF0000")
                If FileExists($LEGENDE_COMPTEUR[$CPT][5]) Then
                    SoundPlay($LEGENDE_COMPTEUR[$CPT][5])
                Else
                    MsgBox(32,"Attention","le son " & $LEGENDE_COMPTEUR[$CPT][5] & " devrait etre joué, mais fichier absent")
                EndIf
            EndIf

            If $ETAT=20 Then
                If FileExists($LEGENDE_COMPTEUR[$CPT][4]) Then
                    SoundPlay($LEGENDE_COMPTEUR[$CPT][4])
                Else
                    MsgBox(32,"Attention","le son " & $LEGENDE_COMPTEUR[$CPT][4] & " devrait etre joué, mais fichier absent")
                EndIf
            EndIf
        EndIf
    Next
WEnd

 

[zesteph]

Merci Sksdir pour ton script
Tu as legerement modifié celui d'origine, et je t en remercie cela correspond à ce que je cherchais meme si c'est pas un GUI visible
Maintenant je vais surtout essayer de le comprendre, car c'est aussi cela mon but.

En plus, je vais pouvoir l'utiliser pour ma fille aussi et lui faire un jeu de reflexe et de rapidité, j'aurai juste à changer les libéler pour changer les lettres à appuyer