RPS.py

from tkinter import *
import PIL.Image, PIL.ImageTk, PIL.ImageDraw, PIL.ImageFont
import random, os, sys, threading, base64

if getattr(sys, 'frozen', False):
    exe_path = os.path.dirname(sys.executable)
elif __file__:
    exe_path = os.path.dirname(os.path.abspath(__file__))
def no():
    pass
class TKGUI:
    def __init__(self):
        self.root= Tk() ##initilise the main window
        self.quit = False ##defaults the quit flag
        self.choice = 0
        self.points = [0, 0, 0]
        self.icons = {}
        self.gen_icons()
        self.CPU_choice = None
        self.anim = True
        self.result = False
        self.result_choice = 0

    def create_icon(self, url, data, name, w=32, h=32):
        if os.path.isfile(url):
            im = PIL.Image.open(url)
        else:
            open(name+".gif",'wb').write(base64.b64decode(data))
            im = PIL.Image.open(url)
        im = im.resize((w, h), PIL.Image.ANTIALIAS)
        icon = PIL.ImageTk.PhotoImage(im)
        return icon

    def gen_icons(self):
        rock = "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"
        paper= "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"
        scissors= "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"
        self.icons['rock'] = self.create_icon(exe_path+"\\rock.gif", rock, "rock", w=160, h=256)
        self.icons['paper'] = self.create_icon(exe_path+"\\paper.gif", paper, "paper", w=160, h=256)
        self.icons['scissors'] = self.create_icon(exe_path+"\\scissors.gif", scissors, "scissors", w=160, h=256)

    def rand_choice(self): ## keps setting a random number to choice as the computers choice
        while not self.quit:
            self.choice = random.randint(0, 2)

    def play(self, event, choice):
        if choice == 0:
            self.r.configure(command=no)
            self.p.configure(state="disabled")
            self.s.configure(state="disabled")
        elif choice == 1:
            self.r.configure(state="disabled")
            self.p.configure(command=no)
            self.s.configure(state="disabled")
        elif choice == 2:
            self.r.configure(state="disabled")
            self.p.configure(state="disabled")
            self.s.configure(command=no)
        self.player_choice = choice
        self.result = True

    def colourize(self):
        win = False
        if self.result_choice == 0: #rock
            if self.player_choice == 0:
                self.points[1] +=1
                self.r.configure(bg="green")
                self.CPU_choice.configure(bg="green")
            elif self.player_choice == 1:
                self.points[0] +=1
                self.p.configure(bg="green")
                self.CPU_choice.configure(bg="red")
            elif self.player_choice == 2:
                self.points[2] +=1
                self.s.configure(bg="red")
                self.CPU_choice.configure(bg="green")
        elif self.result_choice == 1: # paper
            if self.player_choice == 0:
                self.points[2] +=1
                self.r.configure(bg="red")
                self.CPU_choice.configure(bg="green")
            elif self.player_choice == 1:
                self.points[1] +=1
                self.p.configure(bg="green")
                self.CPU_choice.configure(bg="green")
            elif self.player_choice == 2:
                self.points[0] +=1
                self.s.configure(bg="green")
                self.CPU_choice.configure(bg="red")
        elif self.result_choice == 2: # scissors
            if self.player_choice == 0:
                self.points[2] +=1
                self.r.configure(bg="red")
                self.CPU_choice.configure(bg="green")
            elif self.player_choice == 1:
                self.points[0] +=1
                self.p.configure(bg="green")
                self.CPU_choice.configure(bg="red")
            elif self.player_choice == 2:
                self.points[1] +=1
                self.s.configure(bg="green")
                self.CPU_choice.configure(bg="green")

    def reset(self):
        children = self.root.winfo_children()
        for child in children:
            child.pack_forget()
            child.destroy()
        self.CPU_choice = None
        self.anim = True
        self.result = False
        self.result_choice = 0
        self.root.configure(bg="white")
        self.interface()

    def interface(self):
        holder = Frame(self.root, bg="white")
        holder.pack(fill=BOTH, expand=1)

        CPU = Frame(holder, bg="white")
        CPU.pack(side=TOP, fill=X, expand=1)
        self.CPU_choice = Label(CPU, image=self.icons['rock'], bg="white")
        self.CPU_choice.pack(side=TOP)

        Score = Frame(holder, bg="white")
        Score.pack(side=TOP, fill=X)
        self.win = Label(Score, text="Won: %s" %self.points[0], bg="white")
        self.win.pack(side=LEFT)
        self.draw = Label(Score, text="Draw: %s" %self.points[1], bg="white")
        self.draw.pack(side=LEFT)
        self.loose = Label(Score, text="Loss: %s" %self.points[2], bg="white")

        self.loose.pack(side=LEFT)
        Player = Frame(holder, bg="white")
        Player.pack(side=TOP, fill=X, expand=1)
        Frame(Player).pack(side=LEFT,fill=X, expand=1)
        self.r = Button(Player, bg="white", image=self.icons['rock'], command=lambda e=Event(), c=0:self.play(e,c))
        self.r.pack(side=LEFT)
        self.p = Button(Player, bg="white", image=self.icons['paper'], command=lambda e=Event(), c=1:self.play(e,c))
        self.p.pack(side=LEFT)
        self.s = Button(Player, bg="white", image=self.icons['scissors'], command=lambda e=Event(), c=2:self.play(e,c))
        self.s.pack(side=LEFT)
        Frame(Player).pack(side=LEFT, fill=X, expand=1)
    def run(self): ##main part of the application
        self.root.configure(bg="white") #sets the background to white rather than default gray.
        self.root.protocol("WM_DELETE_WINDOW", self.quitting) ##changes the X (close) Button to run a function instead.
        try:
            self.root.iconbitmap("fav.ico") ##sets the application Icon
        except:
            pass
        self.root.title("MyApp")
        self.root.geometry("800x600")
        self.root.configure(bg="white")
        t = threading.Thread(target=self.rand_choice)
        t.start()
        self.interface()
        x = 0
        r = 0
        reset = 0
        opt = ["rock", "paper", "scissors"]
        #############################################################
        while not self.quit: ##flag to quit the application
            self.root.update_idletasks() #updates the root. same as root.mainloop() but safer and interruptable
            self.root.update() #same as above. This lest you stop the loop or add things to the loop.
            #add extra functions here if you need them to run with the loop#
            if self.CPU_choice != None and self.anim and not self.result:
                if x > 10:
                    x= 0
                    self.CPU_choice.configure(image=self.icons[opt[self.choice]])
                    self.CPU_choice.update()
                else:
                    x += 1
            if self.result:
                if r < 10:
                    self.CPU_choice.configure(image=self.icons[opt[self.choice]])
                    self.CPU_choice.update()
                    r+=1
                else:
                    r = 0
                    self.result_choice = self.choice
                    self.CPU_choice.configure(image=self.icons[opt[self.result_choice]])
                    self.CPU_choice.update()
                    self.result = False
                    self.anim = False
            if not self.anim and not self.result:
                if reset == 0:
                    self.colourize()
                reset +=1
                if reset > 100:
                    reset = 0
                    self.reset()

    def quitting(self): ##to set the quit flag
        self.quit = True

if __name__ == "__main__":
    app = TKGUI() ##creates instance of GUI class
    try:
        app.run()# starts the application
    except KeyboardInterrupt:
        app.quitting() ##safely quits the application when crtl+C is pressed
    except:
        raise #you can change this to be your own error handler if needed