def test_Renderer_draw_rect(self):
surface = SDL_CreateRGBSurface(0, 128, 128, 32, 0, 0, 0, 0).contents
sdl2ext.fill(surface, 0x0)
renderer = sdl2ext.Renderer(surface)
renderer.draw_rect((40, 50, 32, 32), 0x0000FF)
view = sdl2ext.PixelView(surface)
self.check_lines(view, 128, 128, [
((40, 50), (71, 50)),
((40, 50), (40, 81)),
((40, 81), (71, 81)),
((71, 50), (71, 81))], 0x0000FF, (0x0,))
del view
sdl2ext.fill(surface, 0x0)
renderer.draw_rect([(5, 5, 10, 10), (20, 15, 8, 10)], 0x0000FF)
view = sdl2ext.PixelView(surface)
self.check_lines(view, 128, 128, [
((5, 5), (14, 5)),
((5, 5), (5, 14)),
((5, 14), (14, 14)),
((14, 5), (14, 14)),
((20, 15), (27, 15)),
((20, 15), (20, 24)),
((20, 24), (27, 24)),
((27, 15), (27, 24))], 0x0000FF, (0x0,))
del view
def test_SpriteFactory(self):
factory = sdl2ext.SpriteFactory(sdl2ext.SOFTWARE)
assert isinstance(factory, sdl2ext.SpriteFactory)
assert factory.default_args == {}
factory = sdl2ext.SpriteFactory(sdl2ext.SOFTWARE, bananas="tasty")
assert isinstance(factory, sdl2ext.SpriteFactory)
assert factory.default_args == {"bananas": "tasty"}
window = sdl2ext.Window("Test", size=(1, 1))
renderer = sdl2ext.Renderer(window)
factory = sdl2ext.SpriteFactory(sdl2ext.TEXTURE, renderer=renderer)
assert isinstance(factory, sdl2ext.SpriteFactory)
factory = sdl2ext.SpriteFactory(sdl2ext.TEXTURE, renderer=renderer)
assert isinstance(factory, sdl2ext.SpriteFactory)
assert factory.default_args == {"renderer": renderer}
with pytest.raises(ValueError):
sdl2ext.SpriteFactory("Test")
with pytest.raises(ValueError):
sdl2ext.SpriteFactory(-456)
with pytest.raises(ValueError):
sdl2ext.SpriteFactory(123)
with pytest.raises(ValueError):
sdl2ext.SpriteFactory(sdl2ext.TEXTURE)
dogc()
def main():
#cause I don't want to pass these around
global WINDOW, REN, SPRITE_FACTORY, SPRITE_RENDERER, MUSIC
SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO)
WINDOW = ext.Window("Tetromino", size=(WINDOWWIDTH, WINDOWHEIGHT))
REN = ext.Renderer(WINDOW)
WINDOW.show()
font_file = sysfont.get_font("freesans", sysfont.STYLE_BOLD)
font_manager = ext.FontManager(font_file, size=18)
#fontmanager=font_manager will be default_args passed to every sprite creation method
SPRITE_FACTORY = ext.SpriteFactory(renderer=REN,
fontmanager=font_manager,
free=True)
SPRITE_RENDERER = SPRITE_FACTORY.create_sprite_render_system(WINDOW)
sdlmixer.Mix_Init(sdlmixer.MIX_INIT_OGG)
sdlmixer.Mix_OpenAudio(22050, sdlmixer.MIX_DEFAULT_FORMAT, 2, 1024)
#BEEP1 = sdlmixer.Mix_LoadWAV(b"beep1.ogg")
showTextScreen("Tetromino")
while True:
if random.randint(0, 1) == 0:
MUSIC = sdlmixer.Mix_LoadMUS(b"tetrisb.mid")
else:
MUSIC = sdlmixer.Mix_LoadMUS(b"tetrisc.mid")
sdlmixer.Mix_PlayMusic(MUSIC, -1)
runGame()
sdlmixer.Mix_HaltMusic()
showTextScreen("Game Over")
def init(windowname='ZOMG FORGOT TO NAME IT', width=640, height=400):
global renderer, window, window_width, window_height
window_width = width
window_height = height
sdl.init()
window = sdl.Window(windowname, size=(window_width, window_height))
window.show()
renderer = sdl.Renderer(window)
def test_Renderer_draw_line(self):
surface = SDL_CreateRGBSurface(0, 128, 128, 32, 0, 0, 0, 0).contents
sdl2ext.fill(surface, 0x0)
renderer = sdl2ext.Renderer(surface)
renderer.draw_line((20, 10, 20, 86), 0x0000FF)
view = sdl2ext.PixelView(surface)
self.check_lines(view, 128, 128, [((20, 10), (20, 86))], 0x0000FF,
(0x0, ))
del view
def __init__(self, entities, timer):
self.entities = entities
self.timer = timer
self.window = sdle.Window("Game", size=(self.WINDOW_X, self.WINDOW_Y))
self.renderer = sdle.Renderer(self.window,
flags=sdl.SDL_RENDERER_ACCELERATED)
self.texture = sdl.SDL_CreateTexture(self.renderer.renderer,
sdl.SDL_PIXELFORMAT_ARGB8888,
sdl.SDL_TEXTUREACCESS_STREAMING,
self.WINDOW_X, self.WINDOW_Y)
self.window.show()
def test_Renderer_copy(self):
surface = SDL_CreateRGBSurface(0, 128, 128, 32, 0, 0, 0, 0).contents
sdl2ext.fill(surface, 0x0)
renderer = sdl2ext.Renderer(surface)
factory = sdl2ext.SpriteFactory(sdl2ext.TEXTURE, renderer=renderer)
w, h = 32, 32
sp = factory.from_color(0xFF0000, (w, h))
sp.x, sp.y = 40, 50
renderer.copy(sp, (0, 0, w, h), (sp.x, sp.y, w, h))
view = sdl2ext.PixelView(surface)
self.check_pixels(view, 128, 128, sp, 0xFF0000, (0x0, ))
del view
def test_Renderer(self):
sf = SDL_CreateRGBSurface(0, 10, 10, 32, 0, 0, 0, 0).contents
renderer = sdl2ext.Renderer(sf)
self.assertEqual(renderer.rendertarget, sf)
self.assertIsInstance(renderer.sdlrenderer.contents, SDL_Renderer)
del renderer
# Deprecated
renderer = sdl2ext.Renderer(sf)
self.assertEqual(renderer.rendertarget, sf)
self.assertIsInstance(renderer.renderer.contents, SDL_Renderer)
del renderer
sprite = sdl2ext.SoftwareSprite(sf, True)
renderer = sdl2ext.Renderer(sprite)
self.assertEqual(renderer.rendertarget, sprite)
self.assertIsInstance(renderer.sdlrenderer.contents, SDL_Renderer)
del renderer
dogc()
window = sdl2ext.Window("Test", size=(1, 1))
renderer = sdl2ext.Renderer(window)
self.assertEqual(renderer.rendertarget, window)
self.assertIsInstance(renderer.sdlrenderer.contents, SDL_Renderer)
del renderer
dogc()
sdlwindow = window.window
renderer = sdl2ext.Renderer(sdlwindow)
self.assertEqual(renderer.rendertarget, sdlwindow)
self.assertIsInstance(renderer.sdlrenderer.contents, SDL_Renderer)
del renderer
del window
self.assertRaises(TypeError, sdl2ext.Renderer, None)
self.assertRaises(TypeError, sdl2ext.Renderer, 1234)
self.assertRaises(TypeError, sdl2ext.Renderer, "test")
dogc()
def test_Renderer(self):
sf = SDL_CreateRGBSurface(0, 10, 10, 32, 0, 0, 0, 0).contents
renderer = sdl2ext.Renderer(sf)
assert renderer.rendertarget == sf
assert isinstance(renderer.sdlrenderer.contents, SDL_Renderer)
del renderer
# Deprecated
renderer = sdl2ext.Renderer(sf)
assert renderer.rendertarget == sf
assert isinstance(renderer.sdlrenderer.contents, SDL_Renderer)
del renderer
sprite = sdl2ext.SoftwareSprite(sf, True)
renderer = sdl2ext.Renderer(sprite)
assert renderer.rendertarget == sprite
assert isinstance(renderer.sdlrenderer.contents, SDL_Renderer)
del renderer
dogc()
window = sdl2ext.Window("Test", size=(1, 1))
renderer = sdl2ext.Renderer(window)
assert renderer.rendertarget == window
assert isinstance(renderer.sdlrenderer.contents, SDL_Renderer)
del renderer
dogc()
sdlwindow = window.window
renderer = sdl2ext.Renderer(sdlwindow)
assert renderer.rendertarget == sdlwindow
assert isinstance(renderer.sdlrenderer.contents, SDL_Renderer)
del renderer
del window
with pytest.raises(TypeError):
sdl2ext.Renderer(None)
with pytest.raises(TypeError):
sdl2ext.Renderer(1234)
with pytest.raises(TypeError):
sdl2ext.Renderer("test")
dogc()
def test_SpriteFactory_create_texture_sprite(self):
window = sdl2ext.Window("Test", size=(1, 1))
renderer = sdl2ext.Renderer(window)
factory = sdl2ext.SpriteFactory(sdl2ext.TEXTURE, renderer=renderer)
for w in range(1, 100):
for h in range(1, 100):
sprite = factory.create_texture_sprite(renderer, size=(w, h))
self.assertIsInstance(sprite, sdl2ext.TextureSprite)
del sprite
# Test different access flags
for flag in (SDL_TEXTUREACCESS_STATIC, SDL_TEXTUREACCESS_STREAMING,
SDL_TEXTUREACCESS_TARGET):
sprite = factory.create_texture_sprite(renderer, size=(64, 64),
access=flag)
self.assertIsInstance(sprite, sdl2ext.TextureSprite)
del sprite
dogc()
def test_SpriteFactory_create_sprite(self):
window = sdl2ext.Window("Test", size=(1, 1))
renderer = sdl2ext.Renderer(window)
tfactory = sdl2ext.SpriteFactory(sdl2ext.TEXTURE, renderer=renderer)
sfactory = sdl2ext.SpriteFactory(sdl2ext.SOFTWARE)
for w in range(0, 100):
for h in range(0, 100):
for bpp in (1, 4, 8, 12, 15, 16, 24, 32):
sprite = sfactory.create_sprite(size=(w, h), bpp=bpp)
assert isinstance(sprite, sdl2ext.SoftwareSprite)
if w == 0 or h == 0:
with pytest.raises(sdl2ext.SDLError):
tfactory.create_sprite(size=(w, h))
continue
sprite = tfactory.create_sprite(size=(w, h))
assert isinstance(sprite, sdl2ext.TextureSprite)
dogc()
def test_Renderer_clear(self):
sf = SDL_CreateRGBSurface(0, 10, 10, 32, 0xFF000000, 0x00FF0000,
0x0000FF00, 0x000000FF)
renderer = sdl2ext.Renderer(sf.contents)
self.assertIsInstance(renderer.color, sdl2ext.Color)
self.assertEqual(renderer.color, sdl2ext.Color(0, 0, 0, 0))
renderer.color = 0x00FF0000
self.assertEqual(renderer.color, sdl2ext.Color(0xFF, 0, 0, 0))
renderer.clear()
view = sdl2ext.PixelView(sf.contents)
self.check_areas(view, 10, 10, [[0, 0, 10, 10]], 0xFF000000, (0x0, ))
del view
renderer.clear(0xAABBCCDD)
self.assertEqual(renderer.color, sdl2ext.Color(0xFF, 0, 0, 0))
view = sdl2ext.PixelView(sf.contents)
self.check_areas(view, 10, 10, [[0, 0, 10, 10]], 0xBBCCDDAA, (0x0, ))
del view
del renderer
SDL_FreeSurface(sf)
dogc()
def test_SpriteFactory_from_image(self):
window = sdl2ext.Window("Test", size=(1, 1))
renderer = sdl2ext.Renderer(window)
tfactory = sdl2ext.SpriteFactory(sdl2ext.TEXTURE, renderer=renderer)
sfactory = sdl2ext.SpriteFactory(sdl2ext.SOFTWARE)
for suffix in ("tif", "png", "jpg"):
imgname = RESOURCES.get_path("surfacetest.%s" % suffix)
tsprite = tfactory.from_image(imgname)
self.assertIsInstance(tsprite, sdl2ext.TextureSprite)
ssprite = sfactory.from_image(imgname)
self.assertIsInstance(ssprite, sdl2ext.SoftwareSprite)
for factory in (tfactory, sfactory):
self.assertRaises((ArgumentError, ValueError), factory.from_image,
None)
#self.assertRaises((IOError, SDLError),
# factory.from_image, "banana")
if not _ISPYPY:
self.assertRaises(ArgumentError, factory.from_image, 12345)
dogc()
def test_SpriteFactory_from_surface(self):
window = sdl2ext.Window("Test", size=(1, 1))
renderer = sdl2ext.Renderer(window)
tfactory = sdl2ext.SpriteFactory(sdl2ext.TEXTURE, renderer=renderer)
sfactory = sdl2ext.SpriteFactory(sdl2ext.SOFTWARE)
sf = SDL_CreateRGBSurface(0, 10, 10, 32, 0, 0, 0, 0)
tsprite = tfactory.from_surface(sf.contents)
self.assertIsInstance(tsprite, sdl2ext.TextureSprite)
ssprite = sfactory.from_surface(sf.contents)
self.assertIsInstance(ssprite, sdl2ext.SoftwareSprite)
SDL_FreeSurface(sf)
for factory in (tfactory, sfactory):
self.assertRaises((sdl2ext.SDLError, AttributeError, ArgumentError,
TypeError), factory.from_surface, None)
self.assertRaises((AttributeError, ArgumentError, TypeError),
factory.from_surface, "test")
# TODO: crashes pypy 2.0
#self.assertRaises((AttributeError, ArgumentError, TypeError),
# factory.from_surface, 1234)
dogc()
def test_SpriteFactory_from_text(self):
sfactory = sdl2ext.SpriteFactory(sdl2ext.SOFTWARE)
fm = sdl2ext.FontManager(RESOURCES.get_path("tuffy.ttf"))
# No Fontmanager passed
self.assertRaises(KeyError, sfactory.from_text, "Test")
# Passing various keywords arguments
sprite = sfactory.from_text("Test", fontmanager=fm)
self.assertIsInstance(sprite, sdl2ext.SoftwareSprite)
sprite = sfactory.from_text("Test", fontmanager=fm, alias="tuffy")
self.assertIsInstance(sprite, sdl2ext.SoftwareSprite)
# Get text from a texture sprite factory
window = sdl2ext.Window("Test", size=(1, 1))
renderer = sdl2ext.Renderer(window)
tfactory = sdl2ext.SpriteFactory(sdl2ext.TEXTURE,
renderer=renderer,
fontmanager=fm)
sprite = tfactory.from_text("Test", alias="tuffy")
self.assertIsInstance(sprite, sdl2ext.TextureSprite)
dogc()
def test_SpriteFactory(self):
factory = sdl2ext.SpriteFactory(sdl2ext.SOFTWARE)
self.assertIsInstance(factory, sdl2ext.SpriteFactory)
self.assertEqual(factory.default_args, {})
factory = sdl2ext.SpriteFactory(sdl2ext.SOFTWARE, bananas="tasty")
self.assertIsInstance(factory, sdl2ext.SpriteFactory)
self.assertEqual(factory.default_args, {"bananas": "tasty"})
window = sdl2ext.Window("Test", size=(1, 1))
renderer = sdl2ext.Renderer(window)
factory = sdl2ext.SpriteFactory(sdl2ext.TEXTURE, renderer=renderer)
self.assertIsInstance(factory, sdl2ext.SpriteFactory)
factory = sdl2ext.SpriteFactory(sdl2ext.TEXTURE, renderer=renderer)
self.assertIsInstance(factory, sdl2ext.SpriteFactory)
self.assertEqual(factory.default_args, {"renderer": renderer})
self.assertRaises(ValueError, sdl2ext.SpriteFactory, "Test")
self.assertRaises(ValueError, sdl2ext.SpriteFactory, -456)
self.assertRaises(ValueError, sdl2ext.SpriteFactory, 123)
self.assertRaises(ValueError, sdl2ext.SpriteFactory, sdl2ext.TEXTURE)
dogc()
def initiation(algorithm, data):
'''initiate and return a window and renderer from the name of algorithm and maze data'''
w = sdl.Window("%s simulation" % algorithm,
(len(data[0]) * SIZE, len(data) * SIZE))
r = sdl.Renderer(w)
return w, r
def run():
# Initialize PySDL2 stuff
ext.init()
window = ext.Window(title="Esper PySDL2 example", size=RESOLUTION)
renderer = ext.Renderer(target=window)
window.show()
# Initialize Esper world, and create a "player" Entity with a few Components.
world = esper.World()
player = world.create_entity()
world.add_component(player, Velocity(x=0, y=0))
world.add_component(player, Renderable(texture=texture_from_image(renderer, "redsquare.png"),
width=64, height=64, posx=100, posy=100))
# Another motionless Entity:
enemy = world.create_entity()
world.add_component(enemy, Renderable(texture=texture_from_image(renderer, "bluesquare.png"),
width=64, height=64, posx=400, posy=250))
# Create some Processor instances, and asign them to be processed.
render_processor = RenderProcessor(renderer=renderer)
movement_processor = MovementProcessor(minx=0, maxx=RESOLUTION[0], miny=0, maxy=RESOLUTION[1])
world.add_processor(render_processor)
world.add_processor(movement_processor)
# A simple main loop
running = True
while running:
start_time = SDL_GetTicks()
for event in ext.get_events():
if event.type == SDL_QUIT:
running = False
break
if event.type == SDL_KEYDOWN:
if event.key.keysym.sym == SDLK_UP:
# Here is a way to directly access a specific Entity's Velocity
# Component's attribute (y) without making a temporary variable.
world.component_for_entity(player, Velocity).y = -3
elif event.key.keysym.sym == SDLK_DOWN:
# For clarity, here is an alternate way in which a temporary variable
# is created and modified. The previous way above is recommended instead.
player_velocity_component = world.component_for_entity(player, Velocity)
player_velocity_component.y = 3
elif event.key.keysym.sym == SDLK_LEFT:
world.component_for_entity(player, Velocity).x = -3
elif event.key.keysym.sym == SDLK_RIGHT:
world.component_for_entity(player, Velocity).x = 3
elif event.key.keysym.sym == SDLK_ESCAPE:
running = False
break
elif event.type == SDL_KEYUP:
if event.key.keysym.sym in (SDLK_UP, SDLK_DOWN):
world.component_for_entity(player, Velocity).y = 0
if event.key.keysym.sym in (SDLK_LEFT, SDLK_RIGHT):
world.component_for_entity(player, Velocity).x = 0
# A single call to world.process() will update all Processors:
world.process()
# A crude FPS limiter for about 60fps
current_time = SDL_GetTicks()
sleep_time = int(start_time + 16.667 - current_time)
if sleep_time > 0:
SDL_Delay(sleep_time)
def run():
lib.init()
window = lib.Window('RLSnake', size=(window_width, window_height))
window.show()
renderer = lib.Renderer(window)
fontManager = sdl2.ext.FontManager(font_path = "assets/fonts/Roboto-Regular.ttf", size = 14)
factory = sdl2.ext.SpriteFactory(renderer=renderer)
text = factory.from_text("Current score: ",fontmanager=fontManager)
snake = Snake(n_grid_x, n_grid_y)
snake.set_visibility_range(args.visibility_range)
snake.reset()
network = ActorCriticNetwork(4, fc1_dims=args.neurons, fc2_dims=args.neurons)
agent = TfAgent(network)
agent.load_weights(args.model_path)
autoplay = args.autoplay
moves = 0
running = True
game_over = False
old_score = 0
current_tiles = snake.get_tiles()
while running:
events = sdl2.ext.get_events()
for event in events:
if event.type == sdl2.SDL_QUIT:
running = False
break
if event.type == sdl2.SDL_KEYDOWN:
if event.key.keysym.sym == sdl2.SDLK_ESCAPE:
running = False
break
if event.key.keysym.sym == 112:
autoplay = not autoplay
if event.key.keysym.sym == 114:
snake.reset()
moves = 0
old_score = 0
game_over = False
current_tiles = snake.get_tiles()
break
if not game_over:
if not autoplay:
if event.key.keysym.sym == sdl2.SDLK_SPACE:
action = agent.get_action(snake.get_view_obs())
_, game_over, _ = snake.step(action)
current_tiles = snake.get_tiles()
moves += 1
if autoplay:
action = agent.get_action(snake.get_view_obs())
_, game_over, _ = snake.step(action)
current_tiles = snake.get_tiles()
moves += 1
renderer.clear(sdl2.ext.Color(0, 0, 0))
draw_grid(renderer)
for x in range(len(current_tiles)):
for y in range(len(current_tiles[x])):
tile = current_tiles[x][y]
if tile == 0:
continue
if tile == 1:
continue
if tile == 2:
if game_over:
fill_tile(renderer, int(x), int(y), COLOR_SNAKE_GAME_OVER)
else:
if snake.get_score() > old_score:
fill_tile(renderer, int(x), int(y), COLOR_SNAKE_EATEN)
else:
fill_tile(renderer, int(x), int(y), COLOR_SNAKE)
if tile == 4:
if game_over:
fill_tile(renderer, int(x), int(y), COLOR_SNAKE_GAME_OVER)
else:
if snake.get_score() > old_score:
fill_tile(renderer, int(x), int(y), COLOR_SNAKE_HEAD_EATEN)
else:
fill_tile(renderer, int(x), int(y), COLOR_SNAKE_HEAD)
if tile == 3:
fill_circle(renderer, int(x), int(y), COLOR_FOOD)
for tile in snake.get_current_view():
fill_tile(renderer, int(tile[0]), int(tile[1]), COLOR_VIEW_RANGE)
if snake.get_score() > old_score:
old_score = snake.get_score()
text = factory.from_text("Current score: " + str(snake.get_score()), fontmanager=fontManager)
renderer.copy(text, dstrect=(0, 0, text.size[0],text.size[1]))
if autoplay:
text = factory.from_text("Move: " + str(moves) + " / " + str(MAX_MOVES), fontmanager=fontManager)
else:
text = factory.from_text("Move: " + str(moves), fontmanager=fontManager)
renderer.copy(text, dstrect=(0, 14, text.size[0],text.size[1]))
renderer.present()
sdl2.SDL_Delay(args.sleep)
if autoplay and (game_over or moves >= MAX_MOVES):
snake.reset()
moves = 0
old_score = 0
game_over = False
return 0
def test_SpriteFactory_from_object(self):
window = sdl2ext.Window("Test", size=(1, 1))
renderer = sdl2ext.Renderer(window)
tfactory = sdl2ext.SpriteFactory(sdl2ext.TEXTURE, renderer=renderer)
sfactory = sdl2ext.SpriteFactory(sdl2ext.SOFTWARE)
def run():
lib.init()
window = lib.Window('RLSnake', size=(window_width, window_height))
window.show()
renderer = lib.Renderer(window)
font_manager = sdl2.ext.FontManager(
font_path="assets/fonts/Roboto-Regular.ttf", size=14)
factory = sdl2.ext.SpriteFactory(renderer=renderer)
text = factory.from_text("Current score: ", fontmanager=font_manager)
snake = Snake(n_grid_x, n_grid_y)
snake.reset()
moves = 0
running = True
game_over = False
current_tiles = snake.get_tiles()
while running:
events = sdl2.ext.get_events()
for event in events:
if event.type == sdl2.SDL_QUIT:
running = False
break
if event.type == sdl2.SDL_KEYDOWN:
if event.key.keysym.sym == sdl2.SDLK_ESCAPE:
running = False
break
if event.key.keysym.sym == 114:
snake.reset()
game_over = False
current_tiles = snake.get_tiles()
moves = 0
break
if not game_over:
if event.key.keysym.sym == sdl2.SDLK_UP:
_, game_over, _ = snake.step(3)
current_tiles = snake.get_tiles()
moves += 1
elif event.key.keysym.sym == sdl2.SDLK_DOWN:
_, game_over, _ = snake.step(2)
current_tiles = snake.get_tiles()
moves += 1
elif event.key.keysym.sym == sdl2.SDLK_LEFT:
_, game_over, _ = snake.step(1)
current_tiles = snake.get_tiles()
moves += 1
elif event.key.keysym.sym == sdl2.SDLK_RIGHT:
_, game_over, _ = snake.step(0)
current_tiles = snake.get_tiles()
moves += 1
renderer.clear(sdl2.ext.Color(0, 0, 0))
draw_grid(renderer)
for x in range(len(current_tiles)):
for y in range(len(current_tiles[x])):
tile = current_tiles[x][y]
if tile == 0:
continue
if tile == 1:
continue
if tile == 2:
if game_over:
fill_tile(renderer, int(x), int(y),
COLOR_SNAKE_GAME_OVER)
else:
fill_tile(renderer, int(x), int(y), COLOR_SNAKE)
if tile == 4:
if game_over:
fill_tile(renderer, int(x), int(y),
COLOR_SNAKE_GAME_OVER)
else:
fill_tile(renderer, int(x), int(y), COLOR_SNAKE_HEAD)
if tile == 3:
fill_circle(renderer, int(x), int(y), COLOR_FOOD)
text = factory.from_text("Current score: " + str(snake.get_score()),
fontmanager=font_manager)
renderer.copy(text, dstrect=(0, 0, text.size[0], text.size[1]))
text = factory.from_text("Move: " + str(moves),
fontmanager=font_manager)
renderer.copy(text, dstrect=(0, 14, text.size[0], text.size[1]))
renderer.present()
sdl2.SDL_Delay(33)
return 0
