Game making list based on python

1, Sequence application - word guessing game

1. Import relevant modules in the word guessing game program.
2. Create all word sequence tuples to be guessed WORDS.
3. Display the game welcome interface.
4. Realize the logic of the game.
First, randomly pick out a word from the sequence, such as "easy"; then disorder the alphabetical order of the word; then, a new disordered word jumble can be generated through multiple cycles; finally, the disordered word will be displayed to the player.
5. Players input guessing words, and the program judges right and wrong. If the player guesses wrong, he can continue to guess.
Reference code:

import random
WORDS=("python","jumble","easy","difficult","answer","continue","phone","position","game")
print("Welcome to the word guessing game, combine the letters into a correct word")
iscontinue="y"
while iscontinue=="y"or iscontinue=="Y":
    word=random.choice(WORDS)
    corrent=word
    jumble=""
    while word:
        position=random.randrange(len(word))
        jumble+=word[position]
        word=word[:position]+word[(position+1):]
    print("Disordered words:",jumble)
    guess=input("\n Please guess:")
    while guess != corrent and guess !="":
        print("I'm sorry it's not right")
        guess=input("Continue to guess:")
    if guess==corrent:
        print("Great, you guessed it!\n")
    iscontinue=input("\n\n Whether to continue(Y/N):")

The operation results are as follows:

2, Application of object-oriented design licensing game

(1) , design
Three classes are designed in the licensing program: Card class, Hand class and Poke class.
Class 1.Card
The Card class represents a Card, in which the FaceNum field refers to the Card numbers 1-13, the Suit field refers to the decor, "Mei" refers to plum blossom, "Fang" refers to diamonds, "red" refers to hearts, "black" refers to spades.
The Card constructor initializes the encapsulated member variables according to the parameters to initialize the Card face size and decor, and whether to display the Card face. The default value is True to display the front of the Card; the str() method is used to output the Card face size and decor; the pic_order() method is used to obtain the order number of the Card, and the Card face is based on clubs 1-13, diamonds 14-26, hearts 27-39, and spades 40- 52 sequence number (before shuffling), that is to say, the sequence number of plum 2 is 2, the sequence number of block A is 14, and the sequence number of block K is 26 (this method is reserved for the graphic display of the Card face); flip() is the flip method, which changes the attribute value of whether the Card face is displayed.
Class 2.Hand
The Hand class represents a Hand (a card held by a player), which can be considered as a card held by a player. The cards list variable stores the cards held by the player. You can add cards, empty the cards in your Hand, and give one card to another player.
Class 3.Poke
The Poke class represents a deck of cards, and we can think of a deck as a player with 52 cards, so we inherit the Hand class. Because the cards list variable needs to store 52 cards, and needs to be dealt and shuffled, the following methods are added.
populate(self) generates a deck of 52 cards. Of course, these cards are stored in the cards list variable in the order of plum 1-13, diamonds 14-26, hearts 27-39, and spades 40-52 (before shuffling). shuffle(self) shuffle, use Python's random module shuffle() method to shuffle the storage order of cards. Deal (self., hands, per_hand = 13) can complete the licensing action, giving four players 13 cards by default. Of course, if per_hand=10, each player will be dealt 10 cards, but there are still cards left in the end.
(2) Main program
The main program is relatively simple. Because there are four players, the players list is generated to store the initialized four players. The object instance poke1 of a deck of cards is generated. A deck of 52 cards is generated by calling the populate() method. The shuffle order is disrupted by calling the huffle() method. The deal(players, 13) method is called to issue 13 cards to each player respectively. Finally, all the cards of the four players are shown.
Reference code:

class Card():
    Ranks=["A","2","3","4","5","6","7","8","9","10","J","Q","K"]#Deck number 1-13
    Suits=["Plum blossom","square","red","black"]#Four colors

    def __init__(self,rank,suit,face_up=True):
        self.rank=rank
        self.suit=suit
        self.is_face_up=face_up  #Whether to display the front of the card, True for the front, and flame for the back
    
    def __str__(self):
        if self.is_face_up:
            rep=self.suit+self.rank
        else:
            rep="XX"
        return rep
    
    def flip(self): #Flop method
        self.is_face_up=not self.is_face_up
    
    def pic_order(self):   #Serial number of the card
        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":
            Suit=2
        elif self.suit=="red":
            Suit=3
        else:
            Suit=4
        return (Suit-1)*13+FaceNum

class Hand():
    def __init__(self):
        self.cards=[]
    
    def __str__(self):   #Override print() method
        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):    #Generate a deck of cards
        for suit in Card.Suits:
            for rank in Card.Ranks:
                self.add(Card(rank,suit))
    
    def shuffle(self):   #Shuffle the cards
        import random
        random.shuffle(self.cards)
    
    def deal(self,hands,per_hand=13):   #Issue cards to players, 13 cards per player by default
        for rounds in range(per_hand):
            for hand in hands:
                top_card=self.cards[0]
                self.cards.remove(top_card)
                hand.add(top_card)

if __name__=="__main__":
    print("This is a module with classes for playing cards.")

    players=[Hand(),Hand(),Hand(),Hand()]
    poke1=Poke()
    poke1.populate()     #Generate a deck of cards
    poke1.shuffle()      #Shuffle the cards
    poke1.deal(players,13)  #13 for each player

    #Show 4 players' cards
    n=1
    for hand in players:
        print("card-game competitor",n,end=":")
        print(hand)
        n=n+1
    input("\nPress the enter key to exit.")

The operation results are as follows:

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_ua and converts it to the number val a, 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.
Reference 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()

The operation results are as follows:

4, Tkinter graphic drawing - Graphic licensing program

1. Program function introduction
52 cards (excluding king and Xiao Wang) are randomly distributed to four players, and the cards of each player are displayed on the screen. The operation effect of the program is shown in Figure 5-1. Next, we use Canvas to draw Tkinter module graphics as an example to introduce the method of building a simple GUI (graphical user interface) game interface.
2. Program design ideas
The 52 cards to be issued are numbered in the order of 0-12 clubs, 13-25 diamonds, 26-38 hearts and 39-51 spades, and stored in the pocker list c before shuffling. The list element stores the number of A card c is actually A card. At the same time, according to this number, the playing card pictures are stored in the imgs list. That is to say, imgs[0] stores the picture of plum blossom A, imgs[1] stores the picture of plum blossom 2, imgs[14] stores the picture of block 2, and so on.
After licensing, according to the card number list of each player (pl,p2, p3, p4), obtain the corresponding card picture from imgs, and use create- image "x coordinate, y coordinate", image = image file) to display the card in the specified position.
Reference code:

from tkinter import *
import random
n=52
def gen_pocker(n):
    x=100
    while (x>0):
        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)=([],[],[],[])
(p1,p2,p3,p4)=([],[],[],[])
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="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()

The operation results are as follows:

5, Python image processing -- character puzzle

1. Game introduction
A jigsaw puzzle divides a picture into several pieces and randomly scrambles them. When all the pieces are put back to their original positions, the puzzle is finished (the end of the game). This character puzzle game is composed of three lines and three columns. The blocks are arranged in random order. The player clicks around the blank blocks to exchange their positions until all the blocks return to their original positions. Jigsaw game operation interface
2. Program design ideas
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 the array board. If board[0l[0] is block 5, the block with number 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.
0 1 2
3 4 5
6 7 8
After disruption
5 8 2
4 6 3
1 7 0

Reference 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='ka'+str(i)+'.png'
    Pics.append(PhotoImage(file=filename))

WIDTH=720
HEIGHT=720

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 play_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 did it!")

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

def callBack2():
    print("Restart")
    play_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()
play_game()
drawBoard(cv)
root.mainloop()

The operation results are as follows: