Bonjour à tous, je me suis récemment lancé dans un twitch ressemblant a twitch plays pokemon

(Les commandes sont tapées dans le chat et exécutés sur mon ordinateur grace a un programme python).

Mais ce qui me pose problème c'est que lorsque le live est lancé je dois impérativement rester avec la fenêtre du

jeu sélectionnée sinon les commandes tapées par les viewers  ne contrôlent pas le jeu, don je ne

peux rien faire pendant que le live est en cours.

Y aurait il un moyen pour que python sélectionne la fenêtre que lorsqu’un message est posté dans le chat?

Voici le code python (il y a quatre fichiers):

Voici le Main:

   

  
import twitch
import keypresser
import keyholder
t = twitch.Twitch();
k = keypresser.Keypresser();
    

username = "deltachannel";
key = "Je l'ai enlevée";
t.twitch_connect(username, key);
    
  
while True:
      
        new_messages = t.twitch_recieve_messages();
    
        if not new_messages:
          
            continue
        else:
            for message in new_messages:
             
                msg = message['message'].lower()
                username = message['username'].lower()
                print(username + " say: " + msg);
    
              
                if msg == "a": keyholder.holdForSeconds("a",0.2);
                if msg == "b": keyholder.holdForSeconds("z",0.2);
                if msg == "left": keyholder.holdForSeconds("j",0.2);
                if msg == "right": keyholder.holdForSeconds("l",0.2);
                if msg == "up": keyholder.holdForSeconds("i",0.2);
                if msg == "down": keyholder.holdForSeconds("k",0.2);
                if msg == "start": keyholder.holdForSeconds("s",0.2);
                if msg == "select": keyholder.holdForSeconds("d",0.2);
                if msg == "left1": keyholder.holdForSeconds("j",0.2);
                if msg == "right1": keyholder.holdForSeconds("l",0.2);
                if msg == "up1": keyholder.holdForSeconds("i",0.2);
                if msg == "down1": keyholder.holdForSeconds("k",0.2);
                if msg == "left2": keyholder.holdForSeconds("j",0.5);
                if msg == "right2": keyholder.holdForSeconds("l",0.5);
                if msg == "up2": keyholder.holdForSeconds("i",0.5);
                if msg == "down2": keyholder.holdForSeconds("k",0.5);
                if msg == "left3": keyholder.holdForSeconds("j",0.8);
                if msg == "right3": keyholder.holdForSeconds("l",0.8);
                if msg == "up3": keyholder.holdForSeconds("i",0.8);
                if msg == "down3": keyholder.holdForSeconds("k",0.8);

Voici le twitch:

   

import socket
import sys
import re
    
class Twitch:
    
        user = "deltachannel";
        oauth = "...";
        s = None;
    
        def twitch_login_status(self, data):
            if not re.match(r'^:(testserver\.local|tmi\.twitch\.tv) NOTICE \* :Login unsuccessful\r\n$', data): return True
            else: return False
    
        def twitch_connect(self, user, key):
            self.user = user;
            self.oauth= key;
            print("Connecting to twitch.tv");
            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM);
            s.settimeout(2);
            connect_host = "irc.twitch.tv";
            connect_port = 6667;
            try:
                s.connect((connect_host, connect_port));
            except:
                print("Failed to connect to twitch");
                sys.exit();
            print("Connected to twitch");
            print("Sending our details to twitch...");
            s.send('USER %s\r\n' % user);
            s.send('PASS %s\r\n' % key);
            s.send('NICK %s\r\n' % user);
    
            if not self.twitch_login_status(s.recv(1024)):
                print("... and they didn't accept our details");
                sys.exit();
            else:
                print("... they accepted our details");
                print("Connected to twitch.tv!")
                self.s = s;
                s.send('JOIN #%s\r\n' % user)
                s.recv(1024);
    
        def check_has_message(self, data):
            return re.match(r'^:[a-zA-Z0-9_]+\![a-zA-Z0-9_]+@[a-zA-Z0-9_]+(\.tmi\.twitch\.tv|\.testserver\.local) PRIVMSG #[a-zA-Z0-9_]+ :.+$', data)
    
        def parse_message(self, data):
            return {
                'channel': re.findall(r'^:.+\![a-zA-Z0-9_]+@[a-zA-Z0-9_]+.+ PRIVMSG (.*?) :', data)[0],
                'username': re.findall(r'^:([a-zA-Z0-9_]+)\!', data)[0],
                'message': re.findall(r'PRIVMSG #[a-zA-Z0-9_]+ :(.+)', data)[0].decode('utf8')
            }
    
        def twitch_recieve_messages(self, amount=1024):
            data = None
            try: data = self.s.recv(1024);
            except: return False;
    
            if not data:
                print("Lost connection to Twitch, attempting to reconnect...");
                self.twitch_connect(self.user, self.oauth);
                return None
    
            #self.ping(data)
    
            if self.check_has_message(data):
                return [self.parse_message(line) for line in filter(None, data.split('\r\n'))];

Voici le keypresser:

import win32com.client as comclt
    
class Keypresser:
    
        wsh = None;
    
        def __init__(self):
            self.wsh = comclt.Dispatch("WScript.Shell");
        def key_press(self, key):
            self.wsh.SendKeys(key)

Et voici le keyholder:

   

import win32api
import win32con
import time
VK_CODE = {'backspace':0x08,
               'tab':0x09,
               'clear':0x0C,
               'enter':0x0D,
               'shift':0x10,
               'ctrl':0x11,
               'alt':0x12,
               'pause':0x13,
               'caps_lock':0x14,
               'esc':0x1B,
               'spacebar':0x20,
               'page_up':0x21,
               'page_down':0x22,
               'end':0x23,
               'home':0x24,
               'left_arrow':0x25,
               'up_arrow':0x26,
               'right_arrow':0x27,
               'down_arrow':0x28,
               'select':0x29,
               'print':0x2A,
               'execute':0x2B,
               'print_screen':0x2C,
               'ins':0x2D,
               'del':0x2E,
               'help':0x2F,
               '0':0x30,
               '1':0x31,
               '2':0x32,
               '3':0x33,
               '4':0x34,
               '5':0x35,
               '6':0x36,
               '7':0x37,
               '8':0x38,
               '9':0x39,
               'a':0x41,
               'b':0x42,
               'c':0x43,
               'd':0x44,
               'e':0x45,
               'f':0x46,
               'g':0x47,
               'h':0x48,
               'i':0x49,
               'j':0x4A,
               'k':0x4B,
               'l':0x4C,
               'm':0x4D,
               'n':0x4E,
               'o':0x4F,
               'p':0x50,
               'q':0x51,
               'r':0x52,
               's':0x53,
               't':0x54,
               'u':0x55,
               'v':0x56,
               'w':0x57,
               'x':0x58,
               'y':0x59,
               'z':0x5A,
               'numpad_0':0x60,
               'numpad_1':0x61,
               'numpad_2':0x62,
               'numpad_3':0x63,
               'numpad_4':0x64,
               'numpad_5':0x65,
               'numpad_6':0x66,
               'numpad_7':0x67,
               'numpad_8':0x68,
               'numpad_9':0x69,
               'multiply_key':0x6A,
               'add_key':0x6B,
               'separator_key':0x6C,
               'subtract_key':0x6D,
               'decimal_key':0x6E,
               'divide_key':0x6F,
               'F1':0x70,
               'F2':0x71,
               'F3':0x72,
               'F4':0x73,
               'F5':0x74,
               'F6':0x75,
               'F7':0x76,
               'F8':0x77,
               'F9':0x78,
               'F10':0x79,
               'F11':0x7A,
               'F12':0x7B,
               'F13':0x7C,
               'F14':0x7D,
               'F15':0x7E,
               'F16':0x7F,
               'F17':0x80,
               'F18':0x81,
               'F19':0x82,
               'F20':0x83,
               'F21':0x84,
               'F22':0x85,
               'F23':0x86,
               'F24':0x87,
               'num_lock':0x90,
               'scroll_lock':0x91,
               'left_shift':0xA0,
               'right_shift ':0xA1,
               'left_control':0xA2,
               'right_control':0xA3,
               'left_menu':0xA4,
               'right_menu':0xA5,
               'browser_back':0xA6,
               'browser_forward':0xA7,
               'browser_refresh':0xA8,
               'browser_stop':0xA9,
               'browser_search':0xAA,
               'browser_favorites':0xAB,
               'browser_start_and_home':0xAC,
               'volume_mute':0xAD,
               'volume_Down':0xAE,
               'volume_up':0xAF,
               'next_track':0xB0,
               'previous_track':0xB1,
               'stop_media':0xB2,
               'play/pause_media':0xB3,
               'start_mail':0xB4,
               'select_media':0xB5,
               'start_application_1':0xB6,
               'start_application_2':0xB7,
               'attn_key':0xF6,
               'crsel_key':0xF7,
               'exsel_key':0xF8,
               'play_key':0xFA,
               'zoom_key':0xFB,
               'clear_key':0xFE,
               '+':0xBB,
               ',':0xBC,
               '-':0xBD,
               '.':0xBE,
               '/':0xBF,
               '`':0xC0,
               ';':0xBA,
               '[':0xDB,
               '\\':0xDC,
               ']':0xDD,
               "'":0xDE,
               '`':0xC0}
    
    
    
def press(*args):
        '''
       one press, one release.
       accepts as many arguments as you want. e.g. press('left_arrow', 'a','b').
       '''
        for i in args:
            win32api.keybd_event(VK_CODE[i], 0,0,0)
            time.sleep(2)
            win32api.keybd_event(VK_CODE[i],0 ,win32con.KEYEVENTF_KEYUP ,0)
    
def pressAndHold(*args):
        '''
       press and hold. Do NOT release.
       accepts as many arguments as you want.
       e.g. pressAndHold('left_arrow', 'a','b').
       '''
        for i in args:
            win32api.keybd_event(VK_CODE[i], 0,0,0)
            time.sleep(2)
    
def pressHoldRelease(*args):
        '''
       press and hold passed in strings. Once held, release
       accepts as many arguments as you want.
       e.g. pressAndHold('left_arrow', 'a','b').
    
       this is useful for issuing shortcut command or shift commands.
       e.g. pressHoldRelease('ctrl', 'alt', 'del'), pressHoldRelease('shift','a')
       '''
        for i in args:
            win32api.keybd_event(VK_CODE[i], 0,0,0)
            time.sleep(2)
    
        for i in args:
                win32api.keybd_event(VK_CODE[i],0 ,win32con.KEYEVENTF_KEYUP ,0)
                time.sleep(.1)
    
def holdForSeconds(key, seconds):
        win32api.keybd_event(VK_CODE[key], 0,0,0)
        time.sleep(seconds)
        win32api.keybd_event(VK_CODE[key],0 ,win32con.KEYEVENTF_KEYUP ,0)
    
def release(*args):
        '''
       release depressed keys
       accepts as many arguments as you want.
       e.g. release('left_arrow', 'a','b').
       '''
        for i in args:
            win32api.keybd_event(VK_CODE[i],0 ,win32con.KEYEVENTF_KEYUP ,0)
    
def holdKey(*args):
     win32api.keybd_event(VK_CODE[i], 0, win32con.KEYEVENTF_EXTENDEDKEY, 0)

Merci de votre aide!