This is the second programming improvement course.
Consider a program based on Tetris.
Click here for the explanation video
Tetris
is a tetrimino
composed of 4 blocks
It is a puzzle game that arranges in the field.
Puzzle games like this Perfect for programming material !!
Let's think about it immediately.
With the field of the board (10 x 20 squares) Blocks surrounding other than above Blocks as shown below Let's convert the field into data.
■□□□□□□□□□□■ ■□□□□□□□□□□■ ■□□□□□□□□□□■ ■□□□□□□□□□□■ ■□□□□□□□□□□■ ■□□□□□□□□□□■ ■□□□□□□□□□□■ ■□□□□□□□□□□■ ■□□□□□□□□□□■ ■□□□□□□□□□□■ ■□□□□□□□□□□■ ■□□□□□□□□□□■ ■□□□□□□□□□□■ ■□□□□□□□□□□■ ■□□□□□□□□□□■ ■□□□□□□□□□□■ ■□□□□□□□□□□■ ■□□□□□□□□□□■ ■□□□□□□□□□□■ ■□□□□□□□□□□■ ■■■■■■■■■■■■
Tip:
It's annoying to display black and white squares one by one. Let's use repetition.
The total is 21 lines multiplied by 12 squares.
Simply create and output the data as above. Keeping the data together makes it easier to reuse.
If you use a list type for data that is aligned vertically and horizontally It is easy to express and manage.
Multiplication of the list is the repetition of elements, and addition is the concatenation of the elements.
data = [['■'] + ['□']*10 + ['■']]*20 + [['■']*12]
for y in data:
print(''.join(y))
In this case, the data is output as characters,
In the case of a puzzle game, if you store the data as a character string There are also some troublesome things, so I often think numerically.
data = [[1] + [0]*10 + [1]]*20 + [[1]*12]
for y in data:
for x in y:
print('■' if x==1 else '□',end='')
print()
■ If 1 If □, the data is stored as 0 and converted at the time of output.
Now the results are together.
Tetromino (7) □■□□ □■□□ □■□□ □□■□ □■□□ □□■□ □□□□ □■□□ □■■□ □■□□ □□■□ □■■□ □■■□ □■■□ □■□□ □■□□ □■■□ □■■□ □□■□ □■□□ □■■□ □■□□ □□□□ □□□□ □□□□ □□□□ □□□□ □□□□
Let's convert the above 7 types of tetrimino into data
This is also like a list type that uses numerical values and letters as values when using it in games It will be easier to express if you use a data type with a fixed number of vertical and horizontal numbers.
If you think about 7 tetriminos independently and consider rotation etc. It would be easier to reuse if you define it as a list type of 4x4 squares.
line = [[0,1,0,0],[0,1,0,0],[0,1,0,0],[0,1,0,0]]
tblo = [[0,1,0,0],[0,1,1,0],[0,1,0,0],[0,0,0,0]]
lr = [[0,1,0,0],[0,1,0,0],[0,1,1,0],[0,0,0,0]]
ll = [[0,0,1,0],[0,0,1,0],[0,1,1,0],[0,0,0,0]]
hr = [[0,1,0,0],[0,1,1,0],[0,0,1,0],[0,0,0,0]]
hl = [[0,0,1,0],[0,1,1,0],[0,1,0,0],[0,0,0,0]]
sq = [[0,0,0,0],[0,1,1,0],[0,1,1,0],[0,0,0,0]]
t_minos = [line,tblo,lr,ll,hr,hl,sq]
for mino in t_minos:
for y in mino:
for x in y:
print('■' if x==1 else '□',end='')
print()
print()
□■□□ □■□□ □■□□ □■□□
□■□□ □■■□ □■□□ □□□□
□■□□ □■□□ □■■□ □□□□
□□■□ □□■□ □■■□ □□□□
□■□□ □■■□ □□■□ □□□□
□□■□ □■■□ □■□□ □□□□
□□□□ □■■□ □■■□ □□□□
Using the tetrimino data I created earlier
Let's create a function rotate
that rotates by 90 degrees
def rotate(data ,angle):
processing
return data
□■□□ □■■□ □■□□ □□□□
If you rotate this 90 degrees
□□□□ □■■■ □□■□ □□□□
First, prepare the tetrimino data.
data = [[0,1,0,0],[0,1,1,0],[0,1,0,0],[0,0,0,0]]
It is troublesome to write the drawing code every time, so make it a function.
def print_block(block):
for y in block:
for x in y:
print('■' if x==1 else '□',end='')
print()
print_block(data)
□■□□ □■■□ □■□□ □□□□
Using [:: -1]
on a list will make a shallow copy of the original list in reverse order.
The zip
function repeatedly extracts one element from the beginning of each argument to create a Tuple
.
When combined, the elements are rotated 90 degrees.
data = [[0,1,0,0],[0,1,1,0],[0,1,0,0],[0,0,0,0]]
print_block(data[::-1])
□□□□ □■□□ □■■□ □■□□
print_block(zip(*data[::-1]))
□□□□ □■■■ □□■□ □□□□
To summarize in a function
def rotate(data,num):
tmp = data.copy()
if num==0:
return tmp
rotated = list(map(list, zip(*tmp[::-1])))
for i in range(num//90-1):
rotated = list(map(list, zip(*rotated[::-1])))
return rotated
data = [[0,1,0,0],[0,1,1,0],[0,1,0,0],[0,0,0,0]]
block = rotate(data,270)
print_block(block)
□□□□ □■□□ ■■■□ □□□□
The numpy library contains such matrix-like data Some have the ability to operate.
numpy.rot90 (data, rotation speed)
Rotate the array of numbers 90 degrees counterclockwise Specify 0 ~ for the number of rotations, and rotate 90 degrees with 1 Clockwise when the number of revolutions is set to-
import numpy as np
def rotate2(data,num):
return np.rot90(data.copy(),-num//90)
data = [[0,1,0,0],[0,1,1,0],[0,1,0,0],[0,0,0,0]]
block = rotate2(data,90)
print_block(block)
□□□□ □■■■ □□■□ □□□□
This can be done in 2 lines.
How to think about data structure and how to operate data A puzzle game is recommended.
We will continue to do so, so please try to solve it in various ways.
Well then.
Otsu py's HP: http://www.otupy.net/
Youtube: https://www.youtube.com/channel/UCaT7xpeq8n1G_HcJKKSOXMw
Twitter: https://twitter.com/otupython