def __init__(self):
self.t = Tetris()
state_num = 2**(
4 * 8
) * 4 * 4 * 9 * 5 # 4x8 board [filled or not], 4*9 active-shape locations, 4 rotation positions, 5 shape types
action_num = 4 # rotate, left, right, step
#P = {s : {a : [] for a in range(action_num)} for s in range(state_num)}
init_state_dist = []
for x in range(4):
for rot in range(4):
for shape_type in range(5):
init_state_dist.append(encode([0, 0, x, rot, shape_type]))
init_state_dist = np.array(init_state_dist)
#init_state_dist /= init_state_dist.sum()
#super(TetrisEnv, self).__init__(state_num, action_num, P, init_state_dist)
self.action_space = spaces.Discrete(5)
self.observation_space = spaces.Tuple(
(spaces.Discrete(2**(4 * 8)), spaces.Discrete(4 * 9),
spaces.Discrete(4), spaces.Discrete(5)))
size = 2**(4 * 8) * 4 * 4 * 9 * 5
#-int(-np.log(2**(4*8)*4*4*9*5)/np.log(2))
self.observation_space.shape = np.zeros(size, dtype=int)
def run(self):
"""Run this game."""
clock = pygame.time.Clock()
count = 0
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
if self.mode == 1:
with open('data.json', 'w') as f:
json.dump({'record': self.record}, f)
exit()
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_RETURN:
if self.game.state == 0:
if self.game.score.points > self.record and self.mode == 1:
self.record = self.game.score.points
self.game = Tetris(WIDTH, HEIGHT, self.level,
self.mode == 1, None)
else:
self.paused = not self.paused
pressed = pygame.key.get_pressed()
if not self.paused:
if self.game.state == 1:
if self.mode == 0:
if self.timer.tick() == 0:
self.agent.play(self.game.current_tetromino,
self.game.grid)(self.game)
elif self.mode == 1:
self.interact(pressed)
self.game.update()
self.pressed = pressed
self.render()
clock.tick(60)
def run():
game = Tetris()
episodes = 2000
discount=0.9
epsilon=.99
nuerons=[32, 32, 32]
activation_functions=['relu', 'relu', 'relu', 'linear']
batchSize = 32
epoch = 5
trainIteration = 1
dqn = Agent(4, discount, epsilon, nuerons, activation_functions)
episodes = 2000
scores = []
for episode in range(episodes):
current = game.newGame()
gameOver, step = False, 0
renderEpisode = episode % 50 == 0
while not gameOver:
actions = game.getLegalActions()
bestAction, bestState = dqn.best_state(list(actions.keys()), list(actions.values()))
reward, gameOver = game.play(xLoc=bestAction[0], degrees=bestAction[1], render=renderEpisode)
dqn.add_sample(current, bestState, reward, gameOver)
current = bestState
scores.append(reward)
if episode % trainIteration == 0:
dqn.train(batch_size=batchSize, epoch=epoch)
def __init__(self, cfg):
self.num_states = cfg.MODEL.SIZE_STATE
self.num_actions = cfg.MODEL.SIZE_ACTION
self.num_episodes = cfg.SOLVER.NUM_EPISODES
self.tetris = Tetris(cfg)
self.agent = Agent(cfg,self.tetris)
class Keyboard:
def __init__(self):
self.T = Tetris(action_type='single', is_display=True)
def run(self):
while True:
state = self.T.reset()
done = False
while not done:
flag = False
for evt in pygame.event.get():
if evt.type == pygame.QUIT:
exit()
if evt.type == pygame.KEYDOWN:
for idx, key in enumerate(key_actions):
if evt.key == eval("pygame.K_" + key):
state, _, done, _, _ = self.T.step(idx)
flag = True
pygame.time.wait(delay_time[idx])
keys_pressed = pygame.key.get_pressed()
if not flag:
for idx, key in enumerate(key_actions):
key = eval("pygame.K_" + key)
if keys_pressed[key]:
state, _, done, _, _ = self.T.step(idx)
if idx == [3, 4, 5, 6]:
pygame.time.wait(delay_time[idx])
pygame.time.wait(10)
def __init__(self):
self.t = Tetris()
self.action_space = spaces.Discrete(5)
self.observation_space = spaces.Tuple(
(spaces.Discrete(32), spaces.Discrete(4)))
self.seed()
def consumer(self, msg):
if self.game is None:
if 'snake' in msg:
self.game = Snake(20, 25)
self.run_thread()
if 'tetris' in msg:
self.game = Tetris(20, 25)
self.run_thread()
else:
# fire all of the events
if len(msg) > 0:
#with self.lock:
if 'left' in msg:
self.eventwatcher += self.game.on_left
elif 'right' in msg:
self.eventwatcher += self.game.on_right
elif 'up' in msg:
self.eventwatcher += self.game.on_up
elif 'down' in msg:
self.eventwatcher += self.game.on_down
elif 'abutton' in msg:
self.eventwatcher += self.game.on_a
elif 'bbutton' in msg:
self.eventwatcher += self.game.on_b
def main():
game = Tetris()
try:
game.start_game()
except Exception:
pass
curses.endwin()
def start_tetris(self):
self.tetris = Tetris(self.app.ipcon)
if self.tetris.okay:
self.tetris.run_game_loop()
self.tetris = None
def main():
game = Tetris(width=10, height=12)
while not game.isFinished:
# One game update
game.update()
print(game)
time.sleep(0.2)
def get_fitness(self, chromosome, seed):
"""Return the fitness of a given chromosome."""
agent = Agent(chromosome.chromosome)
game = Tetris(WIDTH, HEIGHT, 0, 0, seed) # simulate a game of Tetris
while game.state != 0:
agent.play(game.current_tetromino, game.grid)(game)
game.update()
chromosome.fitness = game.score.score
print(f'Fitness: {chromosome.fitness}')
return chromosome
def playTetris(screen):
graphics = TetrisGraphicsCurses(screen)
controls = TetrisControlsCurses(screen)
tetris = Tetris()
while (tetris.state != Tetris.State.END):
action = controls.readTetrisAction(tetris.state)
actionOutput = tetris.action(action)
tetrisOutput = tetris.update()
for out in actionOutput, tetrisOutput:
graphics.update(out)
def start_game():
global game
game = Tetris()
game.start()
global action_report
action_report = game.move_piece('up')
return json.dumps(action_report.state)
def __init__(self):
self.game = Tetris()
self.led_display = LED_Module()
self.led = MAX7219()
self.to_show_led = ""
self.showed_led = ""
self.to_show_matrix = []
self.showed_matrix = []
self.state = ""
self.change_state("PLAY")
self.num = 0
def lineClearIntegrationTest():
height = 5
width = 4
tetris = Tetris(height, width)
tetris.tetro = Tetromino(height - 1, 0, Tetris.TetrominoKind.I)
tetris.state = Tetris.State.PLACE
out = tetris.update()
assert (out != None and Tetris.Output.LINE_CLEAR in out)
_, clearedLines = out
assert (clearedLines == [4])
class Game:
def __init__(self, p):
self.die = False
self.tetris = Tetris(20, 2, 20)
self.bot = Bot(self.tetris, p)
def draw(self):
if not self.die:
self.bot.run()
self.tetris.run()
if self.tetris.die:
self.die = True
def fallActuallyFalls():
tetris = Tetris(20, 10)
tetris.state == Tetris.State.FALLING
tetro0 = Tetromino(0, 0, Tetris.TetrominoKind.O)
tetris.tetro = copy.copy(tetro0)
tetro1 = tetris.tetro
tetris.moveDown(1)
assert (tetro0.tetroKind == tetro1.tetroKind)
assert (tetro0.col == tetro1.col)
assert (tetro0.row + 1 == tetro1.row)
def __init__(self):
super(TetrisEnv, self).__init__()
self.game = Tetris()
self.action_list = [
self.game.left, self.game.right, self.game.up, self.game.down,
self.rotatel, self.rotater, self.game.hold
]
# up down left right hold rotateleft rotateright
self.action_space = spaces.Discrete(7)
self.observation_space = spaces.MultiDiscrete([2] * Tetris.width *
Tetris.height + [8] * 7 +
[8] + [2] + [8] + [4] +
[10] + [20])
self.reset()
def materializeNewTetrominoAfterPlace():
tetris = Tetris(10, 10)
tetris.state = Tetris.State.PLACE
tetris.tetro = Tetromino(0, 5, Tetris.TetrominoKind.O)
tetris.place()
assert (tetris.state == Tetris.State.MATERIALIZE)
tetris.materialize()
assert (tetris.tetro.row == 0)
def placeAfterFallingEnough():
tetris = Tetris()
tetris.state = Tetris.State.FALLING
tetris.tetro = Tetromino(0, 0, Tetris.TetrominoKind.Z)
tetris.moveDown(tetris.height)
assert (tetris.state == Tetris.State.FALLING)
tetris.moveDown(1)
assert (tetris.state == Tetris.State.PLACE)
def __init__(self, stdscr):
self.stdscr = stdscr
self.init_curses()
self.game_win = curses.newwin(visible_rows, block_width * num_cols, 0,
0)
self.info_win = curses.newwin(10, 20, 0, block_width * num_cols)
self.debug_win = curses.newwin(10, 20, 10, block_width * num_cols)
self.tetris = Tetris()
self.pause = False
self.debug = False
self.fps_counter = 0
self.frames_this_second = 0
self.start_fps_timer = 0
def getSimulator(self, simulator):
if simulator == "logistics":
return Logistics(start=True)
elif simulator == "pong":
return Pong(start=True)
elif simulator == "tetris":
return Tetris(start=True)
elif simulator == "wumpus":
return Wumpus(start=True)
elif simulator == "blocks":
return Blocks_world(start=True)
elif simulator == "blackjack":
return Game(start=True)
elif simulator == "50chain":
return Chain(start=True)
elif simulator == "net_admin":
return Admin(start=True)
else:
print('{} is not a supported simulation'.format(simulator))
raise NameError()
def __init__(self,FA="LSReg",domain="50chain",N=100,loss="ls",trees=500,type="max",depth=2):
'''class constructor'''
self.domain = domain
if domain == "50chain":
self.domObj = Chain()
elif domain == "blackjack":
self.domObj = Game()
elif domain == "wumpus":
self.domObj = Grid(4)
elif domain == "blocksworld":
self.domObj = BW(4)
elif domain == "traffic":
self.domObj = TrafficSignal()
elif domain == "pong":
self.domObj = Pong()
elif domain == "tetris":
self.domObj = Tetris()
if FA == "LSReg":
self.FA = LSReg()
elif FA == "NN":
self.FA = NeuralNetwork()
elif FA == "GB":
self.FA = GradientBooster(loss=loss,trees=trees,depth=depth)
self.value,self.count = {},{}
self.values = [{} for i in range(N)]
self.approxValues = [{} for i in range(N)]
self.BE = []
self.type = type
self.TD(self.FA,N)
def new_client(client, server):
global tetris, command, first_run
id = client['id']
print("New client(%d) connected" % id)
tetris.insert(id, Tetris())
command.insert(id, "")
print("Game created")
def make_env(): #env = gym.envs.make(FLAGS.env) # remove the timelimitwrapper #env = env.env #if wrap: # env = atari_helpers.AtariEnvWrapper(env) return Tetris(action_type = FLAGS.action_type,use_fitness=True)
def getSample(self):
'''gets a sample trajectory from
the specified domain
'''
d = Chain()
if self.domain == "blackjack":
d = Game()
elif self.domain == "wumpus":
d = Grid(4)
elif self.domain == "blocksworld":
d = BW(4)
elif self.domain == "traffic":
d = TrafficSignal()
elif self.domain == "pong":
d = Pong()
elif self.domain == "tetris":
d = Tetris()
#elif wumpus
sample = []
state = d
actions = d.actions
while True:
if state == "winner" or state == "loser":
sample += [deepcopy(state)]
break
sample += [deepcopy(str(state))]
action = actions[randint(0,len(actions)-1)]
state = d.takeAction(state,action)
return sample
def __init__(self, shadowsEnabled=True, automated=False):
self.game = Tetris()
Tk.__init__(self)
self.canvas = Canvas(self,
width=TetrisWindow.DEFAULT_WIDTH,
height=TetrisWindow.DEFAULT_HEIGHT)
self.canvas.pack(fill=BOTH, expand=1)
self.needToRedraw = False
self.shadowsEnabled = shadowsEnabled
if not automated:
self.refreshTimerFired()
self.canvas.after(1000, self.gameTimerFired)
self.bind("<Button-1>", self.mousePressed)
self.bind("<Key>", self.keyPressed)
self.canvas.bind("<Configure>", self.onResize)
def __init__(self):
self.t = Tetris()
state_num = 2**(4*8)*4*4*9*5 # 4x8 board [filled or not], 4*9 active-shape locations, 4 rotation positions, 5 shape types
action_num = 4 # rotate, left, right, step
P = {s : {a : [] for a in range(action_num)} for s in range(state_num)}
init_state_dist = []
for x in range(4):
for rot in range(4):
for shape_type in range(5):
init_state_dist.append( encode([0, 0, x, rot, shape_type]) )
init_state_dist = np.array(init_state_dist)
init_state_dist /= init_state_dist.sum()
super(TetrisEnv, self).__init__(state_num, action_num, P, init_state_dist)
def hand_crafted():
env = Tetris()
current_state = env.reset()
done = False
steps = 0
agent = Handcrafted_agent(env.get_state_size())
# Game
while not done:
next_states = env.get_next_states_handcrafted()
best_state = agent.best_state(next_states.values())
best_action = None
for action, state in next_states.items():
if state == best_state:
best_action = action
break
reward, done = env.play(best_action[0], best_action[1], render=True,
render_delay=None)
current_state = next_states[best_action]
steps += 1
return env.get_game_score()
def __init__(self, d):
display.App.__init__(self, d)
self.menu_items = [('Clock', Clock(d)), ('Tetris', Tetris(d)),
('Snake', Snake(d)), ('Off', Blank(d))]
self.selected = 0
self.font = pygame.font.Font("fonts/5x7.pcf", 7)
class TetrisWidget(QWidget, Ui_Tetris):
tetris = None
thread = None
def __init__(self, parent, app):
super(QWidget, self).__init__()
self.app = app
self.setupUi(self)
self.button_a.pressed.connect(lambda: self.button_press('a'))
self.button_s.pressed.connect(lambda: self.button_press('s'))
self.button_d.pressed.connect(lambda: self.button_press('d'))
self.button_k.pressed.connect(lambda: self.button_press('k'))
self.button_l.pressed.connect(lambda: self.button_press('l'))
self.button_r.pressed.connect(lambda: self.button_press('r'))
def start_tetris(self):
self.tetris = Tetris(self.app.ipcon)
if self.tetris.okay:
self.tetris.run_game_loop()
self.tetris = None
def button_press(self, button):
if self.tetris:
self.tetris.kp.key_queue.put(button)
def start(self):
self.thread = Thread(target=self.start_tetris)
self.thread.daemon = True
self.thread.start()
def stop(self):
if self.tetris:
self.tetris.loop = False
self.tetris.kp.key_queue.put('q')
class QTetris(QWidget):
class QTile(QGraphicsObject):
colorMap = {Tetris.I: QColor("#53bbf4"), Tetris.J: QColor("#e25fb8"),
Tetris.L: QColor("#ffac00"), Tetris.O: QColor("#ecff2e"),
Tetris.S: QColor("#97eb00"), Tetris.T: QColor("#ff85cb"),
Tetris.Z: QColor("#ff5a48")}
def __init__(self, qTetris: 'QTetris', tetrimino: Tetris.Tetrimino, tile: Tetris.Tile):
super(QTetris.QTile, self).__init__()
tile.delegate = self
self.color = self.colorMap[type(tetrimino)]
self.qTetris = qTetris
self.moveAnimation = QParallelAnimationGroup()
self.dropAnimation = QPropertyAnimation(self, b'pos')
self.collapseAnimation = QPropertyAnimation(self, b'pos')
self.shiftAnimation = QPropertyAnimation(self, b'pos')
self.collapseAnimation.finished.connect(lambda tl=tile: tile.delegate.disappeared(tl))
self.qTetris.scene.addItem(self)
self.setPos(QPointF(0, 4))
self.moved(tile)
def moved(self, tile: Tetris.Tile):
translation = QPropertyAnimation(self, b'pos')
start, end = self.pos(), QPointF(tile.row, tile.column)
curve, speed, delay = QEasingCurve.OutBack, 1 / 50, -1
self.animate(translation, start, end, curve, speed, delay)
rotation = QPropertyAnimation(self, b'rotation')
start, end = self.rotation(), tile.rotation
curve, speed, delay = QEasingCurve.OutBack, 1, -1
self.animate(rotation, start, end, curve, speed, delay)
rotation.setDuration(translation.duration())
self.moveAnimation.clear()
self.moveAnimation.addAnimation(translation)
self.moveAnimation.addAnimation(rotation)
self.moveAnimation.start()
def dropped(self, tile: Tetris.Tile):
start, end = self.pos(), QPointF(tile.row, tile.column)
curve, speed, delay = QEasingCurve.OutBounce, 1 / 50, 0
self.animate(self.dropAnimation, start, end, curve, speed, delay)
def collapsed(self, tile: Tetris.Tile):
start, end = self.pos(), QPointF(tile.row, tile.column + 2 * tile.tetris.num_columns)
curve, speed, delay = QEasingCurve.InOutExpo, 1 / 50, 800
if self.dropAnimation.state() == QAbstractAnimation.Running:
start = self.dropAnimation.endValue()
self.animate(self.collapseAnimation, start, end, curve, speed, delay)
def shifted(self, tile: Tetris.Tile):
start, end = self.pos(), QPointF(tile.row, tile.column)
curve, speed, delay = QEasingCurve.OutBounce, 1 / 100, 1200
if self.dropAnimation.state() == QAbstractAnimation.Running:
start = self.dropAnimation.endValue()
self.animate(self.shiftAnimation, start, end, curve, speed, delay)
def disappeared(self, tile: Tetris.Tile):
self.qTetris.scene.removeItem(self)
def paint(self, painter: QPainter, styleOption: QStyleOptionGraphicsItem, widget: QWidget=None):
pen = QPen()
pen.setWidthF(0.05)
pen.setColor(Qt.darkGray)
painter.setPen(pen)
brush = QBrush()
brush.setColor(self.color)
brush.setStyle(Qt.SolidPattern)
painter.setBrush(brush)
topLeft = QPointF(0, 0)
bottomRight = QPointF(1, 1)
rectangle = QRectF(topLeft, bottomRight)
rectangle.translate(-0.5, -0.5)
painter.drawRect(rectangle)
@staticmethod
def animate(animation: QPropertyAnimation, start: Union[QPointF, int, float], end: Union[QPointF, int, float],
curve: QEasingCurve=QEasingCurve.Linear, speed: float=1 / 50, delay: int=-1):
animation.setStartValue(start)
animation.setEndValue(end)
animation.setEasingCurve(curve)
if type(start) == type(end) == QPointF:
distance = (end - start).manhattanLength()
else:
distance = abs(end - start)
animation.setDuration(round(distance / speed))
if delay == 0:
animation.start()
if delay > 0:
QTimer.singleShot(delay, animation.start)
def boundingRect(self):
topLeft = QPointF(0, 0)
bottomRight = QPointF(1, 1)
rectangle = QRectF(topLeft, bottomRight)
rectangle.translate(-0.5, -0.5)
return rectangle
class QScene(QGraphicsScene):
def __init__(self, tetris: Tetris):
super(QTetris.QScene, self).__init__()
self.tetris = tetris
pen = QPen()
pen.setWidthF(0.05)
pen.setColor(Qt.lightGray)
brush = QBrush(Qt.NoBrush)
rect = QRectF(0, 0, tetris.num_rows, tetris.num_columns)
rect.translate(-0.5, -0.5)
self.setSceneRect(rect)
self.addRect(rect, pen, brush)
self.setBackgroundBrush(self.palette().window())
for column in range(0, tetris.num_columns, 2):
pen = QPen(Qt.NoPen)
brush = QBrush(Qt.SolidPattern)
brush.setColor(Qt.lightGray)
topLeft = QPointF(0, column)
bottomRight = QPointF(tetris.num_rows, column + 1)
rectangle = QRectF(topLeft, bottomRight)
rectangle.translate(-0.5, -0.5)
self.addRect(rectangle, pen, brush)
def mouseMoveEvent(self, sceneMouseEvent: QGraphicsSceneMouseEvent):
mousePoint = sceneMouseEvent.scenePos()
mouseRow, mouseColumn = round(mousePoint.x()), round(mousePoint.y())
row, column = self.tetris.falling_tetrimino.row, self.tetris.falling_tetrimino.column
if mouseColumn - column > 0:
self.tetris.move_right()
if mouseColumn - column < 0:
self.tetris.move_left()
def mouseReleaseEvent(self, sceneMouseEvent: QGraphicsSceneMouseEvent):
if sceneMouseEvent.button() == Qt.LeftButton:
self.tetris.drop()
if sceneMouseEvent.button() == Qt.RightButton:
self.tetris.rotate()
def wheelEvent(self, sceneWheelEvent: QGraphicsSceneWheelEvent):
if sceneWheelEvent.delta() > 10:
self.tetris.move_down()
def keyReleaseEvent(self, sceneKeyEvent: QKeyEvent):
if sceneKeyEvent.key() == Qt.Key_Left:
self.tetris.move_left()
if sceneKeyEvent.key() == Qt.Key_Right:
self.tetris.move_right()
if sceneKeyEvent.key() == Qt.Key_Down:
self.tetris.move_down()
if sceneKeyEvent.key() == Qt.Key_Up:
self.tetris.rotate()
class QView(QGraphicsView):
def __init__(self, scene: 'QTetris.QScene'):
super(QTetris.QView, self).__init__()
self.setTransform(QTransform().rotate(+90).scale(+1, -1))
self.setMinimumSize(100, 200)
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setRenderHints(QPainter.Antialiasing)
self.setFrameStyle(QFrame.NoFrame)
self.setMouseTracking(True)
self.setScene(scene)
def __init__(self):
super(QTetris, self).__init__()
self.tetris = None
self.timer = None
self.initGame()
self.view = None
self.scene = None
self.initUI()
self.show()
self.tetris.spawn()
self.timer.start()
def initGame(self):
self.tetris = Tetris()
self.tetris.delegate = self
self.timer = QTimer(self)
self.timer.setInterval(350)
self.timer.timeout.connect(lambda: self.tetris.tick())
def initUI(self):
self.setLayout(QGridLayout())
self.layout().setSpacing(0)
self.layout().setContentsMargins(0, 0, 0, 0)
self.scene = QTetris.QScene(self.tetris)
self.view = QTetris.QView(self.scene)
self.layout().addWidget(self.view)
self.scored(0)
def appeared(self, tetrimino: Tetris.Tetrimino):
for tile in tetrimino:
QTetris.QTile(self, tetrimino, tile)
def scored(self, score: int):
self.setWindowTitle(self.tr("Tetris - {score}").format(score=score))
def terminated(self):
QMessageBox.critical(self, self.tr("Game Over!"), self.tr("You toppped out."), QMessageBox.Ok)
self.tetris.restart()
def resizeEvent(self, resizeEvent: QResizeEvent):
boundingRect = self.scene.itemsBoundingRect()
self.view.fitInView(boundingRect, Qt.KeepAspectRatio)
self.view.centerOn(boundingRect.center())
def sizeHint(self) -> QSize:
return QSize(self.tetris.num_columns * 22, self.tetris.num_rows * 22)
from tetris import Tetris game = Tetris() game.initialize_game() game.start()
def initGame(self):
self.tetris = Tetris()
self.tetris.delegate = self
self.timer = QTimer(self)
self.timer.setInterval(350)
self.timer.timeout.connect(lambda: self.tetris.tick())
