Gamelimiter - Limit your Gaming

[Scriptinggamer]

Hi, weil ich oft in Spielen Versinke und nicht mehr aufhören kann, habe ich ein Programm geschrieben um die Spiele nach einer gewissen Zeit automatisch enden zu lassen. Beim ersten Start kann man die Prozesse der Spiele/Anwendungen komfortabel ermitteln und einspeichern und muss bei jedem weiteren Start nurnoch die Zeit eingeben und loslegen

Pythonscript und Installer gibt's natürlich kostenlos auf http://scriptinggamer.de.cg/software.php#gamelimiter

Verbesserungsideen, Bugs und Vorschläge werden gern gesehen, ob in meinem forum http://scriptinggamer.de.cg/forum.php , oder hier...

[Leonidas]

Verbesserungsvorschläge: keinen Code auf Modul-Ebene, ordentliche main()-Funktion, Zustandkapselung mit OOP und werd die globals los. Ersetze os.popen durch subprocess. Keine time.sleep() in GUI-Code.

Ich denke damit solltest du erstmal anfangen, dann kann man weiterschauen.

[Scriptinggamer]

Hey, danke für die tipps, find ich super das du dich so um jedes einzelnes Thema kümmerst, ich bin noch nicht so erfahren und hab von Aufbau und Struktur wie man sieht kaum Ahnung, ich verstehe zwar nicht alles was du geschrieben hast aber werde mal versuchen das etwas zu ordnen und zu verbessern.
Aber wie sonst wenn nicht über time.sleep() soll ich das Programm warten oder runterzählen lassen?
Gruß

[Dav1d]

Mit wxPython würde ich wx.FutureCall nutzen, ich denke bei tkInter würde man after nutzen.

Ansonsten gibt es noch threading.Timer

[Leonidas]

ich verstehe zwar nicht alles was du geschrieben hast aber werde mal versuchen das etwas zu ordnen und zu verbessern.

Prima. Also die eine Frage hat Dav1d ja schon beantwortet, bei den anderen Sachen kannst du dich ja melden wenn du das erste ausgebessert hast.

[Scriptinggamer]

Alles klar

[Scriptinggamer]

Hey, ich habe mich jetzt erstmal in diesem Thema weiter informiert und wenn ich mit der Beispieldatei fertig bin, mache ich mich an den Gamelimiter.
Ich habe aber mittlerweile folgendes gelernt/verstanden (ansatzweise):
-Tkinter in einer Klasse
-Hauptfenster und Toplevels
-Arbeiten mit Frames um nur im Hauptfenster mehrere Fensterinhalte zu nutzen (ihr versteht schon was ich meine )
-Und noch ein bisschen mehr...
Wären denn der letzte gepostete Code von diesem Thema den Verbesserungsvorschlägen entsprechend?
Gruß

[Scriptinggamer]

Ich werd ihn hier einfach mal rein schreiben:

Code: Alles auswählen

#!/usr/bin/python
# -*- coding: cp1252 -*-

#Module importieren
import tkinter as tk

#Klasse definieren
class App:
    #root/master initialisieren
    def __init__(self):
        self.master = tk.Tk()
        self.master.protocol("WM_DELETE_WINDOW", self.quit_app)
        self.master.title("Frames")
        self.set_main_frame()
        self.master.mainloop()
        
    #Hauptfenster starten
    def set_main_frame(self):
        #Hauptframe definieren
        self.main_frame = tk.Frame(self.master)
        self.main_frame.pack()
        #Widgets initialisieren
        self.hallo_label = tk.Label(self.main_frame, text = "Hallo Tkinter!")
        self.hallo_button = tk.Button(self.main_frame, text = "Weiter", command = self.set_entry_frame)
        self.quit_button = tk.Button(self.main_frame, text = "Beenden", command = self.quit_app)
        #Widgets positionieren
        self.hallo_label.grid(row = 0, column = 0, columnspan = 2)
        self.hallo_button.grid(row = 1, column = 0)
        self.quit_button.grid(row = 1, column = 1)
        #Bestätigung in der Konsole
        print("Hauptfenster geöffnet")
        
    #Einsellungsfenster starten
    def set_entry_frame(self):
        #Einstellungsframe definieren
        self.entry_frame = tk.Frame(self.master)
        #Hauptframe schließen
        self.main_frame.destroy()
        self.entry_frame.pack()
        #Widgets initialisieren
        self.head_label = tk.Label(self.entry_frame, text = "Eingaben")
        self.entry1_label = tk.Label(self.entry_frame, text = "Eingabe 1")
        self.entry1_entry = tk.Entry(self.entry_frame)
        self.entry2_label = tk.Label(self.entry_frame, text = "Eingabe 2")
        self.entry2_entry = tk.Entry(self.entry_frame)
        self.safe_entry_button = tk.Button(self.entry_frame, text = "Ausgeben", command = self.set_request_win)
        #Widgets positionieren
        self.head_label.grid(row = 0, column = 0, columnspan = 2)
        self.entry1_label.grid(row = 1, column = 0)
        self.entry1_entry.grid(row = 1, column = 1)
        self.entry2_label.grid(row = 2, column = 0)
        self.entry2_entry.grid(row = 2, column = 1)
        self.safe_entry_button.grid(row = 3, column = 0, columnspan = 2)
        #Bestätigung in der Konsole
        print("Eingabefenster geöffnet")

    #Bestätigung oder Abbruch
    def set_request_win(self):
        #Eingaben auslesen
        self.entry = [self.entry1_entry.get(), self.entry2_entry.get()]
        #Toplevel Fenster definieren
        self.request_win = tk.Toplevel()
        self.request_win.title("Wirklich?")
        #Widgets initialisieren
        self.question_label = tk.Label(self.request_win, text = "Möchtest du den Text wirklich ausgeben?")
        self.agree_button = tk.Button(self.request_win, text = "Also los, gib ihn aus!", command = self.print_entry)
        self.main_button = tk.Button(self.request_win, text = "Ich überlegs mir...", command = self.to_main)
        self.quit_button = tk.Button(self.request_win, text = "Sofort alles beenden!", command = self.quit_app)
        #Widgets positionieren
        self.question_label.grid(row = 0)
        self.agree_button.grid(row = 1, sticky = "w,e")
        self.main_button.grid(row = 2, sticky = "w,e")
        self.quit_button.grid(row = 3, sticky = "w,e")        

    #Eingaben verwerten und zum Hauptfenster zurückkehren
    def print_entry(self):
        ###Eingaben verwerten#########
        for setting in self.entry:   #
            print(setting)           #
        ##############################
        #Nachfragefenster schließen
        self.request_win.destroy()
        #Ausgabeframe schließen
        self.entry_frame.destroy()
        #Hauptframe starten
        self.set_main_frame()

    def to_main(self):
        self.request_win.destroy()
        self.entry_frame.destroy()
        self.set_main_frame()

    def quit_app(self):
        print("Programm beendet")
        self.master.destroy()

#App ausführen (Instanz der Klasse App erstellen)        
app = App()

So, nach dem Grundgerüst würde ich also die neue Version des Gamelimiters schreiben.
Zu den Verbesserungsideen:
-kein Code auf Modulebene: was meinst du damit? ist das in dem script immernoch?
-ordentliche main() funktion: brauche ich die mit der Klasse noch?
-Zustandskapselung mit OOP: was ist das?
-werd die globals los: erledigt
und der Rest ist hier ja nicht vorhanden...
Danke
Gruß

[BlackJack]

@Scriptinggamer: Kein Code auf Modulebene und `main()`-Funktion gehören quasi zusammen. Du hast immer noch das ``app = App()`` auf Modulebene was verhindert, dass man das Modul importieren kann ohne dass das Programm startet. Üblicherweise hat man dieses Muster für ausführbare Module:

Code: Alles auswählen

def main():
    app = App()

if __name__ == '__main__':
    main()

Jetzt kann man das Modul als Programm ausführen, aber auch als Modul importieren ohne dass das eigentliche Programm los läuft. Zum Beispiel um Objekte daraus wiederzuverwenden, einzelne Teile zu testen, oder andere Werkzeuge auf den Modulinhalt los zu lassen.

Zustandskapselung in Objekten bedeutet, dass man den Zustand des Programms nicht über globale Variablen vermerkt, sondern Zustand/Werte und Methoden die zusammen gehören in einer Klasse zusammen fasst. Das hast Du im Grunde nicht, denn Deine Klasse dürfte noch schlimmer sein als die Funktionen mit ein paar ausgewählten ``global``\s. Denn in Deiner Klasse hast Du wirklich *alles* an das Objekt gebunden und nicht nur die Objekte die den Zustand ausmachen. Und alles ist in *einer* Klasse. Letztendlich bist Du die ``global``-Anweisungen los geworden, semantisch hast Du jetzt aber mehr globale Variablen als vorher.

Die Attribute eines Objekts sollten möglichst alle in der `__init__()`-Methode eingeführt werden oder zumindest nach deren Abarbeitung existieren. Wenn man in beliebigen Methoden neue Attribute erzeugt, ist der Quelltext schwerer nachzuvollziehen und der Zustand und die Verwendbarkeit des Objekt oft auch extrem abhängig davon in welcher Reihenfolge die Methoden aufgerufen werden. Das macht den Code fehleranfälliger.

Kommentare sollten einen Mehrwert liefern und nicht noch einmal das aussagen was der kommentierte Quelltext selbst schon deutlich sagt. Ein ``#Module importieren`` vor den ``import``-Anweisungen oder ``#Klasse definieren`` vor einer ``class``-Anweisung ist redundant.

[Scriptinggamer]

Ich hab in dem anderen Thema eine verbesserte version gepostet.
Aber ich finde das es hilfreich ist das die Kommentare hintereinander den Programmablauf/aufbau darstellen. z.B. für Neulinge.
Und das in der __init__ nicht der erste Frame erstellt wird ist notwendig um den Frame auch später wieder aufrufbar zu machen, oder gibts da ne bessere Methode?
Gruß

[Scriptinggamer]

Oder ist es absolut unüblich und unsauber verschiedene Frames hintereinander in einem Fenster zu platzieren?
so wäre es zumindest übersichtlicher als wenn ich da dann mit der Zeit die Fenster sammeln würde...

[Scriptinggamer]

Hallo,
Wie dem auch sei, ich schreibe grade an der neuen Version des Gamelimiters. after() kann ich aber garnicht benutzen, ich zerstöre das Fenster doch bevor ich anfange runter zu zählen... eigentlich ist tkinter in der zeit wo ich sleepe ja garnicht in benutzung, wäre time.sleep() dann doch besser?
Gruß

[Scriptinggamer]

Ich war zu ungeduldig um zu warten und habe eben die neue Version geschrieben, in ner klasse, mit mainfunktion, keinem Code auf modulebene, ohne globals und ohne os aber eben noch mit time.sleep()

Code: Alles auswählen

#!/usr/bin/python
# -*- coding: utf-8 -*-

#Module importieren
import tkinter as tk
from tkinter import messagebox
import time
import pickle
import winsound
import subprocess

#Klasse definieren
class App:
    #Hauptfenster initialisieren
    def __init__(self, master):
        self.master = master
        self.master.title("Gamelimiter")
        self.add_widgets()

    #Widgets hinzufügen
    def add_widgets(self):
        self.radio_check = tk.IntVar()
        self.block_check = tk.IntVar()
       
        self.radio_check.set(1)
        self.block_check.set(0)

        #Widgets initialisieren
        head_label = tk.Label(self.master, text = "Herzlich willkommen!\nWie lange möchtest du spielen?")
        self.time_entry_h = tk.Entry(self.master, width = 4)
        seperator_label = tk.Label(self.master, text = ":")
        self.time_entry_m = tk.Entry(self.master, width = 4)
        time_radio_1 = tk.Radiobutton(self.master, text = "Zeit herunterzählen", variable = self.radio_check, value = 1)
        time_radio_2 = tk.Radiobutton(self.master, text = "als Uhrzeit verwenden", variable = self.radio_check, value = 2)
        start_button = tk.Button(self.master, text = "Starten", command = self.countdown)
        edit_processes_button = tk.Button(self.master, text = "Prozesse verwalten", command = self.edit_processes)
        block_check_button = tk.Checkbutton(self.master, text = "dann eine Stunde blocken", variable = self.block_check)

        self.time_entry_h.insert(10, "h")
        self.time_entry_m.insert(10, "m")

        #Widgets positionieren
        head_label.grid(row = 0, column = 0, columnspan = 3)
        self.time_entry_h.grid(row = 1, column = 0, sticky = "e")
        seperator_label.grid(row = 1, column = 1)
        self.time_entry_m.grid(row = 1, column = 2, sticky = "w")
        time_radio_1.grid(row = 2, column = 0)
        time_radio_2.grid(row = 2, column = 2)
        start_button.grid(row = 3, column = 0, columnspan = 3, sticky = "w,e")
        edit_processes_button.grid(row = 4, column = 2, sticky = "e")
        block_check_button.grid(row = 4, column = 0, columnspan = 3, sticky = "w")

    #Zeit einlesen, verarbeiten und herunterzählen
    def countdown(self):
        #Zeit zum herunterzählen
        if self.radio_check.get() == 1:
            if self.time_entry_h.get().isdigit() and 0 <= int(self.time_entry_h.get()) <= 60:
                play_time = int(self.time_entry_h.get()) * 3600
            else:
                play_time = 0
            if self.time_entry_m.get().isdigit() and 0 <= int(self.time_entry_m.get()) <= 60:
                play_time += int(self.time_entry_m.get()) * 60
        #Zeit bis zur Uhrzeit
        else:
            if self.time_entry_h.get().isdigit() and 0 <= int(self.time_entry_h.get()) <= 60:
                time_end_m = int(self.time_entry_h.get()) * 60
                hour_isset = True
            else:
                time_end_m = int(time.strftime("%H")) * 60
                hour_isset = False
            if self.time_entry_m.get().isdigit() and 0 <= int(self.time_entry_m.get()) <= 60:
                time_end_m += int(self.time_entry_m.get())
            elif not hour_isset:
                time_end_m += int(time.strftime("%M"))
               
           
            time_now_m = int(time.strftime("%H")) * 60 + int(time.strftime("%M"))
            if time_now_m <= time_end_m:
                play_time = (time_end_m - time_now_m)*60
            else:
                play_time = (time_end_m - time_now_m + 1440)*60

        #Zählen starten
        self.master.destroy()
        if play_time != 0:
            if play_time <= 300:
                time.sleep(play_time -11)
            else:
                time.sleep(play_time - 300)
                os.startfile("warnung.exe")
                time.sleep(289)
            winsound.PlaySound("beep.wav", winsound.SND_FILENAME)
        self.kill_tasks()

    #Prozesse überprüfen und beenden
    def kill_tasks(self):
        #Überprüfen des Befehls
        def system_test():
            if subprocess.call(["taskkill", "/IM", "testprozessname"], shell = True) == 128:
                return("taskkill")
            else:
                return("tskill")
           
        #Prozesse aus Datei einlesen
        file_processes = open("prozesse.data", "rb")
        processes = pickle.load(file_processes)
        file_processes.close()
       
        #Rückmeldung vorbereiten
        processes_closed = []
        processes_failed = []
        processes_opened = str(subprocess.check_output("tasklist", shell = True), encoding='utf8')
       
        #Prozesse versuchen zu beenden
        self.befehl = system_test()
        for process in processes:
            if process in processes_opened:
                if subprocess.call([self.befehl, "/F", "/IM", process, "/T"], shell = True) != 1:
                    processes_closed.append(process)
                else:
                    processes_failed.append(process)

        #Root erstellen
        endroot = tk.Tk()
        endroot.title("Beenden")
       
        head_label = tk.Label(text = "Das Programm ist fertig!")
        end_button = tk.Button(text = "Beenden", command = endroot.destroy)

        head_label.grid(row = 0)
        end_button.grid(row = 1, sticky = "w,e")
       
        #Rückmeldung geben
        if len(processes) == 0:
            messagebox.showwarning(title = "Keine Prozesse", message = "Du hast noch keine Prozesse gespeichert!")
        elif len(processes_closed) > 0 and len(processes_failed) == 0:
            messagebox.showwarning(title = "Prozesse beendet",
                                   message = "Folgende Prozesse wurden beendet:\n" + ", ".join(processes_closed))
        elif len(processes_closed) > 0:
            messagebox.showwarning(title = "Prozesse beendet",
                                   message = "Folgende Prozesse wurden beendet:\n" + ", ".join(processes_closed) + "\nFolgende Prozesse konnten nicht Beendet werden:\n" + ", ".join(processes_failed))
        elif len(processes_failed) > 0:
            messagebox.showwarning(title = "Beenden fehlgeschlagen",
                                   message = "Für folgende Prozesse reichen die Rechte nicht aus:\n(Dies lässt sich beheben indem das Programm\nals Administrator ausgeführt wird)\n" + ", ".join(processes_failed))
        else:
            messagebox.showwarning(title = "Keinen Prozess beendet",
                                   message = "Keiner der gespeicherten Prozesse ist geöffnet!")
        #Mainloop starten
        endroot.mainloop()
        if self.block_check.get() and len(processes) != 0:
            self.block()

    def edit_processes(self):
        #Prozesse separieren, despacen und in die Datei schreiben
        def safe_processes():
            raw_text = str(process_entry.get())
            process_list = []
            if not raw_text == "":
                while True:
                    if not raw_text == "":
                        if "," in raw_text:
                            process = raw_text[:raw_text.find(",")]
                            raw_text = raw_text[raw_text.find(",")+1:]
                        else:
                            process = raw_text
                            raw_text = ""
                        while True:
                            if " " in process:
                                process = process[:process.find(" ")] + process[process.find(" ")+1:]
                            else:
                                break
                        process_list.append(process)
                    else:
                        break
            process_file = open("prozesse.data", "wb")
            pickle.dump(process_list, process_file)
            process_file.close()
            messagebox.showwarning(title = "Speichern erfolgreich!", message = "Erfolgreich gespeichert!")
            edit_toplevel.destroy()

        #Tasks-einlesen-Dialog
        def get_tasks():
            #Tasks vergleichen und ausgeben
            def compare_tasks():
                #global tasks_before
                tasks_after = str(subprocess.check_output("tasklist", shell = True), encoding='utf8').splitlines()[4:]
                added_tasks = []
                for task_a in tasks_after:
                    in_list = False
                    for task_b in tasks_before:
                        if task_a[:task_a.find("    ")] == task_b[:task_b.find("    ")]:
                            in_list = True
                    if not in_list:
                        added_tasks.append(task_a[:task_a.find("    ")])
                print(added_tasks)
                if len(added_tasks) > 0:
                    messagebox.showwarning(title = "Tasks", message = "Folgende Tasks sind hinzugekommen:\n" + "\n".join(added_tasks))
                else:
                    messagebox.showwarning(title = "Tasks", message = "Es sind keine Tasks hinzugekommen!")

                get_tasks_toplevel.destroy()
           
            #Offene Prozesse einlesen
            tasks_before = str(subprocess.check_output("tasklist", shell = True), encoding='utf8').splitlines()[4:]

            #Toplevel initialisieren
            get_tasks_toplevel = tk.Toplevel()
            get_tasks_toplevel.title("Tasks einlesen")

            #Widgets initialisieren
            head_label = tk.Label(get_tasks_toplevel, text = "Starte das Spiel und drücke den Button!")
            get_tasks_button = tk.Button(get_tasks_toplevel, text = "Überprüfen", command = compare_tasks)

            head_label.grid(row = 0)
            get_tasks_button.grid(row = 1, sticky = "w,e")
       
        #Prozesse importieren
        process_file = open("prozesse.data")
        if process_file.read() == "":
            text = ""
        else:
            process_file = open("prozesse.data", "rb")
            text = ", ".join(pickle.load(process_file))
        process_file.close()
       
        #Toplevel initialisieren
        edit_toplevel = tk.Toplevel()
        edit_toplevel.title("Prozesse verwalten")

        #Widgets initialisieren
        head_label = tk.Label(edit_toplevel, text = "Gib hier die Prozesse deiner Spiele ein:")
        process_entry = tk.Entry(edit_toplevel)
        safe_button = tk.Button(edit_toplevel, text = "Speichern", command = safe_processes)
        break_button = tk.Button(edit_toplevel, text = "Abbrechen", command = edit_toplevel.destroy)
        get_button = tk.Button(edit_toplevel, text = "Tasks einlesen", command = get_tasks)

        process_entry.insert(10, text)

        #Widgets positionieren
        head_label.grid(row = 0, column = 0, columnspan = 3)
        process_entry.grid(row = 1, column = 0, columnspan = 3, sticky = "w,e")
        safe_button.grid(row = 2, column = 0)
        break_button.grid(row = 2, column = 1)
        get_button.grid(row = 2, column = 2)

    def block(self):
        #Prozesse aus Datei importieren
        file_processes = open("prozesse.data", "rb")
        processes = pickle.load(file_processes)
        file_processes.close()        

        #1 Stunde lang jede minute prüfen
        i = 60
        while i > 0:
            i -= 1
            time.sleep(60)
            processes_opened = str(subprocess.check_output("tasklist", shell = True), encoding='utf8')
            for process in processes:
                if process in processes_opened:
                    subprocess.call([self.befehl, "/F", "/IM", process, "/T"], shell = True)

def main():
    root = tk.Tk()
    app = App(root)
    root.mainloop()

if __name__ == "__main__":
    main()

Außerdem noch mit nem piepsen, die letzten 11 sekunden
Gruß

[/me]

Code: Alles auswählen

#!/usr/bin/python
# -*- coding: cp1252 -*-

Natürlich kann man cp1252 verwenden, aber gibt es einen konkreten Grund warum du nicht einfach das zukunftssichere UTF-8 nimmst?

[Scriptinggamer]

habs mir irgendwo rauskopiert ich ändere es eben.

[deets]

edit_processes sieht grausam aus. Dir ist "".split bekannt? Generell sieht das *sehr* danach aus, das du string-manipulation ueben solltest.

[cofi]

habs mit irgendwo rauskopiert ich ändere es eben.

Nein, stopp. Erst nachdenken.

Auch wenn ich ebenfalls UTF-8 bevorzuge, so muss das Coding Cookie mit der _tatsaechlichen_ Kodierung zusammenpassen und nicht einer Wunschkodierung.
Wenn ich richtig sehe, nutzt du Python 3, dort ist UTF-8 die Default Kodierung, du kannst es also auch weglassen.

[Scriptinggamer]

Danke für euer Interesse und eure Tipps,
Kann ichs trotzdem da lassen?
oder sollte ich die Codingzeile entfernen?
Nachdenken hätte nichts gebracht, ich wusste garnicht was für ein Coding standart ist.
Ich werd mir mal ansehen was ich so an der Stringmanipulation verbessern kann.
Gruß

[cofi]

Nachdenken hätte nichts gebracht, ich wusste garnicht was für ein Coding standart ist.

Du musst wissen wie die Datei kodiert ist, sonst ist jedes Cookie Kaese, das hat mit den _Python_ Defaults nichts zu tun, sondern einzig mit dem Editor den du verwendest.

[Leonidas]

Naja, das Programm tut unter Linux schon mal nicht, weil überall Windows-spezifischer Kram verwendet wird. Wird die anzahl der potentiellen Tester ein gutes Stück einschränken.