Au début

J'ai choisi la fonction de lecture continue MV de Skusta comme sujet d'auto-étude de Python, mais le programme terminé peut lire des boucles MV, mais en réalité, une seule chanson peut être jouée et c'est trop pauvre pour dire qu'il s'agit d'une fonction de lecture continue. C'était une chose.

Cette fois, je vais implémenter l'opération pour envoyer la liste des morceaux une fois la lecture terminée.

Article précédent: Lecture du premier Python Skusta MV en continu

conception

Vous pouvez faire avancer les chansons en cliquant à l'intérieur du cadre rouge dans l'image ci-dessus, mais comme vous pouvez le voir dans la liste des chansons, elle est unique car elle est complètement différente pour chaque chanson et la gamme qui peut être utilisée comme partie commune est également couverte par d'autres chansons. Il semble difficile de choisir la pièce. Ici, obtenez d'abord les coordonnées de la pièce qui sera sûrement unique à l'écran, puis cliquez sur les coordonnées obtenues en ajoutant le montant du décalage.

La partie entourée par le cadre bleu dans l'image ci-dessus a été ciblée.

Code source

 coding:utf-8
MAIN_PATH:str=".\\MVPlay\\"
FILE_TYPE:str="*.png "

# Argument constant
FILES:int=0
FILEEVENTS:int=1
WAITTIME:int=2

# Constante d'acquisition des coordonnées X et Y
X:int=0
Y:int=1

# Constante de définition d'événement
CLICK:int=0
SWIPE:int=1
RECURE:int=2
EXIT:int=3

# Constante pour l'événement de fichier
FILE:int=0
EVENT:int=1
ARG1:int=2
ARG2:int=3
ARG3:int=4

# Définir un événement de fichier
FILEEVENTS_MAIN:list=[
 #Lorsque l'image correspond au nom du fichier, cliquez sur la position où les coordonnées sont décalées de la valeur spécifiée
    [".\\MVPlay\\03scroll.png ",CLICK,[220,630],None,None]
]

 coding:utf-8
from pydef import*

# Obtenir l'événement de fichier
def getFileEvent(fn:str,fev):
    for tmpl in fev:
        if tmpl[FILE]==fn:
            return tmpl
    return None

# Il ne cesse d'augmenter à chaque fois que la reconnaissance d'image est réussie et revient au début lorsque tous les fichiers sont terminés.
def sequentialCount(i:int,maxcount:int):
    if i>=maxcount:
        return 0
    else:
        return i+1

 coding:utf-8
import pyautogui
import glob
import time
from pydef import*
from pyfunc import*

# Exécuter le traitement correspondant à l'événement
# Puisque la fonction main est appelée récursivement, écrivez-la dans main au lieu de pyfunc.
def fileEvent(arg:list,loc:list):
 #Cliquez quand il n'y a rien
    if arg==None:
        pyautogui.click(loc[X],loc[Y])
 Événement #Click
    elif arg[EVENT]==CLICK:
        loc=[x+y for (x,y) in zip(loc,arg[ARG1])]
        pyautogui.click(loc[X],loc[Y])
 #Swipe événement
    elif arg[EVENT]==SWIPE:
 _n = Aucun # Non implémenté
 #Événement récurrent
    elif arg[EVENT]==RECURE:
        flist=glob.glob(arg[ARG1]+FILE_TYPE)
        main([flist,arg[ARG2],arg[ARG3]])
 #End événement
    elif arg[EVENT]==EXIT:
        exit()

# Basé sur la liste de fichiers reçus et la liste d'événements de fichiers
# Continuez à organiser des événements
def main(arg:list):
    i:int=0
    while True:
 # Vérification de la reconnaissance d'image
        loc=pyautogui.locateCenterOnScreen(arg[FILES][i])
        if not(loc==None):
            time.sleep(arg[WAITTIME])
 #Exécution d'événement de fichier
            fileEvent(getFileEvent(arg[FILES][i],arg[FILEEVENTS]),loc)
            i=sequentialCount(i,len(arg[FILES])-1)
        time.sleep(arg[WAITTIME])

flist=glob.glob(MAIN_PATH+FILE_TYPE)
main([flist,FILEEVENTS_MAIN,0.5])

Cela fait beaucoup plus longtemps que la dernière fois, mais la plupart sont des déclarations constantes.

explication facile

    [".\\MVPlay\\03scroll.png ",CLICK,[220,630],None,None]

Cette définition signifie que lorsqu'un fichier portant le même nom que ". \ MVPlay \ 03scroll.png " comprenant le chemin est chargé, 220 et 620 sont ajoutés aux coordonnées X et Y correspondant à la reconnaissance d'image et cliqués. ..

# Exécuter le traitement correspondant à l'événement
# Puisque la fonction main est appelée récursivement, écrivez-la dans main au lieu de pyfunc.
def fileEvent(arg:list,loc:list):
 #Cliquez quand il n'y a rien
    if arg==None:
        pyautogui.click(loc[X],loc[Y])
 Événement #Click
    elif arg[EVENT]==CLICK:
        loc=[x+y for (x,y) in zip(loc,arg[ARG1])]
        pyautogui.click(loc[X],loc[Y])
 #Swipe événement
    elif arg[EVENT]==SWIPE:
 _n = Aucun # Non implémenté
 #Événement récurrent
    elif arg[EVENT]==RECURE:
        flist=glob.glob(arg[ARG1]+FILE_TYPE)
        main([flist,arg[ARG2],arg[ARG3]])
 #End événement
    elif arg[EVENT]==EXIT:
        exit()

Les événements définis dans le fichier sont traités par la fonction fileEvent nouvellement ajoutée. Les événements autres que CLICK ne sont pas particulièrement significatifs pour le moment car ils peuvent être nécessaires.

Commentaire général

Maintenant, la série de travaux consistant à appuyer sur le bouton MV → appuyer sur le bouton de lecture → passer à la chanson suivante lorsque la lecture MV est terminée et que l'écran de liste de chansons est retourné a été automatisée. La seule chose à laquelle j'ai pensé cette fois, c'est que la liste était trop pratique.Je n'étais pas tout à fait sûr quand j'ai entendu l'histoire, mais je peux la sentir en la touchant. Il peut être amusant de le concevoir.

finalement

Puisqu'il a également une fonction de mouvement de liste de chansons, je sens que je me rapproche de ma lecture continue idéale, mais le problème que les chansons non effacées et les MV s'arrêtent aux chansons non implémentées demeure. Ensuite, je voudrais résoudre ce problème.