Simple Python games

1. Word guessing game

  • The game introduce: guess the word game is to calculate the soap machine to produce a word randomly, disorder the alphabet order, for the player to guess. This game uses the control character interface. In the game, tuples in the sequence can be used to store all the words to be guessed. Because the game of guessing words needs to randomly generate a word to be guessed and a random number, random module random number function is introduced. random.choice() can randomly select elements from a sequence.
Run code
# Word Jumble guessing game
import  random
#   Create a word sequence
WORDS = ('python','easy','difficult','answer','continue','jumble','phone','desktop',
         'position','game','quick','find','apple','banana','orange','stream')
print(
    """
            //Welcome to the word guessing game
        //Combine the letters into a correct word,
    """
)
iscontinue="y"
while iscontinue == "y" or iscontinue == "Y":
    # Randomly pick out a word from the sequence
    word = random.choice(WORDS)
    # A variable used to judge whether the player is right or not
    correct = word
    # Create disordered words
    jumble = ""
    while word:   # Word is not an empty string time loop
        # According to the length of word, the random position of word is generated
        position = random.randrange(len(word))
        # Combine position position letters into disordered words
        jumble += word[position]
        # Remove the position position letter from the original word by slicing
        word = word[:position] + word[(position + 1):]
    print("Disordered words:",jumble)

    guess = input("\n Please guess:")
    while guess != correct and guess != "":
        print("I'm sorry you guessed it wrong")
        guess = input("Continue to guess:")
    if guess == correct:
        print("Congratulations, that's right!\n")
        iscontinue = input("\n Whether to continue(Y/N):")
Run screenshots

2. Licensing game

  • The game is introduced: four famous brand players play cards, the computer randomly gives 52 cards (not big, Wang) to four players, and displays each player's cards on the screen.
Run code
# Card Moudule
# Basic classes for a game with playing cards
class Card():
    """ A Playing card"""
    RANKS = ["A","2","3","4","5","6","7","8","9","10","J","Q","K"]
    SUITS = ["Plum blossom","square","red","black"]

    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 flip(self):
        self.is_face_up = not self.is_face_up

    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":
            Suit = 2
        elif self.suit == "red":
            Suit = 3
        else:
            Suit = 4
        return (Suit - 1) * 13 + FaceNum
class Hand():
    """A hand of plating card"""
    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):
    """A deck of playing cards"""
    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:
                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()
    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.")
Run screenshots

3. Graphic interface design - guessing digital games

  • Game introduction: in the game, the program randomly generates numbers within 1024, and then lets the players guess. If the number of guesses is too large or too small, it will prompt, and the program will also count the number of guesses. Using Tkinter to develop digital guessing game
Run code
import tkinter as tk
import sys
import random
import  re

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

def eBtnClose(event):
    root.destroy()
def eBtnGuess(event):
    global nmaxn
    global nmin
    global num
    global running
    if running:
        val_a=int(entry_a.get())
        if val_a==number:
            labelqval("Congratulations!")
            num+=1
            running=False
            numGuess()
        elif val_a<number:
            if val_a>nmin:
                nmin=val_a
                num+=1
                label_tip_min.config(label_tip_min,text=nmin)
            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("You're right!")
    elif num<10:
        labelqval("==Within ten times, I got the right answer... Number of attempts:"+str(num))
    elif num<50:
        labelqval("OK, number of attempts:"+str(num))
    else:
        labelqval("ok You've done it more than 50 times... Number of attempts:"+str(num))
def labelqval(vText):
    label_val_q.config(label_val_q,text=vText)
root=tk.Tk(className="Figure guessing game")
root.geometry("480x120+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=nmin)
label_tip_max.pack(side="top",fill="x")
label_tip_min.pack(side="bottom",fill="y")
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()
Run screenshots

4. Graphic drawing - Graphic licensing procedure

  • Introduction to the game: 52 cards (excluding king and Wang) will be randomly distributed to four players, and the cards of each player will be 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.
Run 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()
# Create a Canvas with a white background
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):           #The 13 round
    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]]
    player1.append(cv.create_image((100,150+20*x), image=img))
    img = imgs[p3[x]]
    player1.append(cv.create_image((200 + 20 * x, 500), image=img))
    img = imgs[p4[x]]
    player1.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()
Run screenshots

5. Image processing - character puzzle

  • The game is introduced: the puzzle game divides a picture into several pieces and randomly scrambles them. When all pieces are put back to their original positions, the puzzle is completed (the game ends). 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.
Run code
from tkinter import *
from tkinter.messagebox import *
import random


root=Tk('Jigsaw puzzle')
root.title("Jigsaw puzzle")
#  Load external image
Pics=[]
for i in range(9):
    filename='t_picture\\girl_'+str(i+1)+'.png'
    Pics.append(PhotoImage(file=filename))
#  Define constants
#   Size of canvas
WIDTH=1920
HEIGHT=1080
# Side length of image block
IMAGE_WIDTH=WIDTH//3
IMAGE_HEIGHT=HEIGHT//3

#   Number of rows and columns on chessboard
ROWS=3
COLS=3
#   Mobile steps
steps=0
#  Save a list of all image blocks
board= [[0,1,2],
        [3,4,5],
        [6,7,8]]
#   Image block class
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)
#  Initialize the puzzle
def init_board():
    #   Scrambling image block coordinates
    L=list(range(8))
    L.append(None)
    random.shuffle(L)
    #  Filled puzzle
    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)
#  Reset game
def play_game():
    global steps
    steps=0
    init_board()

#   Draw game interface elements
def drawBoard(canvas):
    #  Draw a black box
    canvas.create_polygon((0,0,WIDTH,0,WIDTH,HEIGHT,0,HEIGHT),width=1,outline='Black',fill='white')
    #   Picture block
    #   The code is written here
    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
    #   Convert the click position to the coordinates on the puzzle board
    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
            #print(board)
            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)

#   Setup window
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()
Run screenshots

Tags: P4 Python Mobile

Posted on Sun, 08 Mar 2020 06:15:00 -0400 by Liquix