honney/minimal_tetris_py
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

updates

Browse Source
This commit is contained in:
Hannes
2026-07-20 20:51:09 +02:00
parent fe9072221b
commit 4503f99135
7 changed files with 677 additions and 86 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.gitignore
+2
View File
@@ -1,6 +1,8 @@
output/
*.gif
*.mp4
*.png
*.jpg
# ---> Python
background.py
+160
View File
@@ -0,0 +1,160 @@
I = 1
O = 2
T = 3
S = 4
Z = 5
J = 6
L = 7
# board = [
# [I,I,I,I,L,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
# [S,S,L,L,L,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
# [T,S,S,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
# [T,T,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
# [T,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
# [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
# [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
# [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
# [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
# [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
# [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
# [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
# [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
# [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
# [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
# [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
# [0,0,0,0,0,J,0,T,0,0,Z,Z,0,J,0,0,L,0,0,0,0,0,0,0,0,0,0,0,0,0,0,J],
# [J,0,T,T,T,J,T,T,T,Z,Z,Z,Z,J,O,O,L,0,O,O,0,0,0,0,0,Z,Z,T,T,T,T,J],
# ]
board = [
[0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,O,O,0,0,0],
[0,0,0,0,0,O,O,0,0,0],
[0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0],
[0,0,I,0,0,0,0,0,0,0],
[O,O,I,T,0,0,0,J,J,0],
[O,O,I,T,T,L,L,J,L,0],
[O,O,I,T,I,I,L,J,L,0],
[S,S,S,S,0,S,S,S,S,S]
]
board_width = len(board[0])
board_height = len(board)
class color:
def __init__(self, color=None, red=None, green=None, blue=None, alpha=255) -> None:
# Allow hex string input like "#ff8800" or "ff8800"
if isinstance(color, str):
hexcode = color.lstrip("#")
if len(hexcode) not in (6, 8):
raise ValueError("Hex color must be 6 or 8 characters long")
self.r = int(hexcode[0:2], 16)
self.g = int(hexcode[2:4], 16)
self.b = int(hexcode[4:6], 16)
if len(hexcode) == 8:
self.a = int(hexcode[6:8], 16)
else:
self.a = alpha
else:
# Regular RGB(A) input
self.r = red
self.g = green
self.b = blue
self.a = alpha
def get(self) -> tuple[int, int, int]:
return (self.r, self.g, self.b)
def sub(self, n) -> tuple[int, int, int]:
if self.r:
r=self.r-n
else:
r=0
if self.g:
g=self.g-n
else:
g=0
if self.b:
b=self.b-n
else:
b=0
return (r,g,b)
def multiply(self, other) -> tuple[int, int, int]:
r = other[0]
g = other[1]
b = other[2]
return (((self.r * r) >> 8), ((self.g * g) >> 8), ((self.b * b)>>8))
def shiftr(self, n):
return ((self.r >> n), (self.g >> n), (self.b >>n))
def mask(self, n):
return ((self.r & n), (self.g & n), (self.b & n))
black = color("#000000")
white = color("#ffffff")
colors = [
color("#000000"),
color("#00ffff"),
color("#fff200"),
color("#9d00ff"),
color("#00ff00"),
color("#ff0000"),
color("#0000ff"),
color("#ff8000")
]
width = board_width*32
height = board_height*32
from PIL import Image
img = Image.new("RGB", (width, height))
pixels = img.load()
for y in range(height):
for x in range(width):
xd = x
yd = y
color_internal = colors[board[yd>>5][xd>>5]]
if board[yd>>5][xd>>5] != 0:
xs = xd&0x1F
ys = yd&0x1F
if (xs > 7 and xs < 24) and (ys > 7 and ys < 24): # middle
pixels[x, y] = color_internal.get()
elif (xs > 5 and xs < 26) and (ys > 5 and ys < 26): # mid boarder
pixels[x, y] = color_internal.mask(0xFFFFFFB0)
elif xs+ys<31: # top left edge
if xs>ys:
pixels[x, y] = color_internal.get()
else:
pixels[x, y] = color_internal.mask(0xFFFFFFEF)
else:
if xs>ys:
pixels[x, y] = color_internal.mask(0xFFFFFFD7)
else:
pixels[x, y] = color_internal.mask(0xFFFFFFC0)
else:
pixels[x, y] = (0, 0, 0)
# if (x+y)&1:
# pixels[x, y] = (0, 0, 255)
# else:
# pixels[x, y] = ((x+y)>>3, (((1280+720)>>3)-((x+y)>>3)), 0)
img.save("output/folie_16_background.png")
img.show()
bg_mult.py
+156
View File
@@ -0,0 +1,156 @@
I = 1
O = 2
T = 3
S = 4
Z = 5
J = 6
L = 7
class color:
def __init__(self, color=None, red=None, green=None, blue=None, alpha=255) -> None:
# Allow hex string input like "#ff8800" or "ff8800"
if isinstance(color, str):
hexcode = color.lstrip("#")
if len(hexcode) not in (6, 8):
raise ValueError("Hex color must be 6 or 8 characters long")
self.r = int(hexcode[0:2], 16)
self.g = int(hexcode[2:4], 16)
self.b = int(hexcode[4:6], 16)
if len(hexcode) == 8:
self.a = int(hexcode[6:8], 16)
else:
self.a = alpha
else:
# Regular RGB(A) input
self.r = red
self.g = green
self.b = blue
self.a = alpha
def get(self) -> tuple[int, int, int]:
return (self.r, self.g, self.b)
def sub(self, n) -> tuple[int, int, int]:
if self.r:
r=self.r-n
else:
r=0
if self.g:
g=self.g-n
else:
g=0
if self.b:
b=self.b-n
else:
b=0
return (r,g,b)
def multiply(self, other) -> tuple[int, int, int]:
r = other[0]
g = other[1]
b = other[2]
return (((self.r * r) >> 8), ((self.g * g) >> 8), ((self.b * b)>>8))
def shiftr(self, n):
return ((self.r >> n), (self.g >> n), (self.b >>n))
def mask(self, n):
return ((self.r & n), (self.g & n), (self.b & n))
black = color("#000000")
white = color("#ffffff")
colors = [
color("#000000"),
color("#00ffff"),
color("#fff200"),
color("#9d00ff"),
color("#00ff00"),
color("#ff0000"),
color("#0000ff"),
color("#ff8000")
]
base_board = [
[I,I,I,I,L,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[S,S,L,L,L,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[T,S,S,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[T,T,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[T,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,J,0,T,0,0,Z,Z,0,J,0,0,L,0,0,0,0,0,0,0,0,0,0,0,0,0,0,J],
[J,0,T,T,T,J,T,T,T,Z,Z,Z,Z,J,O,O,L,0,O,O,0,0,0,0,0,Z,Z,T,0,0,0,J],
[J,J,J,T,J,J,I,I,I,I,Z,Z,J,J,O,O,L,L,O,O,I,I,I,I,Z,Z,T,T,T,0,J,J]
]
next_piece = [
[T,T,T],
[0,T,0]
]
coord = 28
board_width = len(base_board[0])
board_height = len(base_board)
width = board_width*32
height = board_height*32
from PIL import Image
img2 = Image.open("output.jpg")
pixels2 = img2.load()
for t in range(len(base_board)-1):
img = Image.new("RGB", (width, height))
pixels = img.load()
board = [row[:] for row in base_board]
for i in range(len(next_piece)):
i_int = i + t
for j in range(len(next_piece[i])):
j_int = j + coord
if board[i_int][j_int] == 0:
board[i_int][j_int] = next_piece[i][j]
for y in range(height):
for x in range(width):
xd = x
yd = y
color_internal = colors[board[yd>>5][xd>>5]]
if board[yd>>5][xd>>5] != 0:
xs = xd&0x1F
ys = yd&0x1F
if (xs > 7 and xs < 24) and (ys > 7 and ys < 24): # middle
pixels[x, y] = color_internal.get()
elif (xs > 5 and xs < 26) and (ys > 5 and ys < 26): # mid boarder
pixels[x, y] = color_internal.mask(0xFFFFFFB0)
elif xs+ys<31: # top left edge
if xs>ys:
pixels[x, y] = color_internal.get()
else:
pixels[x, y] = color_internal.mask(0xFFFFFFEF)
else:
if xs>ys:
pixels[x, y] = color_internal.mask(0xFFFFFFD7)
else:
pixels[x, y] = color_internal.mask(0xFFFFFFC0)
else:
# if (x+y)&1:
# pixels[x, y] = (0, 0, 255)
# else:
pixels[x, y] = pixels2[x, y]# ((x+y)>>2, (((1280+720)>>2)-((x+y)>>2)), 255)
img.save(f"output/folie_{t}_background.png")
if t == 1:
img.show()
gpu.py
+140 -52
View File
@@ -316,10 +316,10 @@ class coord:
def make_next_board():
next_board = [
[0, 0, 0, 0],
[1, 1, 1, 1],
[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 1, 0, 0],
[1, 1, 1, 0],
]
return next_board
@@ -384,42 +384,109 @@ lime = color("#5fdf5f")
colors = [
black,
cyan,
blue,
orange,
yellow,
green,
purple,
red
green,
red,
blue,
orange
]
colors2 = [
black,
color("#0086f3"),
color("#3d4fdc"),
color("#fdab01"),
color("#abcb04"),
color("#02bdcd"),
color("#d20f63"),
color("#fe4b0f"),
]
I=1
O=2
T=3
S=4
Z=5
J=6
L=7
colors2 = colors
# colors2 = [
# black,
# color("#0086f3"),
# color("#3d4fdc"),
# color("#fdab01"),
# color("#abcb04"),
# color("#02bdcd"),
# color("#d20f63"),Z
# color("#fe4b0f"),
# ]
text_bg = black
next_board = make_next_board()
# next_board = make_next_board()
next_board = [
[0, 0, T, 0],
[0, T, T, T],
[0, 0, 0, 0],
[0, 0, 0, 0],
]
nb1 = coord(88, 104, 128, 128)
next_board1 = make_next_board()
# next_board1 = make_next_board()
next_board1 = [
[0, 0, 0, L],
[0, L, L, L],
[0, 0, 0, 0],
[0, 0, 0, 0],
]
nb2 = coord(1064, 104, 128, 128)
board_height, board_width, board = make_board(len(colors))
board_height, board_width, _ = make_board(len(colors))
board = [
[0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,J,J,0],
[0,0,0,0,0,0,0,J,0,0],
[0,0,0,0,0,0,0,J,0,0],
[0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0],
[0,0,I,0,0,0,0,0,0,0],
[O,O,I,I,I,0,0,0,0,0],
[O,O,I,I,I,L,L,0,L,0],
[O,O,I,I,I,I,L,0,L,0]
]
b1 = coord(304, 40, 320, 640)
board2_height, board2_width, board2 = make_board(len(colors2))
board2_height, board2_width, _ = make_board(len(colors2))
board2 = [
[0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0],
[0,0,0,Z,0,0,0,0,0,0],
[0,0,Z,Z,0,0,0,0,0,0],
[0,0,Z,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0],
[O,O,0,0,0,O,O,J,J,J],
[O,O,0,O,O,O,O,Z,Z,J],
[J,0,S,S,Z,Z,I,I,I,I],
[S,Z,Z,T,I,J,J,Z,Z,0],
[S,S,Z,Z,I,J,0,0,Z,Z]
]
b2 = coord(656, 40, 320, 640)
score0 = make_score()
# score0 = make_score()
score0 = 299
score1 = 298
s1 = coord(84, 332, 136, 32)
sn1 = coord(74, 368, 156, 20)
score1 = make_score()
# score1 = make_score()
s2 = coord(1060, 332, 136, 32)
sn2 = coord(1050, 368, 156, 20)
@@ -443,7 +510,28 @@ img = Image.new("RGB", (width, height))
pixels = img.load()
menu = 1
menu = 0
menu_active0 = [1,0,0,0]
menu_active1 = [0,1,0,0]
menu_active2 = [1,0]
def menu_get (side, i) -> tuple[int, int, int] | color | None:
if side == "left":
if menu_active0[i] == 0:
return white.get()
else:
return red.get()
elif side == "right":
if menu_active1[i] == 0:
return white.get()
else:
return red.get()
elif side == "middle":
if menu_active2[i] == 0:
return white
else:
return yellow
for y in range(height):
for x in range(width):
@@ -460,9 +548,9 @@ for y in range(height):
ys = yd >> 3
if x > mm0.x+3 and y>mm0.y+3 and xd<mm0.width-4 and yd<mm0.height-4:
if xs <ys*2 and xs<((mm0.width-8 >> 3)-ys)<<1 and xs >2:
pixels[x, y] = (255,255,255)
pixels[x, y] = menu_get ("middle", 0).get()
elif (xs == ys*2 or xs==((mm0.width-8 >> 3)-ys)<<1) and xs >2 and xs <14:
pixels[x, y] = (32,32,32)
pixels[x, y] = menu_get("middle", 0).shiftr(3)
else:
pixels[x, y] = black.get()
else:
@@ -476,30 +564,30 @@ for y in range(height):
if x > mm1.x+3 and y>mm1.y+3 and xd<mm1.width-8 and yd<mm1.height-8:
# vert/horizontal
if xs == 2 and ys < 10 and ys > 4: # left
pixels[x, y] = white.get()
pixels[x, y] = menu_get("middle", 1).get()
elif xs == 11 and ys < 8 and ys > 4: # right
pixels[x, y] = white.get()
pixels[x, y] = menu_get("middle", 1).get()
elif ys == 2 and xs < 10 and xs > 4: # top
pixels[x, y] = white.get()
pixels[x, y] = menu_get("middle", 1).get()
elif ys == 12 and xs < 10 and xs > 4: # bot
pixels[x, y] = white.get()
pixels[x, y] = menu_get("middle", 1).get()
# Orthogonal
elif xs+ys == 7 and xs >1 and ys >1: # top left
pixels[x, y] = white.get()
pixels[x, y] = menu_get("middle", 1).get()
elif xs+ys == 21 and xs >8 and ys >9: # bot right
pixels[x, y] = white.get()
pixels[x, y] = menu_get("middle", 1).get()
elif ys-xs == 7 and xs < 6 and ys > 8: # bot left
pixels[x, y] = white.get()
pixels[x, y] = menu_get("middle", 1).get()
elif xs-ys == 7 and xs > 8 and ys < 5: # top right
pixels[x, y] = white.get()
pixels[x, y] = menu_get("middle", 1).get()
# Arrow Head
elif xs-ys == 4 and xs > 8 and xs < 12: # left
pixels[x, y] = white.get()
pixels[x, y] = menu_get("middle", 1).get()
elif xs+ys == 18 and xs > 10 and xs <14: # right
pixels[x, y] = white.get()
pixels[x, y] = menu_get("middle", 1).get()
# Aliasing
elif (xs==ys==11) or (xs==ys==3) or (xs==11 and ys==3) or (xs==3 and ys==11):
pixels[x, y] = (32,32,32)
pixels[x, y] = menu_get("middle", 1).shiftr(3)
else:
pixels[x, y] = black.get()
else:
@@ -590,33 +678,33 @@ for y in range(height):
yd = y-lm0.y
xs = xd-34
if xd < (24) and a_p[yd>>2][xd>>2]:
pixels[x, y] = white.get()
pixels[x, y] = menu_get("left", 0)
elif xd > (33) and a_1[yd>>2][xs>>2]:
pixels[x, y] = white.get()
pixels[x, y] = menu_get("left", 0)
elif x >= lm1.x and x < (lm1.x + lm1.width) and y >= lm1.y and y < (lm1.y + lm1.height):
xd = x-lm1.x
yd = y-lm1.y
xs = xd-34
if xd < (24) and a_p[yd>>2][xd>>2]:
pixels[x, y] = white.get()
pixels[x, y] = menu_get("left", 1)
elif xd > (33) and a_2[yd>>2][xs>>2]:
pixels[x, y] = white.get()
pixels[x, y] = menu_get("left", 1)
elif x >= lm2.x and x < (lm2.x + lm2.width) and y >= lm2.y and y < (lm2.y + lm2.height):
xd = x-lm2.x
yd = y-lm2.y
xs = xd-28
if xd < (24) and a_s[yd>>2][xd>>2]:
pixels[x, y] = white.get()
pixels[x, y] = menu_get("left", 2)
elif xd > (27) and a_w[yd>>2][xs>>2]:
pixels[x, y] = white.get()
pixels[x, y] = menu_get("left", 2)
elif x >= lm3.x and x < (lm3.x + lm3.width) and y >= lm3.y and y < (lm3.y + lm3.height):
xd = x-lm3.x
yd = y-lm3.y
xs = xd-28
if xd < (24) and a_h[yd>>2][xd>>2]:
pixels[x, y] = white.get()
pixels[x, y] = menu_get("left", 3)
elif xd > (27) and a_w[yd>>2][xs>>2]:
pixels[x, y] = white.get()
pixels[x, y] = menu_get("left", 3)
####################### Right Board
### Board
elif x>=b2.x and x<b2.x+b2.width and y>=b2.y and y<b2.y+b2.height:
@@ -702,33 +790,33 @@ for y in range(height):
yd = y-rm0.y
xs = xd-34
if xd < (24) and a_p[yd>>2][xd>>2]:
pixels[x, y] = white.get()
pixels[x, y] = menu_get("right", 0)
elif xd > (33) and a_1[yd>>2][xs>>2]:
pixels[x, y] = white.get()
pixels[x, y] = menu_get("right", 0)
elif x >= rm1.x and x < (rm1.x + rm1.width) and y >= rm1.y and y < (rm1.y + rm1.height):
xd = x-rm1.x
yd = y-rm1.y
xs = xd-34
if xd < (24) and a_p[yd>>2][xd>>2]:
pixels[x, y] = white.get()
pixels[x, y] = menu_get("right", 1)
elif xd > (33) and a_2[yd>>2][xs>>2]:
pixels[x, y] = white.get()
pixels[x, y] = menu_get("right", 1)
elif x >= rm2.x and x < (rm2.x + rm2.width) and y >= rm2.y and y < (rm2.y + rm2.height):
xd = x-rm2.x
yd = y-rm2.y
xs = xd-28
if xd < (24) and a_s[yd>>2][xd>>2]:
pixels[x, y] = white.get()
pixels[x, y] = menu_get("right", 2)
elif xd > (27) and a_w[yd>>2][xs>>2]:
pixels[x, y] = white.get()
pixels[x, y] = menu_get("right", 2)
elif x >= rm3.x and x < (rm3.x + rm3.width) and y >= rm3.y and y < (rm3.y + rm3.height):
xd = x-rm3.x
yd = y-rm3.y
xs = xd-28
if xd < (24) and a_h[yd>>2][xd>>2]:
pixels[x, y] = white.get()
pixels[x, y] = menu_get("right", 3)
elif xd > (27) and a_w[yd>>2][xs>>2]:
pixels[x, y] = white.get()
pixels[x, y] = menu_get("right", 3)
img.save("output/alpha.png")
img.show()
graph.py
+91
View File
@@ -0,0 +1,91 @@
import matplotlib.pyplot as plt
import matplotlib.patheffects as path_effects
import matplotlib.ticker as ticker
# ==========================================
# 0. HELPER FUNCTION
# ==========================================
def format_val(x, pos=None):
"""Formats numbers to k/M format for axes and labels"""
if x >= 1_000_000:
return f"{x/1_000_000:.1f}".replace('.0', '') + 'M'
elif x >= 1000:
return f"{x/1000:.1f}".replace('.0', '') + 'k'
return str(int(x))
# ==========================================
# 1. EDIT YOUR DATA HERE
# ==========================================
labels = ['Tetris AI test CPU', 'tet_cpu_per_row', '4 tet_cpu_per_row']
values = [41700, 909000, 909000*4] # e.g., Speed, FPS, Transactions per second (Higher is better)
# Define your unit here (add a space at the start so it looks clean)
unit_label = "Moves per Second [Moves/sec]"
brand_color = '#00E5FF'
competitor_color = '#888888'
multiplier = values[1] / values[0]
max_val = max(values)
black_outline = [path_effects.withStroke(linewidth=3, foreground='black')]
# ==========================================
# 2. SETUP FIGURE
# ==========================================
fig, ax = plt.subplots(figsize=(10, 4.5))
fig.patch.set_alpha(0.0)
ax.patch.set_alpha(0.0)
bars = ax.barh(labels, values, color=[competitor_color, brand_color], height=0.45, zorder=3)
# ==========================================
# 3. CONFIGURE AXES
# ==========================================
# X-Axis Tick Formatting (The requested change)
ax.xaxis.set_major_formatter(ticker.FuncFormatter(format_val))
for spine in ax.spines.values():
spine.set_visible(False)
ax.spines['bottom'].set_visible(True)
ax.spines['bottom'].set_color('white')
ax.spines['bottom'].set_path_effects(black_outline)
ax.tick_params(axis='both', colors='white', labelsize=12)
for label in ax.get_xticklabels() + ax.get_yticklabels():
label.set_path_effects(black_outline)
ax.xaxis.grid(True, linestyle='--', color='white', alpha=0.3, zorder=0)
xlabel = ax.set_xlabel(unit_label, color='white', fontsize=12, labelpad=12, fontfamily='monospace')
xlabel.set_path_effects(black_outline)
# ==========================================
# 4. ADD BAR LABELS & BRACKET
# ==========================================
for bar, val in zip(bars, values):
width = bar.get_width()
txt = ax.text(width - (max_val * 0.02) if width >= (max_val*0.15) else width + (max_val*0.02),
bar.get_y() + bar.get_height()/2,
format_val(val),
ha='right' if width >= (max_val*0.15) else 'left',
va='center', color='white', fontsize=14, fontweight='bold')
txt.set_path_effects(black_outline)
# Draw Bracket
y0, y1 = [b.get_y() + b.get_height()/2 for b in bars]
x_line, x_tick = max_val * 1.05, max_val * 1.02
for x, y in zip([x_tick, x_tick, x_line], [y1, y0, [y0, y1]]):
l, = ax.plot([x_tick, x_line] if isinstance(y, (float, int)) else [x_line, x_line],
[y, y] if isinstance(y, (float, int)) else y, color=brand_color, lw=2)
l.set_path_effects(black_outline)
multiplier_txt = ax.text(x_line + (max_val * 0.03), (y0+y1)/2, f'{multiplier:.1f}x\nFASTER',
ha='left', va='center', color=brand_color, fontsize=22, fontweight='heavy')
multiplier_txt.set_path_effects(black_outline)
ax.set_xlim(0, max_val * 1.45)
plt.tight_layout()
plt.subplots_adjust(bottom=0.2)
plt.savefig('final_graph.png', dpi=300, bbox_inches='tight', transparent=True)
plt.show()
graph2.py
+92
View File
@@ -0,0 +1,92 @@
import matplotlib.pyplot as plt
import matplotlib.patheffects as path_effects
import matplotlib.ticker as ticker
# ==========================================
# 0. HELPER FUNCTION
# ==========================================
def format_val(x, pos=None):
"""Formats numbers to k/M format for axes and labels"""
if x >= 1_000_000:
return f"{x/1_000_000:.1f}".replace('.0', '') + 'M'
elif x >= 1000:
return f"{x/1000:.1f}".replace('.0', '') + 'k'
return str(int(x))
# ==========================================
# 1. EDIT YOUR DATA HERE
# ==========================================
labels = ['Tetris AI test CPU', 'tet_cpu_per_row', '4 tet_cpu_per_row']
values = [41700, 909000, 909000*4] # e.g., Speed, FPS, Transactions per second (Higher is better)
# Define your unit here (add a space at the start so it looks clean)
unit_label = "Moves per Second [Moves/sec]"
# Style choices
brand_color = '#00E5FF'
competitor_color = '#888888'
max_val = max(values)
# Bracket will compare the first and last (or you can change these indices)
start_val, end_val = values[0], values[-1]
multiplier = end_val / start_val
black_outline = [path_effects.withStroke(linewidth=3, foreground='black')]
# ==========================================
# 2. SETUP & DYNAMIC PLOTTING
# ==========================================
fig, ax = plt.subplots(figsize=(10, 6)) # Increased height for more labels
fig.patch.set_alpha(0.0)
ax.patch.set_alpha(0.0)
# Create color list: grey for all, brand_color for the last one
colors = [competitor_color] * (len(values) - 1) + [brand_color]
bars = ax.barh(labels, values, color=colors, height=0.5, zorder=3)
# Configure Axis
ax.xaxis.set_major_formatter(ticker.FuncFormatter(format_val))
for spine in ax.spines.values(): spine.set_visible(False)
ax.spines['bottom'].set_visible(True)
ax.spines['bottom'].set_color('white')
ax.spines['bottom'].set_path_effects(black_outline)
ax.tick_params(axis='both', colors='white', labelsize=12)
for label in ax.get_xticklabels() + ax.get_yticklabels():
label.set_path_effects(black_outline)
ax.xaxis.grid(True, linestyle='--', color='white', alpha=0.3, zorder=0)
xlabel = ax.set_xlabel(unit_label, color='white', fontsize=12, labelpad=12, fontfamily='monospace')
xlabel.set_path_effects(black_outline)
# Add Labels for each bar
for bar, val in zip(bars, values):
width = bar.get_width()
txt = ax.text(width - (max_val * 0.02) if width >= (max_val*0.15) else width + (max_val*0.02),
bar.get_y() + bar.get_height()/2,
format_val(val),
ha='right' if width >= (max_val*0.15) else 'left',
va='center', color='white', fontsize=12, fontweight='bold')
txt.set_path_effects(black_outline)
# ==========================================
# 3. DYNAMIC BRACKET (First vs Last)
# ==========================================
y_start, y_end = bars[0].get_y() + bars[0].get_height()/2, bars[-1].get_y() + bars[-1].get_height()/2
x_line, x_tick = max_val * 1.10, max_val * 1.07 # Shifted further right to accommodate N items
l1, = ax.plot([x_tick, x_line], [y_end, y_end], color=brand_color, lw=2)
l2, = ax.plot([x_tick, x_line], [y_start, y_start], color=brand_color, lw=2)
l3, = ax.plot([x_line, x_line], [y_start, y_end], color=brand_color, lw=2)
for l in [l1, l2, l3]: l.set_path_effects(black_outline)
mult_txt = ax.text(x_line + (max_val * 0.03), (y_start+y_end)/2,
f'{multiplier:.1f}x\nFASTER',
ha='left', va='center', color=brand_color, fontsize=18, fontweight='heavy')
mult_txt.set_path_effects(black_outline)
ax.set_xlim(0, max_val * 1.5)
plt.tight_layout()
plt.subplots_adjust(bottom=0.2)
plt.savefig('dynamic_comparison.png', dpi=300, transparent=True)
plt.show()
test.py
+33 -31
View File
@@ -1,12 +1,21 @@
import random
import os
import cv2
import numpy as np
from PIL import Image
width = 1280
height = 720
width = 200
height = 400
fps = 30 # Frames per second
total_frames = 240 # Increased to actually see the animation move
img = Image.new("RGB", (width, height))
# Ensure output directory exists
os.makedirs("output", exist_ok=True)
pixels = img.load()
# Define the VideoWriter
# 'mp4v' is a widely supported MP4 codec
fourcc = cv2.VideoWriter_fourcc(*"mp4v")
video_path = "output/rainbow.mp4"
video = cv2.VideoWriter(video_path, fourcc, fps, (width, height))
colors = (
(0xFF, 0x00, 0x00),
@@ -16,37 +25,30 @@ colors = (
(0x00, 0xFF, 0xFF),
(0x00, 0x00, 0xFF),
(0x8B, 0x00, 0xFF),
(0xFF, 0x00, 0xFF)
)
colors2 = (
(0xFF,0x00,0x00),
(0xFF,0x40,0x00),
(0xFF,0x80,0x00),
(0xFF,0xBF,0x00),
(0xFF,0xFF,0x00),
(0xBF,0xFF,0x00),
(0x80,0xFF,0x00),
(0x00,0xFF,0x00),
(0x00,0xFF,0x80),
(0x00,0xFF,0xFF),
(0x00,0x80,0xFF),
(0x00,0x00,0xFF),
(0x40,0x00,0xFF),
(0x80,0x00,0xFF),
(0xFF, 0x00, 0xFF),
(0xFF,0x00,0x80)
)
img = Image.new("RGB", (width, height))
pixels = img.load()
frame_num = 0
while frame_num < total_frames:
for y in range(height):
for x in range(width):
pixels[x, y] = colors[((x+y)>>4)&7]
# Adjusted the bit-shift so the animation moves visibly frame-by-frame
pixels[x, y] = colors[((x + y + (frame_num >> 1)) >> 4) & 7]
img.save("output/rainbow.png")
img.show()
# 1. Convert PIL Image to a NumPy array
frame_np = np.array(img)
for y in range(height):
for x in range(width):
pixels[x, y] = colors2[((x+y)>>4)&15]
# 2. Convert RGB (PIL format) to BGR (OpenCV format)
frame_bgr = cv2.cvtColor(frame_np, cv2.COLOR_RGB2BGR)
img.save("output/rainbow2.png")
img.show()
# 3. Write the frame to the video file
video.write(frame_bgr)
frame_num += 1
# Crucial: Release the video writer to finalize and save the file
video.release()
print(f"Video saved successfully to {video_path}")