2D game development course experiment report

This is a verification assignment. The code is given by the teacher.

1. Sequence application - word guessing game

Function introduction

The word guessing game is to randomly generate a word by a counting machine, to disrupt the alphabetical order for players to guess. This game uses the control character interface.

Code:

import random
# Create a word sequence
WORDS = ("python", "jumble", "difficult", "answer", "continue", "phone",
         "position", "game")
# start the game
print("""
          //Word guessing game
    //Combine the letters into a correct word
    """)
iscontinue = "y"
while iscontinue == "y" or iscontinue == "Y":
    # Pick a word randomly from the sequence
    word = random.choice(WORDS)
    # A variable used to judge whether players are right
    correct = word
    # Create disordered words
    jumble = ""
    while word:  # word is not an empty string time cycle
        # 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("Wrong guess.")
        guess = input("Continue to guess:")

    if guess == correct:
        print("Guess right!\n")
        iscontinue = input("\n\n Whether to continue(Y/N): ")

Operation result

2. Object oriented design application licensing game

Function introduction

When four famous brand players play cards, the computer will randomly distribute 52 cards (not big or small) to four players, and display the cards of each player on the screen.

Code

# Card Module
# Basic classes for a game with playing cards
class Card():
    """" A playing card """
    # Number 1-13
    RANKS = ["A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"]
    # Plum for plum, square for diamonds, red for hearts, black for spades
    SUITS = ["Plum blossom", "square", "red", "black"]

    def __init__(self, rank, suit, face_up=True):
        self.rank = rank  # Refers to the number 1-13
        self.suit = suit  # It's about decor
        self.is_face_up = face_up  # Whether to display the front of the card, True for the front, False for the back of the card

    def __str__(self):  # print()
        if self.is_face_up:
            rep = self.suit + self.rank  #+" " str(self.pic_order())
        else:
            rep = "XX"
        return rep

    def filp(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():
    """" A hand of playing cards """
    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):  # 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)  # Order of playing 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.")
    # Four game player
    players = [Hand(), Hand(), Hand(), Hand()]
    poke1 = Poke()
    poke1.populate()  # Generate a deck of cards
    poke1.shuffle()  # Shuffle the cards
    poke1.deal(players, 13)  # 13 cards to 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")

Operation result

3. Graphic interface design - guessing digital games

Function introduction

In the game, the program randomly generates numbers within 1024, and then lets the players guess. If the guessed numbers are 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

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.destroy()


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


def numGuess():
    if num == 1:
        labelqval('I lean on it! One answer')
    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 tried it more than 50 times.....Number of attempts:' + str(num))


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!")
            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("Oh, big.")
        else:
            if val_a < nmaxn:
                nmaxn = val_a
                num += 1
                label_tip_max.config(label_tip_max, text=nmaxn)
            labelqval("Small.")
    else:
        labelqval("You're right...")


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 enter any integer between 0 and 1024:")
entry_a.focus_set()

print(number)
root.mainloop()

Operation result

4.Tkinter graphic drawing - Graphic licensing 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.

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]]
    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()

Operation result

5.Python image processing -- character puzzle

Function 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

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 = 'pt\\' + "t" + str(i) + ".png"
    Pics.append(PhotoImage(file=filename))
# Define constants
# Size of canvas
WIDTH = 335
HEIGHT = 600
# 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 images
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='blue')
    # 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:           # Click the position in the puzzle to move the picture
        if board[r][c] is None:   # Point to empty position and nothing moves
            return
        else:
            # Check the upper, lower, left and right positions of the current image block in turn, and move to the current image block if any
            current_square = board[r][c]
            if r - 1 >= 0 and board[r-1][c] is None:      # Judgement above
                board[r][c] = None
                board[r-1][c] = current_square
                steps += 1
            elif c + 1 <= 2 and board[r][c+1] is None:    # Judge the right side
                board[r][c] = None
                board[r][c+1] = current_square
                steps += 1
            elif r + 1 <= 2 and board[r+1][c] is None:    # Judge below
                board[r][c] = None
                board[r+1][c] = current_square
                steps += 1
            elif c - 1 >= 0 and board[r][c-1] is None:    # Judge the left side
                board[r][c] = None
                board[r][c-1] = current_square
                steps += 1
            #print(board)
            label1["text"] = str(steps)
            cv.delete('all')  # Clear the canvas
            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')   # Clear the canvas
    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()

Operation result