Membuat Game Snake Menggunakan Pyhton Dengan TKinter

 

Source :

import threading

import random

import os.path

from tkinter import *

WIDTH = 500

HEIGHT = 500

class Snake(Frame):

    def __init__(self):

        Frame.__init__(self)

        self.master.title("Permainan ular. mn-belajarpython.blogspot.com")

        self.grid()

        frame1 = Frame(self)

        frame1.grid()

        self.canvas = Canvas(frame1, width = WIDTH, height = HEIGHT, bg ="white")

        self.canvas.grid(columnspan = 3)

        self.canvas.focus_set()

        self.canvas.bind("<Button-1>", self.create)

        self.canvas.bind("<Key>", self.create)

        newGame = Button(frame1, text = "Permainan Baru", command = self.new_game)

        newGame.grid(row = 1, column = 0, sticky = E)

        self.score_label = Label(frame1)

        self.score_label.grid(row = 1, column = 1)

        self.high_score_label = Label(frame1)

        self.high_score_label.grid(row = 1, column = 2)

        self.new_game()

    def new_game(self):

        self.canvas.delete(ALL)

        self.canvas.create_text(WIDTH/2,HEIGHT/2-50,text="selamat datang di game ular ini!"\

                                + "\nklik window atau tekan salah satu tombol arah"

                                + "\nuntuk memulai game ini..", tag="welcome_text")

        rectWidth = WIDTH/25

        rect1 = self.canvas.create_rectangle(WIDTH/2-rectWidth/2, HEIGHT/2-rectWidth/2, WIDTH/2+rectWidth/2\

                                             , HEIGHT/2+rectWidth/2, outline="#dbf", fill="#dbf"\

                                             , tag="rect1")

        rect2 = self.canvas.create_rectangle(WIDTH/2-rectWidth/2, HEIGHT/2-rectWidth/2, WIDTH/2+rectWidth/2\

                                             , HEIGHT/2+rectWidth/2, outline="#dbf", fill="#dbf"\

                                             , tag="rect2")

        rect3 = self.canvas.create_rectangle(WIDTH/2-rectWidth/2, HEIGHT/2-rectWidth/2, WIDTH/2+rectWidth/2\

                                             , HEIGHT/2+rectWidth/2, outline="#dbf", fill="#dbf"\

                                             , tag="rect3")

        self.rectWidth = rectWidth

        self.lastDirection = None

        self.direction = None

        self.started = False

        self.game_over = False

        self.score = 0

        if (os.path.isfile("high_score.txt")):

            scoreFile = open("high_score.txt")

            self.high_score = int(scoreFile.read())

            scoreFile.close()

        else:

            self.high_score = 0

        self.high_score_label["text"] = "Score tertinggi: " + str(self.high_score)

        self.rectangles = [rect1,rect2,rect3]

        self.dot = None

        self.move()

    def create(self, event):

        self.lastDirection = self.direction

        if self.game_over == False:

            if event.keycode == 38: #untuk linux nilai nya adalah 111

                self.direction = "up"

            elif event.keycode == 39: #untuk linux nilai nya adalah 114

                self.direction = "right"

            elif event.keycode == 40: #untuk linux nilai nya adalah 116

                self.direction = "down"

            elif event.keycode == 37: #untuk linux nilai nya adalah 113

                self.direction = "left"

            elif event.x < WIDTH/2 and HEIGHT/3 < event.y < HEIGHT-HEIGHT/3:

                self.direction = "left"

            elif event.x > WIDTH/2 and HEIGHT/3 < event.y < HEIGHT-HEIGHT/3:

                self.direction= "right"

            elif WIDTH/3 < event.x < WIDTH-WIDTH/3 and event.y < HEIGHT/2:

                self.direction = "up"

            elif WIDTH/3 < event.x < WIDTH-WIDTH/3 and event.y > HEIGHT/2:

                self.direction= "down"

    def first_movement(self):

        w = self.rectWidth

        self.canvas.delete("welcome_text")

        if self.direction == "left":

                self.canvas.move("rect1",-w,0)

                self.canvas.after(100)

                self.canvas.move("rect1",-w,0)

                self.canvas.move("rect2",-w,0)

        elif self.direction == "down":

                self.canvas.move("rect1",0,w)

                self.canvas.after(100)

                self.canvas.move("rect1",0,w)

                self.canvas.move("rect2",0,w)

        elif self.direction == "right":

                self.canvas.move("rect1",w,0)

                self.canvas.after(100)

                self.canvas.move("rect1",w,0)

                self.canvas.move("rect2",w,0)

        elif self.direction == "up":

            self.canvas.move("rect1",0,-w)

            self.canvas.after(100)

            self.canvas.move("rect1",0,-w)

            self.canvas.move("rect2",0,-w)

        self.canvas.after(100)

    def _move(self):

        w = self.rectWidth

        while True:

            self.score_label["text"] = "Score: " + str(self.score)

            if self.started == False and self.direction != None:

                self.first_movement()

                self.started = True

            elif self.started == True and self.game_over == False:

                if self.dot == None:

                    self.make_new_dot()

                lock = threading.Lock()

                lock.acquire()

                endRect = self.rectangles.pop()

                frontCoords = self.canvas.coords(self.rectangles[0])

                endCoords = self.canvas.coords(endRect)

                if self.direction == "left":

                    self.canvas.move(self.canvas.gettags(endRect), int(frontCoords[0]-endCoords[0])-w,\

                                     int(frontCoords[1]-endCoords[1]))

                elif self.direction == "down":

                    self.canvas.move(self.canvas.gettags(endRect), int(frontCoords[0]-endCoords[0]),\

                                     int(frontCoords[1]-endCoords[1])+w)

                elif self.direction == "right":

                    self.canvas.move(self.canvas.gettags(endRect), int(frontCoords[0]-endCoords[0])+w,\

                                     int(frontCoords[1]-endCoords[1]))

                elif self.direction == "up":

                    self.canvas.move(self.canvas.gettags(endRect), int(frontCoords[0]-endCoords[0]),\

                                     int(frontCoords[1]-endCoords[1])-w)

                self.canvas.after(100)

                self.rectangles.insert(0, endRect)

                lock.release()

                self.check_bounds()

                self.check_collide()

            elif self.game_over == True:

                break;

    def move(self):

        threading.Thread(target=self._move).start()

    def make_new_dot(self):

        if self.dot != None:

            self.canvas.delete(self.dot)

            self.dot = None

        dotX = random.random()*(WIDTH-self.rectWidth*2) + self.rectWidth

        dotY = random.random()*(HEIGHT-self.rectWidth*2) + self.rectWidth

        self.dot = self.canvas.create_rectangle(dotX,dotY,dotX+self.rectWidth,dotY+self.rectWidth\

                                                ,outline="#ddd", fill="#ddd", tag="dot")

    def grow(self):

        w = self.rectWidth

        lock = threading.Lock()

        lock.acquire()

        self.score += 100

        endCoords = self.canvas.coords(self.rectangles[len(self.rectangles)-1])

        thisTag = "rect" + str(len(self.rectangles) + 1)

        x1 = int(endCoords[0])

        y1 = int(endCoords[1])

        x2 = int(endCoords[2])

        y2 = int(endCoords[3])

        if self.direction == "left":

            x1 += w

            x2 += w

        elif self.direction == "right":

            x1 -= w

            x2 -= w

        elif self.direction == "down":

            y1 -= w

            y2 -= w

        elif self.direction == "up":

            y1 += w

            y2 += w

        thisRect = self.canvas.create_rectangle(x1, y1, x2, y2, outline="#dbf",\

                                     fill="#dbf", tag=thisTag)

        self.rectangles.append(thisRect)

        lock.release()

    def check_bounds(self):

        coordinates = self.canvas.coords(self.rectangles[0])

        if len(coordinates) > 0:

            if coordinates[0] < 0 or coordinates[1] < 0 or coordinates[2] > WIDTH\

               or coordinates[3] > HEIGHT:

                self.end_game()

    def check_collide(self):

        frontCoords = self.canvas.coords(self.rectangles[0])

        overlapping = self.canvas.find_overlapping(frontCoords[0],frontCoords[1]\

                                                         ,frontCoords[2],frontCoords[3])

        for item in overlapping:

            if item == self.dot:

                #Snake collided with dot, grow snake and move dot

                self.grow()

                self.make_new_dot()

            if item in self.rectangles[3:]:

                #Snake has collided with its body, end game

                self.end_game()

        if (self.lastDirection == "left" and self.direction == "right") or\

           (self.lastDirection == "right" and self.direction == "left") or\

           (self.lastDirection == "up" and self.direction == "down") or\

           (self.lastDirection == "down" and self.direction == "up"):

            self.end_game()

    def end_game(self):

        self.game_over = True

        self.canvas.create_text(WIDTH/2,HEIGHT/2,text="GAME OVER!")

        if self.score > self.high_score:

            scoreFile = open("high_score.txt", "w")

            scoreFile.write(str(self.score))

            scoreFile.close()

            self.canvas.create_text(WIDTH/2,HEIGHT/2+20,text=\

                                    "wew.... Kamu mendapatkan Score tinggi baru!")

Snake().mainloop()

Hasil :

  

  

Beberapa Modul Python untuk Aplikasi GUI [ Desktop ]

 

Python mempunyai banyak framework dan toolkits untuk membuat GUI. Ini beberapa library terpopuler yang bisa digunakan adalah:

1. Tkinter

Tkinter adalah library standar Python untuk membuat aplikasi GUI atau desktop.

Tkinter sebenarnya bentuk OOP dari Tcl/Tk. Tcl (Tool Command Language) adalah sebuah bahasa pemrograman dan TK adalah library yang digunakan oleh Tcl untuk membuat aplikasi GUI.

Tkinter biasanya secara default di-bundle dengan Python. Jadi ketika install Python, Tkinter juga akan ikut Terinstal.

Untuk mengetes apakah di komputermu sudah terinstal Tkinter atau belum, ketik perintah berikut di interpreter Python:

>>> import _tkinter

Jika mendapatkan error No module named _tkinter, itu artinya Tkinter belum terinstal di komputermu.

Jika tidak ada, instalnya dengan perintah:

sudo apt install python-tk #untuk ptyhon 2
sudo apt install python3-tk # untuk python 3

Untuk pengguna Windows, harus mencentang bagian ini saat menginstal Python agar Tkinter ikut terinstal.

Sampel program Hello World dengan Tkinter:

from tkinter import *
from tkinter import ttk
root = Tk()
ttk.Button(root, text="Hello World").grid()
root.mainloop()

Hasilnya:

2. wxPython

wxPython adalah GUI Toolkit yang bersifat cross-platform. Artinya, bisa digunakan di mana saja. Mau itu Windows, Linux, dan MacOS.

wxPython sebenarnya menggunakan library dari wxWidgets. wxWidgets adalah GUI Toolkit yang dibuat dengan bahasa C++.

Jika ingin membuat aplikasi GUI yang mendukung untuk digunakan secara cross-platform, wxPython adalah pilihan yang tepat.

Berikut ini beberpa fitur unggulan wxPython:

• Window Layout Using Sizers
• Device Contexts (along with pens, brushes and fonts)
• Comprehensive Event Handling System
• HTML Help Viewer
• Sound and Video Playback
• Unicode and Internationalization Support
• Document/View Architecture
• Printing Archiecture
• Sockets
• Multithreading
• File and Directory Manipulation
• Online and Context-Sensitive Help
• HTML Rendering
• Basic Containers
• Image Loading, Saving, Drawing and Manipulation
• Date-Time Library and Timers
• Error Handling
• Clipboard and Drag-and-Drop

Contoh Hello World:

# pertam-tama kita harus impor dulu modeul wxPython
import wx

# Next, buat objek app
app = wx.App()

# Lalu buat frame.
frm = wx.Frame(None, title="Hello World")

# Tapilkan ke layar.
frm.Show()

# Mulai main loop.
app.MainLoop()

Hasilnya:

3. PyGTK

PyGTK adalah modul Python untuk membuat aplikasi GUI dengan GTK+ (Gimp Toolkits). GTK+ adalah library yang biasanya digunakan untuk membuat aplikasi GUI di Linux, terutama pada desktop environment Gonme. PyGTK juga bersifat cross platform.

Sampel Hello World:

#impor pustaka GTK
import gtk

# membuat objek jendela
window = gtk.Window()

# konfigurasi jendela
window.set_size_request(600,200)
window.set_position(gtk.WIN_POS_CENTER)
window.set_title("Pemrograman PyGTK - Petani Kode")
window.connect("destroy", gtk.main_quit)

# tampilkan jendela
window.show()
gtk.main()

Hasilnya:

PyGTK hanya mendukung untuk library GTK+ versi 2, untuk menggunakan GTK+ versi 3. dianjurkan menggunakan PyGobject.

4. PyGObject

PyGObject adalah modul Python untuk membuat aplikasi GUI dengan Library GObject. GObject merupakan library berbasis OOP untuk bahasa C yang isinya GTK, GStreamer, WebKitGTK, GLib, GIO, dan lain sebagainya.

Contoh Hello World:

import gi
gi.require_version("Gtk", "3.0")
from gi.repository import Gtk

window = Gtk.Window(title="Hello World")
window.show()
window.connect("destroy", Gtk.main_quit)
Gtk.main()

Hasilnya:

PyGObject sudah digunakan di beberapa aplikasi, diantaranya:

• Anaconda
• MyPaint
• Pitivi
• GNOME Music
• GNOME Tweak Tool
• Orca
• dll.

5. PyQt

PyQt adalah modul Python untuk membuat aplikasi GUI dengan library Qt. Qt merupakan library untuk membuat aplikasi GUI pada bahasa C++.

PyQt tersedia dalam dua versi, yakni ada PyQt4 untuk Qt versi 4 dan PyQt 5 untuk Qt versi 5.

Fitur yang menarik dari Qt adalah kemampuannya membuat user interface yang menarik. Karena bisa gunakan Style Sheet di sana.

Berikut ini contohnya:

from PyQt5.QtWidgets import QApplication, QPushButton
app = QApplication([])
app.setStyleSheet("QPushButton { margin: 10ex; }")
button = QPushButton('Hello World')
button.show()
app.exec_()

Hasilnya:

6. PySide

PySide sama seperti PyQt, menggunakan Qt untuk membuat aplikasi GUI. PySide di kembangkan oleh The Qt Company pada proyek Qt for Python.

Contoh Hello World:

import sys
from PySide import QtGui

app = QtGui.QApplication(sys.argv)

wid = QtGui.QWidget()
wid.resize(250, 150)
wid.setWindowTitle('Simple')
wid.show()

sys.exit(app.exec_())

Hasilnya:

Kodenya sama persis seperti PyQt.

7. Kivy

Kivy adalah library python untuk membuat aplikasi GUI yang bersifat cross-platform. Tidak hanya cross-platform pada lingkungan desktop. Kivy juga bisa berjalan pada mobile seperti Android, iOS, dan Raspberry Pi.

Contoh aplikasi hello world:

from kivy.app import App
from kivy.uix.button import Button

class TestApp(App):
    def build(self):
        return Button(text='Hello World')

TestApp().run()

Hasilnya:

8. Pyforms

PyGorms adalah framework untuk membuat aplikasi GUI yang bisa berjalan pada Web, Desktop, dan Terminal.

Satu kode program, aplikasi bisa dijalankan pada tiga tempat.

Contoh:

# example.py
from pyforms.basewidget import BaseWidget
from pyforms.controls   import ControlFile
from pyforms.controls   import ControlText
from pyforms.controls   import ControlSlider
from pyforms.controls   import ControlPlayer
from pyforms.controls   import ControlButton

class ComputerVisionAlgorithm(BaseWidget):

    def __init__(self, *args, **kwargs):
        super().__init__('Computer vision algorithm example')

        #Definition of the forms fields
        self._videofile  = ControlFile('Video')
        self._outputfile = ControlText('Results output file')
        self._threshold  = ControlSlider('Threshold', default=114, minimum=0, maximum=255)
        self._blobsize   = ControlSlider('Minimum blob size', default=110, minimum=100, maximum=2000)
        self._player     = ControlPlayer('Player')
        self._runbutton  = ControlButton('Run')

        #Define the function that will be called when a file is selected
        self._videofile.changed_event = self.__video_file_selection_event
        #Define the event that will be called when the run button is processed
        self._runbutton.value = self.run_event
        #Define the event called before showing the image in the player
        self._player.process_frame_event = self.__process_frame

        #Define the organization of the Form Controls
        self._formset = [
            ('_videofile', '_outputfile'),
            '_threshold',
            ('_blobsize', '_runbutton'),
            '_player'
        ]


    def __video_file_selection_event(self):
        """
        When the videofile is selected instanciate the video in the player
        """
        self._player.value = self._videofile.value

    def __process_frame(self, frame):
        """
        Do some processing to the frame and return the result frame
        """
        return frame

    def run_event(self):
        """
        After setting the best parameters run the full algorithm
        """
        print("The function was executed", self._videofile.value)


if __name__ == '__main__':

    from pyforms import start_app
    start_app(ComputerVisionAlgorithm)

Jalankan di desktop, maka cukup ketik perintah:

python example.py

Maka hasilnya:

Apabila ingin menjalankan aplikasi di CLI atau Terminal, maka cukup tambahkan argument terminal_mode.

python example.py terminal_mode --help

Maka hasilnya:

usage: example.py [-h] [--_videofile _VIDEOFILE] [--_outputfile _OUTPUTFILE]
              [--_threshold _THRESHOLD] [--_blobsize _BLOBSIZE]
              [--exec EXEC] [--load LOAD]
              terminal_mode

positional arguments:
  terminal_mode         Flag to run pyforms in terminal mode

optional arguments:
  -h, --help            show this help message and exit
  --_videofile _VIDEOFILE
                        Video
  --_outputfile _OUTPUTFILE
                        Results output file
  --_threshold _THRESHOLD
                        Threshold
  --_blobsize _BLOBSIZE
                        Minimum blob size
  --exec EXEC           Function from the application that should be executed.
                        Use | to separate a list of functions.
  --load LOAD           Load a json file containing the pyforms form
                        configuration.

Hasilnya untuk web:

9. PySimpleGUI

PySimpleGUI adalah modul Python untuk membuat aplikasi GUI dengan sintaks yang mudah dipahami.

Contoh:

import PySimpleGUI as sg

sg.theme('DarkAmber')   # Add a touch of color
# All the stuff inside your window.
layout = [  [sg.Text('Some text on Row 1')],
            [sg.Text('Enter something on Row 2'), sg.InputText()],
            [sg.Button('Ok'), sg.Button('Cancel')] ]

# Create the Window
window = sg.Window('Window Title', layout)
# Event Loop to process "events" and get the "values" of the inputs
while True:
    event, values = window.read()
    if event in (None, 'Cancel'):   # if user closes window or clicks cancel
        break
    print('You entered ', values[0])

window.close()

Hasilnya:

10. Toga

Toga adalah GUI Toolkits untuk membuat aplikasi GUI secara native. Toga bisa digunakan untuk membuat aplikasi Windiws, MacOs, Linux, dan mobile seperti Android dan iOS.

Contoh aplikasi hello world:

import toga


def button_handler(widget):
    print("hello")


def build(app):
    box = toga.Box()

    button = toga.Button('Hello world', on_press=button_handler)
    button.style.padding = 50
    button.style.flex = 1
    box.add(button)

    return box


def main():
    return toga.App('First App', 'org.beeware.helloworld', startup=build)


if __name__ == '__main__':
    main().main_loop()

Hasilnya:

Untuk Dokumentasi Toga, bisa dibaca di situs  https://toga.readthedocs.io/en/latest/

11. PySciter

PyScipter adalah modul Python untuk membuat aplikasi GUI dengan sciter Sciter merupakan engine yang memungkinkan untuk membuat aplikasi GUI dengan HTML, CSS, dan Javascript secara tertanam (embeddable).

Contoh  Sciter:

Lalu untuk contoh PySciter, kodenya seperti ini:

import sciter

if __name__ == '__main__':
    frame = sciter.Window(ismain=True, uni_theme=True)
    frame.load_file("minimal.htm")
    frame.expand()
    frame.run_app()

Hasilnya:

12. PyWebview

PyWebview hampir sama seperti Sciter, bekerja seperti Web browser. PyWebview bisa digunakan untuk membuat aplikasi GUI berbasis HTML, CSS, dan Js. Bahkan juga bisa dikombinasikan dengan Framework web seperti Flask dan Bottle.

Installasi PyWebview:

pip install pywebview

Contoh Program:

import webview
webview.create_window('Hello world', 'https://www.google.com')
webview.start()

Hasilnya: