テトリス Python+Cocos2d
tetris.py
"""Tetris Cocos2d."""
import random
import cocos
from cocos.director import director
import pyglet
def arena_to_pixel(ax, ay):
"""Convert arena coord to pixel coord."""
px = ax * (Cell.WIDTH + Cell.SPACING)
py = ay * (Cell.HEIGHT + Cell.SPACING)
return (px, py)
class Cell(cocos.sprite.Sprite):
"""Cell component."""
WIDTH = 32
HEIGHT = 32
SPACING = 1
IMAGE = pyglet.resource.image('square.png')
def __init__(self, acoord, color):
"""Ctor."""
super(Cell, self).__init__(Cell.IMAGE, color=color, anchor=(0, 0))
self.scale_x = Cell.WIDTH / Cell.IMAGE.width
self.scale_y = Cell.HEIGHT / Cell.IMAGE.height
self.set_arena_position(acoord[0], acoord[1])
def set_arena_position(self, ax, ay):
"""Set position in arena coord."""
self.ax = ax
self.ay = ay
self.position = arena_to_pixel(ax, ay)
def get_arena_position(self):
"""Get position in arena coord."""
return self.ax, self.ay
class Piece(cocos.cocosnode.CocosNode):
"""Piece consits with four cells."""
PATTERN = [
[(0, 0), (1, 0), (1, 1), (2, 1)], # S
[(1, 0), (2, 0), (0, 1), (1, 1)], # Z
[(0, 0), (1, 0), (0, 1), (0, 2)], # L
[(0, 0), (1, 0), (1, 1), (1, 2)], # J
[(1, 0), (0, 1), (1, 1), (2, 1)], # T
[(0, 0), (1, 0), (0, 1), (1, 1)], # O
[(0, 0), (1, 0), (2, 0), (3, 0)], # I
]
def __init__(self, pattern, position, drop_interval):
"""Ctor."""
super(Piece, self).__init__()
self.ax = 0
self.ay = 0
self.drop_interval = drop_interval
self.drop_time = drop_interval
self.alive = True
for p in pattern:
c = Cell(p, (255, 255, 255))
self.add(c)
self.set_arena_position(position[0], position[1])
self.clear_input()
def update(self, dt):
"""Update frame."""
# handle rotation
self.rotate(self.rotation_input)
if self._is_overlapping():
# cancel
self.rotate(-self.rotation_input)
# move left or right
self.move(self.move_input_dx, self.move_input_dy)
if self._is_overlapping():
# cancel
self.move(-self.move_input_dx, -self.move_input_dy)
# free fall
self.drop_time -= dt
if self.drop_time <= 0:
self.move(0, -1)
self.drop_time = self.drop_interval
if self._is_overlapping():
self.move(0, 1) # cancel drop
self._detach_cells()
self.alive = False
self.clear_input()
def set_arena_position(self, ax, ay):
"""Set position in arena coord."""
self.ax = ax
self.ay = ay
self.position = arena_to_pixel(self.ax, self.ay)
def move(self, dx, dy):
"""Move by offset."""
self.set_arena_position(self.ax + dx, self.ay + dy)
def rotate(self, rotation):
"""Rotate left (-1) or right (+1)."""
if rotation != -1 and rotation != 1:
return
for c in self.get_children():
cx, cy = c.get_arena_position()
new_x = +rotation * cy
new_y = -rotation * cx
c.set_arena_position(new_x, new_y)
def set_drop_interval(self, drop_interval):
"""Set drop intenval."""
self.drop_interval = drop_interval
def push_move_input(self, dx, dy):
"""Push move value for next update."""
self.move_input_dx += dx
self.move_input_dy += dy
def push_rotation_input(self, rotation):
"""Push rotation value for next update."""
# -1 is counter clock-wise (left)
# +1 is clock-wise (right)
# otherwise is no rotation
self.rotation_input = rotation
def clear_input(self):
"""Clear input values."""
self.move_input_dx = 0
self.move_input_dy = 0
self.rotation_input = 0
def _detach_cells(self):
"""Detach child cells and pass to parent."""
for cell in self.get_children():
(ax, ay) = cell.get_arena_position()
ax += self.ax
ay += self.ay
cell.set_arena_position(ax, ay)
self.remove(cell)
self.parent.add(cell)
def _is_overlapping(self):
"""Check if overlapping something."""
# check for left or right wall
if self.left() < 0 or self.right() >= Arena.WIDTH:
return True
# check landing on bottom
if self.bottom() < 0:
return True
# check for cells
arena_cells = [
c for c in self.parent.get_children() if isinstance(c, Cell)
]
for pcell in self.get_children():
px, py = pcell.get_arena_position()
px += self.ax
py += self.ay
for acell in arena_cells:
ax, ay = acell.get_arena_position()
if px == ax and py == ay:
return True
return False
def is_alive(self):
"""Return True if this piece is alive (not landing on)."""
return self.alive
def left(self):
"""Return left most cell position x."""
children = self.get_children()
if len(children) > 0:
return self.ax + min([c.get_arena_position()[0] for c in children])
else:
return self.ax
def right(self):
"""Return right most cell position x."""
children = self.get_children()
if len(children) > 0:
return self.ax + max([c.get_arena_position()[0] for c in children])
else:
return self.ax
def bottom(self):
"""Return down most cell position .y."""
children = self.get_children()
if len(children) > 0:
return self.ay + min([c.get_arena_position()[1] for c in children])
else:
return self.ay
class Arena(cocos.cocosnode.CocosNode):
"""Arena where cells put on."""
WIDTH = 10
HEIGHT = 20
def __init__(self, acoord):
"""Ctor."""
super(Arena, self).__init__()
self.set_arena_position(acoord[0], acoord[1])
def set_arena_position(self, ax, ay):
"""Set position in arena coord."""
self.ax = ax
self.ay = ay
self.position = arena_to_pixel(self.ax, self.ay)
class Game(cocos.layer.Layer):
"""Game player layer."""
is_event_handler = True
def __init__(self):
"""Ctor."""
super(Game, self).__init__()
self._setup_fence()
self.arena = Arena((1, 1))
self.add(self.arena)
self._respawn_piece()
self.schedule(self.update)
def update(self, dt):
"""Update frame."""
if self.piece.is_alive():
self.piece.update(dt)
else:
self.piece.kill()
self._cleanup_perfect_lines()
self._respawn_piece()
def on_key_press(self, key, modifiers):
"""Handle key press events."""
dx = 0
if key == pyglet.window.key.LEFT:
dx = -1
if key == pyglet.window.key.RIGHT:
dx = +1
self.piece.push_move_input(dx, 0)
rot = 0
if key == pyglet.window.key.UP:
rot = -1
if key == pyglet.window.key.DOWN:
rot = +1
self.piece.push_rotation_input(rot)
if key == pyglet.window.key.SPACE:
self.piece.set_drop_interval(0)
def _cleanup_perfect_lines(self):
"""Clean up cells on perfect line."""
line_cell_count = [0] * Arena.HEIGHT
cells = [c for c in self.arena.get_children() if isinstance(c, Cell)]
for cell in cells:
ay = cell.get_arena_position()[1]
if ay < Arena.HEIGHT:
line_cell_count[ay] += 1
for linum in range(Arena.HEIGHT - 1, -1, -1):
if line_cell_count[linum] == Arena.WIDTH:
removing_cells = []
for cell in cells:
ax, ay = cell.get_arena_position()
if ay > linum:
cell.set_arena_position(ax, ay - 1)
elif ay == linum:
removing_cells.append(cell)
for cell in removing_cells:
cells.remove(cell)
cell.kill()
def _respawn_piece(self):
"""Respawn new piece."""
self.piece = Piece(random.choice(Piece.PATTERN),
position=(Arena.WIDTH // 2, Arena.HEIGHT),
drop_interval=0.5)
self.arena.add(self.piece)
def _setup_fence(self):
"""Set up left and right walls, bottom floor."""
fence_color = (88, 88, 188)
for i in range(Arena.HEIGHT + 1):
left = Cell((0, i), fence_color)
right = Cell((Arena.WIDTH + 1, i), fence_color)
self.add(left)
self.add(right)
for i in range(1, Arena.WIDTH + 1):
bottom = Cell((i, 0), fence_color)
self.add(bottom)
game_width = (Arena.WIDTH + 2) * (Cell.WIDTH + Cell.SPACING) - Cell.SPACING
game_height = (Arena.HEIGHT + 1) * (Cell.HEIGHT + Cell.SPACING) - Cell.SPACING
director.init(width=game_width,
height=game_height,
caption="Tetris Cocos2d",
autoscale=False)
scene = cocos.scene.Scene(Game())
director.run(scene)