# 2D game development course assignment Report

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)

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 = []

self.cards.append(card)

def give(self, card, other_hand):
self.cards.remove(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:

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)

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")
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

Keywords: P4 Python Mobile

Added by vividona on Mon, 09 Mar 2020 08:08:36 +0200