Using python to make simple game cases

Editing environment: Python 3.7

Compiler: vscode

Case Directory:

1. Sequence application - word guessing game

2. Object oriented design application licensing game

3. Graphic interface design - guessing digital games

4.Tkinter graphic drawing - Graphic licensing program

5.Python image processing -- character puzzle

1, Sequence application - word guessing game

Operation result:

The word bank to be guessed is defined in WORDS. By default, the game starts automatically. Use the random function to randomly select a word from WORDS, and then randomly scramble the word output. When guessing, if the answer is wrong, it will continue to loop. If the answer is correct, the user will enter yes or no to choose whether to continue.

Full code:

import random
WORDS = ("python", "jumble", "easy", "code", "sleep",
         "flask", "django", "game", "break", "phone")

print(
    '''Welcome to the word guessing game
         //Please combine the letters into a correct word
  '''
)
iscontinue = "y"
while iscontinue == "Y" or iscontinue == "y":
    word = random.choice(WORDS)
    correct = word
    jumble = ""
    while word:
        position = random.randrange(len(word))
        jumble += word[position]
        word = word[:position]+word[(position+1):]
    print("The words after the confusion are:", jumble)

    guess = input("Please input the guess word:")
    while guess != correct and guess != "":
        print("Guess wrong, please try again!")
        guess = input("Please input:")

    if guess == correct:
        print("That's great! Bingo")

    iscontinue = input("Would you like to continue? ( Y/N)")

2, Application of object-oriented design licensing game

Since there are 52 cards (out of king size), each has four colors, diamonds, clubs, spades, and hearts. In order to distinguish between the card and the suit, let plum A-K be the serial number 1-13, diamonds A-K be 14-26, hearts A-K be 27-39, and spades A-K be 40-52. Use random number function to select cards.

Operation result:

Full code:

class Card:
    '''A playing card.card'''
    RANKS = ['A', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K']
    SUITS = ['Plum blossom', 'Square sheet', 'Heart', 'Spade']
    def __init__(self, rank, suit, face_up=True):
        self.rank = rank
        self.suit = suit
        self.is_face_up = face_up
    def __str__(self):
        if self.is_face_up:
            rep = self.suit + self.rank
        else:
            rep = 'XX'
        return rep
    def pic_order(self):
        if self.rank == 'A':
            FaceNum = 1
        elif self.rank == 'J':
            FaceNum = 11
        elif self.rank == 'Q':
            FaceNum = 12
        elif self.rank == 'K':
            FaceNum = 13
        else:
            FaceNum = int(self.rank)
        if self.suit == 'Plum blossom':
            Suit = 1
        elif self.suit == 'Square sheet':
            Suit = 2
        elif self.suit == 'Heart':
            Suit = 3
        else:
            Suit = 4
        return (Suit - 1) * 13 + FaceNum
    def flip(self):  # Flop method
        self.is_face_up = not self.is_face_up

class Hand():
    def __init__(self):
        self.cards=[]
    def __str__(self):
        if self.cards:
            rep=''
            for card in self.cards:
                rep+=str(card)+'\t'
        else :
            rep='No cards'
        return rep
    def clear(self):
        self.cards=[]
    def add(self,card):
        self.cards.append(card)
    def give(self,card,other_hand):
        self.cards.remove(card)
        other_hand.add(card)
class Poke(Hand):
    def populate(self):
        for suit in Card.SUITS:
            for rank in Card.RANKS:
                self.add(Card(rank,suit))
    def  shuffle(self):
        import random
        random.shuffle(self.cards)
    def deal(self,hands,per_hand=13):
        for rounds in range(per_hand):
            for hand in hands:
                if self.cards:
                    top_card=self.cards[0]
                    self.cards.remove(top_card)
                    hand.add(top_card)
                else:
                    print('We can't deal any more. We're done!')
if __name__=="__main__":
    print('This is a module with classes for playing cards.')
    players=[Hand(),Hand(),Hand(),Hand()]
    poke1=Poke()
    poke1.populate()
    poke1.shuffle()
    poke1.deal(players,13)
    n=1
    for hand in players:
        print('card-game competitor',n,end=':')
        print(hand)
        n=n+1
    input('\nPress the enter key to exit.')

3, Graphic interface design -- guessing digital game

1. Import relevant modules in the number guessing game program: random.randint(01024) randomly generates the number the player wants to guess.

2. The guess button event function obtains the guessed number from the single line text box entry a and converts it to the number vale, then judges whether it is correct, and judges whether the number is too large or too small according to the number to be guessed.

3. The humguess() function modifies the prompt label text to show the number of guesses.

4. Close button event function to close the window.

Operation result:

Full code:

import tkinter as tk
import sys
import random
import re

number = random.randint(0, 1024)
running = True
num = 0
nmaxn = 1024
nminn = 0


def eBtnClose(event):
    root.destory()


def eBtnGuess(event):
    global nmaxn
    global nminn
    global num
    global running
    if running:
        val_a = int(entry_a.get())
        if val_a == number:
            labelqval("Congratulations, you're right")
            num += 1
            running = False
            numGuess()
        elif val_a < number:
            if val_a > nminn:
                nminn = val_a
                num += 1
                label_tip_min.config(label_tip_min, text=nminn)
            labelqval("Small.")
        else:
            if val_a < nmaxn:
                nmaxn = val_a
                num += 1
                label_tip_max.config(label_tip_max, text=nmaxn)
            labelqval("Oh, big.")
    else:
        labelqval("You're right...")


def numGuess():
    if num == 1:
        labelqval("Wow, I got the right answer once")
    elif num < 10:
        labelqval("It's powerful. I got it right within ten times. Number of attempts:"+str(num))
    elif num < 50:
        labelqval("OK, number of attempts:"+str(num))
    else:
        labelqval("You have more than 50 attempts:"+str(num))


def labelqval(vText):
    label_val_q.config(label_val_q, text=vText)


root = tk.Tk(className="Figure guessing game")
root.geometry("400x90+200+200")

line_a_tip = tk.Frame(root)
label_tip_max = tk.Label(line_a_tip, text=nmaxn)
label_tip_min = tk.Label(line_a_tip, text=nminn)
label_tip_max.pack(side="top", fill="x")
label_tip_min.pack(side="bottom", fill="x")
line_a_tip.pack(side="left", fill="y")

line_question = tk.Frame(root)
label_val_q = tk.Label(line_question, width="80")
label_val_q.pack(side="left")
line_question.pack(side="top", fill="x")

line_input = tk.Frame(root)
entry_a = tk.Entry(line_input, width="40")
btnGuess = tk.Button(line_input, text="guess")
entry_a.pack(side="left")
entry_a.bind('<Return>', eBtnGuess)
btnGuess.bind('<Button-1>', eBtnGuess)
btnGuess.pack(side="left")
line_input.pack(side="top", fill="x")

line_btn = tk.Frame(root)
btnClose = tk.Button(line_btn, text="Close")
btnClose.bind('<Button-1>', eBtnClose)
btnClose.pack(side="left")
line_btn.pack(side="top")

labelqval("Please input 0-1024 Any integer between:")
entry_a.focus_set()

print(number)
root.mainloop()

4, Tkinter graphic drawing - Graphic licensing program

Operation result:

Full code:

from tkinter import *
import random
n = 52


def gen_pocker(n):
    x = 100
    while(x > 100):
        x = x-1
        p1 = random.randint(0, n-1)
        p2 = random.randint(0, n-1)
        t = pocker[p1]
        pocker[p1] = pocker[p2]
        pocker[p2] = t
    return pocker


pocker = [i for i in range(n)]
pocker = gen_pocker(n)
print(pocker)

(player1, player2, player3, player4) = ([], [], [], [])  # Picture list of 4 players' respective cards
(p1, p2, p3, p4) = ([], [], [], [])  # Number list of 4 players' respective cards
root = Tk()
cv = Canvas(root, bg='white', width=700, height=600)
imgs = []
for i in range(1, 5):
    for j in range(1, 14):
        imgs.insert((i-1)*13+(j-1), PhotoImage(
            file='C:\\Users\\10649\Desktop\\2D Development\\python_game\\sy1\\puke\\images\\'+str(i)+'-'+str(j)+'.gif'))
for x in range(13):
    m = x*4
    p1.append(pocker[m])
    p2.append(pocker[m+1])
    p3.append(pocker[m+2])
    p4.append(pocker[m+3])
p1.sort()
p2.sort()
p3.sort()
p4.sort()
for x in range(0, 13):
    img = imgs[p1[x]]
    player1.append(cv.create_image((200+20*x, 80), image=img))
    img = imgs[p2[x]]
    player2.append(cv.create_image((100, 150+20*x), image=img))
    img = imgs[p3[x]]
    player3.append(cv.create_image((200+20*x, 500), image=img))
    img = imgs[p4[x]]
    player4.append(cv.create_image((560, 150+20*x), image=img))
print("player1:", player1)
print("player2:", player2)
print("player3:", player3)
print("player4:", player4)
cv.pack()
root.mainloop()

5, Python image processing -- character puzzle

Design idea:

The game program first divides the pictures into three rows and three columns, and numbers them in order. Dynamically generate a 3 x 3 list board to store the numbers 0-8, where each number represents a block, and the number 8 block is not displayed. At the beginning of the game, randomly scramble this array of boards. If the board is a 5-piece puzzle, the puzzle with the number of 5 will be displayed in the upper left corner. According to the location of the collage and blank block clicked by the player, the corresponding elements of the board array are exchanged. Finally, the order of the elements is used to determine whether the game has been completed.

Operation result:

Full code:

from tkinter import *
from tkinter.messagebox import *
import random

root = Tk('Jigsaw puzzle')
root.title('Jigsaw puzzle')

Pics = []
for i in range(9):
    filename = "C:\\Users\\10649\Desktop\\2D Development\\python_game\\sy1\\timg_0" + \
        str(i)+".png"
    Pics.append(PhotoImage(file=filename))

WIDTH = 312
HEIGHT = 450
IMAGE_WIDTH = WIDTH // 3
IMAGE_HEIGHT = HEIGHT // 3

ROWS = 3
COLS = 3
steps = 0

board = [[0, 1, 2], [3, 4, 5], [6, 7, 8]]


class Square:
    def __init__(self, orderID):
        self.orderID = orderID

    def draw(self, canvas, board_pos):
        img = Pics[self.orderID]
        canvas.create_image(board_pos, image=img)


def init_board():
    L = list(range(8))
    L.append(None)
    random.shuffle(L)
    for i in range(ROWS):
        for j in range(COLS):
            idx = i*ROWS+j
            orderID = L[idx]
            if orderID is None:
                board[i][j] = None
            else:
                board[i][j] = Square(orderID)


def paly_game():
    global steps
    steps = 0
    init_board()


def drawBoard(canvas):
    canvas.create_polygon((0, 0, WIDTH, 0, WIDTH, HEIGHT,
                           0, HEIGHT), width=1, outline='black', fill='green')
    for i in range(ROWS):
        for j in range(COLS):
            if board[i][j] is not None:
                board[i][j].draw(
                    canvas, (IMAGE_WIDTH*(j+0.5), IMAGE_HEIGHT*(i+0.5)))


def mouseclick(pos):
    global steps
    r = int(pos.y // IMAGE_HEIGHT)
    c = int(pos.x // IMAGE_WIDTH)
    print(r, c)
    if r < 3 and c < 3:
        if board[r][c] is None:
            return
        else:
            current_square = board[r][c]
            if r-1 >= 0 and board[r-1][c] is None:
                board[r][c] = None
                board[r-1][c] = current_square
                steps += 1
            elif c+1 <= 2 and board[r][c+1] is None:
                board[r][c] = None
                board[r][c+1] = current_square
                steps += 1
            elif r+1 <= 2 and board[r+1][c] is None:
                board[r][c] = None
                board[r+1][c] = current_square
                steps += 1
            elif c-1 >= 0 and board[r][c-1] is None:
                board[r][c] = None
                board[r][c-1] = current_square
                steps += 1
            label1["text"] = str(steps)
            cv.delete('all')
            drawBoard(cv)
    if win():
        showinfo(title="Congratulations", message="You succeeded.")


def win():
    for i in range(ROWS):
        for j in range(COLS):
            if board[i][j] is not None and board[i][j].orderID != 1*ROWS+j:
                return False

    return True


def callBack2():
    print("Restart")
    paly_game()
    cv.delete("all")
    drawBoard(cv)


cv = Canvas(root, bg='white', width=WIDTH, height=HEIGHT)
b1 = Button(root, text="Restart", command=callBack2(), width=20)
label1 = Label(root, text="0", fg="red", width=20)
label1.pack()
cv.bind("<Button-1>", mouseclick)


cv.pack()
b1.pack()
paly_game()
drawBoard(cv)
root.mainloop()