def edit_init(): globs.mode = "grid_edit" globs.grid = Grid() listen.launch(editor_camera_loop()) listen.launch(grid_editor_loop())
def main(): glfw.init() glfw.window_hint(glfw.RESIZABLE, False) glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 4) glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 6) w, h = 800, 800 globs.window = glfw.create_window(w, h, 'Tesseland', None, None) glfw.make_context_current(globs.window) init_polygon_shader() levels_init() globs.spf = 0.015 # 60ish fps listen.launch(game_loop()) render_init(w, h) play_init() hud_init() # the main loop. while not glfw.window_should_close(globs.window): glfw.wait_events_timeout(globs.spf / 10) listen.trigger_timers() glfw.terminate()
def render_init(w,h): globs.cam = { "pos":Vec(0,0), # of bottom left corner of screen, in units "pixel_scale": 3, # each asset pixel occupies this many screen pixels "pixels_per_unit": 16, # this is asset pixels, not screen pixels "w": w, "h": h, # width in screen pixels, height in screen pixels "projection": None, # viewport_loop populates this with a matrix "projection-inv": None, # and its inverse here. "w_asset" : w/16/3, # width in asset pixels is width / pixels_per_unit / pixel_scale "h_asset" : h/16/3, # height in asset pixels is height / pixels_per_unit / pixel_scale "smoothing" : False, # is the camera's motion smoothed (True), or does it snap to the player (False) "smoothing_factor" : 5 # how smooth is the motion (higher numbers are slower, smoother motion } globs.hud_elements = [ { "function": "test", "sprite": "assets/hud.png", "location": {"x": 12,"y": 12 },# world units (1 block = 1x1 world units) "size" : {"x": 128, "y" : 16} # pixel_width/20, pixel_height/20 }, { "function": "inventory", "sprite": "assets/hud.png", "location": {"x": 12 ,"y": 3 }, "size" : {"x": 128, "y" : 16}# pixel_width/20, pixel_height/20 }, ] listen.launch(viewport_loop()) listen.launch(render_loop())
def main(): glfw.init() glfw.window_hint(glfw.RESIZABLE, False) glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 4) glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 6) w, h = 800, 640 globs.window = glfw.create_window(w, h, 'PlatformPrototype', None, None) x = glfw.make_context_current(globs.window) # initialize libraries init_quadarray() init_textbox(w=2000, h=2000) # dimension of glyph atlas globs.spf = 0.015 # 60ish fps # this stuff gets rendered by the render_loop globs.quadarrays = [] globs.textboxes = [] # launch loops (order matters here) listen.launch(game_loop()) render_init(w, h) load_assets() edit_init() play_init() # the main loop. while not glfw.window_should_close(globs.window): glfw.wait_events_timeout(globs.spf / 10) listen.trigger_timers() glfw.terminate()
def render_init(w, h): globs.cam = { "w": w, "h": h, "scale": 100, "projection": None, } listen.launch(viewport_loop()) listen.launch(render_loop())
def play_init(): # globs.playerarray renders the player animator = Animator() animator.enqueue(globs.assets["dino-idle-right"], loop=True, label="idle-right") globs.playerarray = QuadArray(animator) globs.quadarrays.append(globs.playerarray) listen.launch(play_loop()) listen.launch(escape_loop())
def render_init(w, h): globs.cam = { "pos": Vec(0, 0), # of bottom left corner of screen, in units "pixel_scale": 3, # each asset pixel occupies this many screen pixels "pixels_per_unit": 16, # this is asset pixels, not screen pixels "w": w, "h": h, "projection": None, # viewport_loop populates this with a matrix "projection-inv": None, # and its inverse here. } listen.launch(viewport_loop()) listen.launch(render_loop())
def render_init(w,h): globs.cam = { "pos":Vec(0,0), # of bottom left corner of screen, in units "target_pos": Vec(0,0), # camera slowly moves to here "pixel_scale": 3, # each asset pixel occupies this many screen pixels "pixels_per_unit": 32, # this is asset pixels, not screen pixels "w": w, "h": h, "projection": None, # viewport_loop populates this with a matrix "projection-inv": None, # and its inverse here. } # dimensions of the viewport in world coordinates dims = Vec(globs.cam["w"], globs.cam["h"]) dims /= globs.cam["pixel_scale"] dims /= globs.cam["pixels_per_unit"] globs.cam["dims"] = dims listen.launch(viewport_loop()) listen.launch(render_loop())
def render_init(w, h): globs.cam = { "w": w, "h": h, "projection": None, } globs.hud_elements = [ { "function": "switchColors", "sprite": "assets/hud_switchColors.png", "location": { "x": 2, "y": 12 }, # world units (1 block = 1x1 world units) "size": { "x": 16, "y": 16 } # pixel_width/20, pixel_height/20 }, { "function": "inventory", "sprite": "assets/hud.png", "location": { "x": 5, "y": 12 }, "size": { "x": 128, "y": 16 } # pixel_width/20, pixel_height/20 }, ] listen.launch(viewport_loop()) listen.launch(render_loop())
def levels_init(): globs.play_disabled = True globs.selected_color = 0 globs.bgcolor = Vec(0.0, 0.0, 0) globs.polydata = { "unit_dx": Vec(1, 0), "unit_dy": Vec(0, 1), "nx": 10, "ny": 10, "origin": Vec(0, 0), "colors": [], } globs.level_idx = -1 globs.levels = [ level1, level2, level0, level5, level4, level3, level7, level6, level555555 ] globs.polygons = [] listen.launch(next_level_loop()) listen.launch(reset_level_loop())
def hud_init(): globs.hud_polygons = [] globs.textboxes = [] globs.move_count = 0 # initialize libraries init_textbox(w=2000, h=2000) # dimension of glyph atlas listen.launch(update_hud()) listen.launch(title_screen()) listen.launch(ending_screen())
def edit_init(): globs.mode = "grid_edit" globs.grid = Grid() globs.world_state = "light" globs.fpsbox.color = Vec(0, 0, 0, 1.0) populate_grid() listen.launch(editor_camera_loop()) listen.launch(editor_key_loop()) listen.launch(grid_editor_loop())
def play_init(): # globs.playerarray renders the player animator = Animator() animator.enqueue(globs.assets["dino-idle-right"], loop=True, label="idle-right") globs.playerarray = QuadArray(animator) globs.quadarrays.append(globs.playerarray) globs.circlearray = QuadArray(globs.assets["circle"]) globs.quadarrays.append(globs.circlearray) globs.boxcounttext = TextBox("IBMPlexSans-Regular.ttf", size=30, color=Vec(1, 0, 0), pos=Vec(globs.cam["w"] - 30, 5, 0.9)) globs.textboxes.append(globs.boxcounttext) globs.boxcounttext.text = "0" globs.boxcount = 0 listen.launch(play_loop()) listen.launch(escape_loop()) listen.launch(camera_move_loop()) listen.launch(play_mouse_loop())
def edit_init(): globs.mode = "grid_edit" listen.launch(grid_editor_loop())
def play_init(): listen.launch(play_loop())
def play_loop(): velocities = [Vec(0, 0), Vec(0, 0)] dpad = Vec(0, 0) listen.launch(dpad_loop(dpad)) direction = "right" collision_radius = 3 while True: events = yield from listen.any(frame=listen.event("on_frame"), ) if globs.mode != "play": continue _, dt = events["frame"] for pn in range(len(globs.playerarray.quads)): playerpos = globs.playerarray.quads[pn] velocity = velocities[pn] # is the player touching a wall? touch = { "bot": Vec(0, -1, 0), "left": Vec(-1, 0, 0), "right": Vec(1, 0, 0) } for key in touch: found = False for (x, y) in grid_positions_nearby(playerpos, collision_radius): if squares_intersect(Vec(x, y), playerpos + touch[key] / 16): if globs.grid[(x, y)] == "terrain-top": found = True break touch[key] = found # replace dict entry with boolean print(touch) if touch["bot"]: # if upstream of obstacle, make the vertical velocity 0 velocity.y = 0 else: # otherwise apply downstream current if velocity.y <= 1: velocity.y -= 5 * dt # horizontal movement velocity.x = dpad.x * 3 for (x, y) in grid_positions_nearby(playerpos, collision_radius): if rect_in_rect(Vec(x, y), playerpos, Vec(1, 1), Vec(1, 1)): if globs.grid[(x, y)] == "terrain-side-right": if velocity.x <= 5: velocity.x += 1 * dt if globs.grid[(x, y)] == "terrain-side-left": if velocity.x >= -5: velocity.x -= 1 * dt # bonk on sides if touch["right"] and velocity.x > 0: velocity.x = 0 if touch["left"] and velocity.x < 0: velocity.x = 0 # compute the delta, and apply it with collision detection delta = velocity * dt # move the player. split the delta into lots of tiny nudges # and then apply as many as you can before we collide for nudge in split_delta(delta, 1 / 16): any_collisions = False for (x, y) in globs.grid: if globs.grid[x, y] == "terrain-top": continue if squares_intersect(Vec(x, y), playerpos + nudge.xy0): any_collisions = True break if any_collisions: break playerpos += nudge.xy0 # finalize playerpos globs.playerarray.update() # adjust the player sprite animation # compute the new label newlabel = "idle" if touch["bot"]: if velocity.x != 0: newlabel = "sneak" else: newlabel = "idle" else: newlabel = "move" # compute the direction the player is facing if velocity.x != 0: if velocity.x > 0: direction = "right" else: direction = "left" newlabel += "-" + direction # update the animator if globs.playerarray.asset.label != newlabel: globs.playerarray.asset.clear() globs.playerarray.asset.enqueue(globs.assets["dino-" + newlabel], loop=True, label=newlabel)
def play_loop(): velocity = Vec(0, 0) dpad = Vec(0, 0) listen.launch(dpad_loop(dpad)) direction = "right" while True: events = yield from listen.any(frame=listen.event("on_frame"), ) # only allow play mode if globs.mode != "play": continue _, dt = events["frame"] playerpos = globs.playerarray.quads[0] center_camera(playerpos.x, playerpos.y) # is the player touching something? touch = { "top": Vec(0, 1, 0), "bot": Vec(0, -1, 0), "left": Vec(-1, 0, 0), "right": Vec(1, 0, 0) } for key in touch: found = False for (x, y) in globs.grid: if squares_intersect(Vec(x, y), playerpos + touch[key] / 16): found = True break touch[key] = found # replace dict entry with boolean if touch["bot"]: # if grounded, make the vertical velocity 0 velocity.y = 0 # if the player is pressing up, make them jump if dpad.y == 1: velocity.y = 5 else: # otherwise apply gravity velocity.y -= 5 * dt if (velocity.y < 0): # after peak jump, fall faster velocity.y -= 5 * dt # head bonk if touch["top"] and velocity.y > 0: velocity.y = 0 # horizontal movement velocity.x = dpad.x * 3 # bonk on sides if touch["right"] and velocity.x > 0: velocity.x = 0 if touch["left"] and velocity.x < 0: velocity.x = 0 # compute the delta, and apply it with collision detection delta = velocity * dt # move the player. split the delta into lots of tiny nudges # and then apply as many as you can before we collide for nudge in split_delta(delta, 1 / 16): any_collisions = False for (x, y) in globs.grid: if squares_intersect(Vec(x, y), playerpos + nudge.xy0): any_collisions = True break if any_collisions: break playerpos += nudge.xy0 # finalize playerpos globs.playerarray.update() # adjust the player sprite animation # compute the new label newlabel = "idle" if touch["bot"]: if velocity.x != 0: newlabel = "sneak" else: newlabel = "idle" else: newlabel = "move" # compute the direction the player is facing if velocity.x != 0: if velocity.x > 0: direction = "right" else: direction = "left" newlabel += "-" + direction # update the animator if globs.playerarray.asset.label != newlabel: globs.playerarray.asset.clear() globs.playerarray.asset.enqueue(globs.assets["dino-" + newlabel], loop=True, label=newlabel)
def main(): glfw.init() # for windowed windows glfw.window_hint(glfw.RESIZABLE, True) # opengl options glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 4) glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 6) global w w = glfw.create_window(800, 600, 'Window Title', None, None) glfw.make_context_current(w) #################### shaderProgram = make_shader_program() glUseProgram(shaderProgram) vao = glGenVertexArrays(1) glBindVertexArray(vao) tri_vbo = glGenBuffers(1) glBindBuffer(GL_ARRAY_BUFFER, tri_vbo) vertices = Vec(0, 0), Vec(0, 1), Vec(1, 1), Vec(1, 0) vertices = Vec(*vertices) glBufferData(GL_ARRAY_BUFFER, vertices.size, vertices.buffer, GL_STATIC_DRAW) glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, ctypes.c_void_p(0)) glEnableVertexAttribArray(0) colorUniform = glGetUniformLocation(shaderProgram, "color") glUniform4f(colorUniform, 1, 1, 1, 1) ################### node = PaddingNode( vertical="*", children=[ RowsNode(children=[ RowsNode(children=[ HintedNode(width=100, height=300, key="node1"), HintedNode(width=200, height=100, key="node2"), HintedNode(width=150, height=200, key="node3"), ]) ]) ]) def fbresize(): x = None while True: if x is None: x, y = glfw.get_framebuffer_size(w) else: _, x, y = yield from listen.on_framebuffer_size(w) # adjust viewport glViewport(0, 0, x, y) # adjust projection projection.set_uniform(shaderProgram, 'projection') projection.clear() projection.ortho(0, x, 0, y, 0, 100) # adjust node node_window_fit(node, w) listen.launch(fbresize()) def rectnode(node, color): while True: yield from node.on_draw() colorUniform = glGetUniformLocation(shaderProgram, "color") glUniform4f(colorUniform, color.x, color.y, color.z, color.w) projection.set_uniform(shaderProgram, 'modelview') projection.push() projection.translate(node.x, node.y, 0.0) projection.scale(node.width, node.height, 1) glDrawArrays(GL_TRIANGLE_FAN, 0, 4) projection.pop() listen.launch(rectnode(node["node1"], Vec(1, 0, 0, 1))) listen.launch(rectnode(node["node2"], Vec(0, 1, 0, 1))) listen.launch(rectnode(node["node3"], Vec(0, 0, 1, 1))) listen.launch(rectnode(node, Vec(0.2, 0.4, 0.3, 1))) while not glfw.window_should_close(w): glClearColor(0.0, 0.0, 0.0, 1.0) glClear(GL_COLOR_BUFFER_BIT) node.draw() glfw.swap_buffers(w) glfw.wait_events_timeout(0.01) # 100 fps listen.trigger_timers() glfw.terminate()
def main(): glfw.init() glfw.window_hint(glfw.RESIZABLE, False) glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 4) glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 6) w, h = 800, 640 globs.h = h globs.w = w globs.window = glfw.create_window(w, h, 'Polygon', None, None) x = glfw.make_context_current(globs.window) init_polygon_shader() # flood-fill colors globs.colors = [ Vec(1.0, 0.0, 1.0, 1.0), Vec(1.0, 1.0, 1.0, 1.0), Vec(0.5, 0.5, 1.0, 1.0), Vec(0.0, 1.0, 1.0, 1.0) ] globs.colorIndex = 0 # data to scale and shape the triangle array globs.tri = {} globs.tri["i_max"] = 7 # number of columns globs.tri["j_max"] = 5 # number of rows globs.tri[ "offsetX"] = 50 # x, y (pixel) position of lower left corner of the array globs.tri["offsetY"] = 50 globs.tri["scaleX"] = 50 # 1/2 the width of a triangle globs.tri["scaleY"] = 50 # 1/2 the height of a triangle # score globs.numberClicksThisLevel = 0 # this stuff gets rendered by the render_loop globs.polygons = [] #generate arrays for i in range(0, globs.tri["i_max"]): for j in range(0, globs.tri["j_max"]): isStaggered = (j % 2 == 1) if not isStaggered: p1, p2, p3 = grid_index_to_position(i, j, True) # upward point globs.polygons.append( Polygon(globs.colors[0 if isStaggered else 2], [p1, p2, p3])) p1, p2, p3 = grid_index_to_position(i, j, False) # downward point globs.polygons.append( Polygon(globs.colors[1 if isStaggered else 3], [p1, p2, p3])) else: p1, p2, p3 = grid_index_to_position(i, j, False) # downward point globs.polygons.append( Polygon(globs.colors[1 if isStaggered else 3], [p1, p2, p3])) p1, p2, p3 = grid_index_to_position(i, j, True) # upward point globs.polygons.append( Polygon(globs.colors[0 if isStaggered else 2], [p1, p2, p3])) # launch loops (order matters here) globs.spf = 0.015 # 60ish fps listen.launch(game_loop()) render_init(w, h) edit_init() # the main loop. while not glfw.window_should_close(globs.window): glfw.wait_events_timeout(globs.spf / 10) listen.trigger_timers() glfw.terminate()
def main(): glfw.init() # Common window hints and their defaults glfw.window_hint(glfw.FOCUS_ON_SHOW, True) # for windowed windows glfw.window_hint(glfw.RESIZABLE, True) glfw.window_hint(glfw.VISIBLE, True) glfw.window_hint(glfw.DECORATED, True) glfw.window_hint(glfw.FOCUSED, True) glfw.window_hint(glfw.FLOATING, False) glfw.window_hint(glfw.MAXIMIZED, False) # for full screen windows # To make full screen, pass a monitor as the 5th argument to glfw.create_window, # or use glfw.set_window_monitor(w,mon). # Auto_iconify means to minimize when focus lost. glfw.window_hint(glfw.AUTO_ICONIFY, True) glfw.window_hint(glfw.CENTER_CURSOR, True) # opengl options glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 4) glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 6) glfw.window_hint(glfw.DEPTH_BITS, 24) glfw.window_hint(glfw.STENCIL_BITS, 8) # transparency glfw.window_hint(glfw.TRANSPARENT_FRAMEBUFFER, False) # later call glfw.set_window_opacity(w, 0.5) # and use glfw.get_window_opacity(w) # for X11 glfw.window_hint_string(glfw.X11_CLASS_NAME, "") glfw.window_hint_string(glfw.X11_INSTANCE_NAME, "") ##################### global w w = glfw.create_window(800, 600, 'Window Title', None, None) glfw.make_context_current(w) # glfw.set_window_title(w, "Window Title") # controlling window size # get/set interchangable # glfw.set_window_pos(w, x, y) # glfw.set_window_size(w, width, height) # glfw.set_window_size_limits(w, minW, minH, maxW, maxH) # glfw.set_window_aspect_ratio(w, 16, 9) # get only # glfw.get_window_frame_size(w) # with borders and all, get only # glfw.get_framebuffer_size(w) # get only # window status # glfw.iconify_window(w) / glfw.restore_window(w) # glfw.get_window_attrib(w, glfw.ICONIFIED) # glfw.maximize_window(w) / glfw.restore_window(w) # glfw.get_window_attrib(w, glfw.MAXIMIZED) # glfw.hide_window / glfw.show_window # glfw.get_window_attrib(w, glfw.VISIBLE) # glfw.focus_window(w) or glfw.request_window_attention(w) # glfw.get_window_attrib(w, glfw.FOCUSED) # glfw.set_window_should_close(w, False) # clipboard # glfw.get_clipboard_string(w) # glfw.set_clipboard_string(w, "hello") def clock(): while True: dt = yield from listen.wait(0.2) listen.launch(clock()) #################### shaderProgram = make_shader_program() glUseProgram(shaderProgram) vao = glGenVertexArrays(1) glBindVertexArray(vao) tri_vbo = glGenBuffers(1) glBindBuffer(GL_ARRAY_BUFFER, tri_vbo) v1, v2, v3 = Vec(0, 0, 0), Vec(1, 1, 0), Vec(1, 0, 0) vertices = Vec(v1, v2, v3) glBufferData(GL_ARRAY_BUFFER, vertices.size, vertices.buffer, GL_STATIC_DRAW) glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, ctypes.c_void_p(0)) glEnableVertexAttribArray(0) ################### def fbresize(): x = None while True: if x is None: x, y = glfw.get_framebuffer_size(w) else: _, x, y = yield from listen.on_framebuffer_size(w) # adjust viewport glViewport(0, 0, x, y) # adjust projection projection.set_uniform(shaderProgram, "projection") projection.clear() projection.ortho(0, x, 0, y, 0, 100) listen.launch(fbresize()) import time, math t0 = time.time() while not glfw.window_should_close(w): glClearColor(0.0, 0.0, 0.0, 1.0) glClear(GL_COLOR_BUFFER_BIT) projection.set_uniform(shaderProgram, "modelview") projection.push() theta = 10 * (time.time() - t0) projection.translate(100, 100, 0.0) projection.translate(10 * math.sin(theta), 10 * math.cos(theta), 0.0) projection.scale(100, 100, 1) glDrawArrays(GL_TRIANGLES, 0, 3) projection.pop() glfw.swap_buffers(w) # glfw.poll_events() # non-blocking # glfw.wait_events() # blocks until an event is received # glfw.wait_events_timeout(0.4) # blocks until event or timeout # To unblock the main thread from wait_events(), use glfw.post_empty_event() glfw.wait_events_timeout(0.01) # 100 fps listen.trigger_timers() glfw.terminate()
def play_loop(): velocity = Vec(0, 0) dpad = Vec(0, 0) listen.launch(dpad_loop(dpad)) direction = "right" collision_prec = 0.01 collision_radius = 2 playersize = globs.playerarray.asset["size"] gridsize = Vec(1, 1) recent_portal = None while True: events = yield from listen.any(frame=listen.event("on_frame"), ) if globs.mode != "play": continue _, dt = events["frame"] playerpos = globs.playerarray.quads[0] # is the player touching something? touch = { "top": Vec(0, 1, 0), "bot": Vec(0, -1, 0), "left": Vec(-1, 0, 0), "right": Vec(1, 0, 0) } for key in touch: found = False for (x, y) in grid_positions_nearby(playerpos, collision_radius): if "dark" not in globs.grid[x, y]: continue if rects_intersect(Vec(x, y), playerpos + touch[key] * collision_prec, gridsize, playersize): found = True break touch[key] = found # replace dict entry with boolean if touch["bot"]: # if grounded, make the vertical velocity 0 velocity.y = 0 # if the player is pressing up, make them jump if dpad.y == 1: velocity.y = 3 else: # otherwise apply gravity velocity.y -= 3 * dt # horizontal movement velocity.x = dpad.x * 3 # head bonk if touch["top"] and velocity.y > 0: velocity.y = 0 # bonk on sides if touch["right"] and velocity.x > 0: velocity.x = 0 if touch["left"] and velocity.x < 0: velocity.x = 0 # compute the delta, and apply it with collision detection delta = velocity * dt # move the player. split the delta into lots of tiny nudges # and then apply as many as you can before we collide for nudge in split_delta(delta, collision_prec): any_collisions = False for (x, y) in grid_positions_nearby(playerpos, collision_radius): if "dark" not in globs.grid[x, y]: continue if rects_intersect( Vec(x, y), playerpos + nudge.xy0, gridsize, playersize, ): any_collisions = True break if any_collisions: break playerpos += nudge.xy0 # finalize playerpos globs.playerarray.update() globs.circlearray.quads[0] = Vec(0, 0, 0) + playerpos globs.circlearray.quads[0] -= globs.circlearray.asset["size"].xy0 / 2 globs.circlearray.quads[0] += globs.playerarray.asset["size"].xy0 / 2 globs.circlearray.update() for (x, y) in grid_positions_nearby(playerpos, collision_radius): if globs.grid[x, y] != "portal": continue if not rect_in_rect(playerpos, Vec(x, y), playersize, gridsize): continue if (x, y) == recent_portal: continue mode_switch() velocity = Vec(0, 0) recent_portal = (x, y) if recent_portal is not None: if not rects_intersect(playerpos, Vec(*recent_portal), playersize, gridsize): recent_portal = None # adjust the camera if we are not falling if touch["bot"]: globs.cam["target_pos"] = -playerpos.xy + globs.cam["dims"] / 2 # adjust the player sprite animation # compute the new label newlabel = "idle" if touch["bot"]: if velocity.x != 0: newlabel = "sneak" else: newlabel = "idle" else: newlabel = "move" # compute the direction the player is facing if velocity.x != 0: if velocity.x > 0: direction = "right" else: direction = "left" newlabel += "-" + direction # update the animator if globs.playerarray.asset.label != newlabel: globs.playerarray.asset.clear() globs.playerarray.asset.enqueue(globs.assets["dino-" + newlabel], loop=True, label=newlabel)