def draw_grid(renderer): x = 0 while x < 1 + n_grid_x * grid_cell_size: renderer.draw_line([x, 0, x, window_height], lib.Color(255, 255, 255)) x += grid_cell_size y = 0 while y < 1 + n_grid_y * grid_cell_size: renderer.draw_line([0, y, window_width, y], lib.Color(255, 255, 255)) y += grid_cell_size
def test_FontManager(self): fm = sdl2ext.FontManager(RESOURCES.get_path("tuffy.ttf"), bg_color=(100, 0, 0)) assert isinstance(fm, sdl2ext.FontManager) assert fm.default_font == "tuffy" assert fm.size == 16 assert fm.bg_color == sdl2ext.Color(100, 0, 0, 0)
def test_FontManager(self): fm = sdl2ext.FontManager(RESOURCES.get_path("tuffy.ttf"), bg_color=(100, 0, 0)) self.assertIsInstance(fm, sdl2ext.FontManager) self.assertEqual(fm.default_font, "tuffy") self.assertEqual(fm.size, 16) self.assertEqual(fm.bg_color, sdl2ext.Color(100, 0, 0, 0))
def rendergoodies(self, g_row): '''draw the goodies in game''' self.color = sdl.Color(random.randint(0, 255), random.randint(0, 255), random.randint(0, 255), 0) for r in g_row: for g in range(r.num): self.__rendercircle(r.co[g], r.pos, gameinfo.BONUSRADIUS)
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 draw(window, robot): events = sdl.get_events() for event in events: if event.type == sdl2.SDL_QUIT: running = False break surface = window.get_surface() sdl.fill(surface, sdl.Color(0, 0, 0)) #Drawing the walls sdl.line(surface, sdl.Color(255, 255, 255), (-meters_to_pixels(0.4) + WINDOW_SIZE[0] // 2, 0, -meters_to_pixels(0.4) + WINDOW_SIZE[0] // 2, WINDOW_SIZE[1], meters_to_pixels(0.4) + WINDOW_SIZE[0] // 2, 0, meters_to_pixels(0.4) + WINDOW_SIZE[0] // 2, WINDOW_SIZE[1])) draw_robot(surface, robot) window.refresh()
def draw_lines(surface, width, height): # Fill the whole surface with a black color. sdl2ext.fill(surface, 0) for x in range(15): # Create a set of four random points for drawing the line. x1, x2 = randint(0, width), randint(0, width) y1, y2 = randint(0, height), randint(0, height) # Create a random color. color = sdl2ext.Color(randint(0, 255), randint(0, 255), randint(0, 255)) # Draw the line with the specified color on the surface. # We also could create a set of points to be passed to the function # in the form # # line(surface, color, (x1, y1, x2, y2, x3, y3, x4, y4, ...)) # ^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^ # first line second line sdl2ext.line(surface, color, (x1, y1, x2, y2))
def draw_rects(surface, width, height): # Fill the whole surface with a black color. sdl2ext.fill(surface, 0) for k in range(15): # Create a set of four random points for the edges of the rectangle. x, y = randint(0, width), randint(0, height) w, h = randint(1, width // 2), randint(1, height // 2) # Create a random color. color = sdl2ext.Color(randint(0, 255), randint(0, 255), randint(0, 255)) # Draw the filled rect with the specified color on the surface. # We also could create a set of points to be passed to the function # in the form # # fill(surface, color, ((x1, y1, x2, y2), (x3, y3, x4, y4), ...)) # ^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^ # first rect second rect sdl2ext.fill(surface, color, (x, y, w, h))
def draw_robot(surface, robot): pos_x = meters_to_pixels(robot.position.x) + WINDOW_SIZE[0] // 2 pos_y = meters_to_pixels(robot.position.y) % WINDOW_SIZE[1] line = (pos_x, pos_y, pos_x + int(meters_to_pixels(0.10) * math.cos(robot.angle - math.pi / 2)), pos_y + int(meters_to_pixels(0.10) * math.sin(robot.angle - math.pi / 2)), pos_x, pos_y, pos_x + int(meters_to_pixels(0.05) * math.cos(robot.angle + math.pi / 2)), pos_y + int(meters_to_pixels(0.05) * math.sin(robot.angle + math.pi / 2)), pos_x, pos_y, pos_x + int(meters_to_pixels(0.05) * math.cos(robot.angle + 0)), pos_y + int(meters_to_pixels(0.05) * math.sin(robot.angle + 0)), pos_x, pos_y, pos_x + int(meters_to_pixels(0.05) * math.cos(robot.angle - math.pi)), pos_y + int(meters_to_pixels(0.05) * math.sin(robot.angle - math.pi))) sdl.line(surface, sdl.Color(255, 255, 100), line)
def fill_circle(renderer, x, y, color=lib.Color(255, 255, 255)): gfx.filledCircleRGBA(renderer.sdlrenderer, x * grid_cell_size + int(grid_cell_size / 2) + 1, y * grid_cell_size + int(grid_cell_size / 2) + 1, int(grid_cell_size / 4), color.r, color.g, color.b, color.a)
import os import sys from random import randint try: from sdl2 import * import sdl2.ext as sdl2ext except ImportError: import traceback traceback.print_exc() sys.exit(1) WHITE = sdl2ext.Color(255, 255, 255) class SoftwareRenderer(sdl2ext.SoftwareSpriteRenderer): def __init__(self, window): super(SoftwareRenderer, self).__init__(window) def render(self, components): sdl2ext.fill(self.surface, sdl2ext.Color(0, 0, 0)) super(SoftwareRenderer, self).render(components) class Player(sdl2ext.Entity): def __init__(self, world, sprite, posx=0, posy=0, ai=False): self.sprite = sprite self.sprite.position = posx, posy self.velocity = Velocity() self.playerdata = PlayerData() self.playerdata.ai = ai
def render(self, components): sdl2ext.fill(self.surface, sdl2ext.Color(0, 0, 0)) super(SoftwareRenderer, self).render(components)
import sys from sdl2.events import SDL_TEXTINPUT # Try to import SDL2. The import might fail, if the SDL2 DLL could not be # loaded. In that case, just print the error and exit with a proper # error code. try: from sdl2 import SDL_QUIT import sdl2.ext as sdl2ext except ImportError: import traceback traceback.print_exc() sys.exit(1) # Define some global color constants WHITE = sdl2ext.Color(255, 255, 255) GREY = sdl2ext.Color(200, 200, 200) RED = sdl2ext.Color(255, 0, 0) GREEN = sdl2ext.Color(0, 255, 0) # Create a resource, so we have easy access to the example images. RESOURCES = sdl2ext.Resources(__file__, "resources") # A callback for the Button.motion event. def onmotion(button, event): print("Mouse moves over the button!") # A callback for the Button.click event. def onclick(button, event):
def set_color(r, g, b): global current_color current_color = sdl.Color(r, g, b)
def fill_tile(renderer, x, y, color=lib.Color(255,255,255)): blendmode = renderer.blendmode renderer.blendmode = sdl2.blendmode.SDL_BLENDMODE_ADD renderer.fill(((x*grid_cell_size+1, y*grid_cell_size+1, grid_cell_size-1, grid_cell_size-1)), color=color) renderer.blendmode = blendmode
import sdl2.ext as sdl WINDOW_WIDTH = 700 WINDOW_HEIGHT = 900 GAP = 80 SCORE_DIFF = 2000 BLOCK_IN_MOTION = 0x0 SNAKE_IN_MOTION = 0x1 GAME_OVER = 0x2 STABLE = 0x0 LEFT = 0x1 RIGHT = 0x2 INITIAL_SPEED = 2 MIN_T_STAMP = 200 COLOR_GRID = { "black":sdl.Color(0, 0, 0, 0), "white":sdl.Color(255, 255, 255, 0), "red":sdl.Color(255, 0, 0, 0), "green":sdl.Color(0, 255, 0, 0), "yellow":sdl.Color(255, 255, 0, 0), "white-green":sdl.Color(190, 255, 190, 0), "blue":sdl.Color(0, 0, 255, 0), "blue-green":sdl.Color(0, 255, 255, 0), "red-blue":sdl.Color(255, 0, 255, 0) } MAX_PER_ROW = 7 TOLERANCE = 20 DELAY1 = 6 DELAY2 = 9 BLOCK_GAP = 4 BLOCKSIZE = int(WINDOW_WIDTH / MAX_PER_ROW - BLOCK_GAP)
def fill_tile(renderer, x, y, color=lib.Color(255, 255, 255)): renderer.fill(((x * grid_cell_size + 1, y * grid_cell_size + 1, grid_cell_size - 1, grid_cell_size - 1)), color=color)
import sys # Try to import SDL2. The import might fail, if the SDL2 DLL could not be # loaded. In that case, just print the error and exit with a proper # error code. try: from sdl2 import SDL_QUIT, SDL_MOUSEBUTTONDOWN import sdl2.ext as sdl2ext except ImportError: import traceback traceback.print_exc() sys.exit(1) # Define black and white as global values, so we can access them throughout # the code. BLACK = sdl2ext.Color(0, 0, 0) WHITE = sdl2ext.Color(255, 255, 255) # This function will use a rectangular area and fill each second horizontal # line with a white color on the passed surface. def draw_horizontal_stripes(surface, x1, x2, y1, y2): # Fill the entire surface with a black color. In contrast to # colorpalettes.py we use a Color() value here, just to demonstrate that # it really works. sdl2ext.fill(surface, BLACK) # Create a 2D view that allows us to directly access each individual pixel # of the surface. The PixelView class is quite slow, since it uses an non- # optimised read-write access to each individual pixel and offset. It works # on every platform, though.
import ctypes import sdl2.ext as sdl import sdl2 window_width = window_height = 0 renderer = None window = None current_color = sdl.Color(255, 255, 255) evh = None 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) # renderer = sdl2.SDL_CreateRenderer( # window, # -1, # sdl2.SDL_RENDERER_ACCELERATED | sdl2.SDL_RENDERER_PRESENTVSYNC # ) # sdl. def is_window_closed(): event = sdl2.SDL_Event() if sdl2.SDL_PollEvent(ctypes.byref(event)) != 0: if event.type == sdl2.SDL_QUIT: return True
def clear_screen(r=0, g=0, b=0): color = sdl.Color(r, g, b) renderer.clear(color)
class Simulation: white = sdl.Color(255, 255, 255, 0) black = sdl.Color(0, 0, 0, 0) red = sdl.Color(255, 0, 0, 0) def __init__(self, renderer, x, y, data): self.data = data self.widy = len(self.data[0]) self.widx = len(self.data) self.r = renderer self.__y = x * SIZE self.__x = y * SIZE def __draw_square(self, x, y): '''draw a sqaure at given points''' for i in range(y, y + SIZE): self.r.draw_line((x, i, x + SIZE, i)) def __rendercircle(self, xc, yc, r=int(SIZE / 2 - SIZE / 5)): '''function to draw circle of radius and XY coordinates''' xc, yc = int(xc), int(yc) for x in range(r): y = floor(sqrt(r**2 - x**2)) self.r.draw_line((xc + x, yc + y, xc + x, yc - y)) self.r.draw_line((xc - x, yc + y, xc - x, yc - y)) def __rendersprite(self): '''render a sprite which travels in the maze according to the path does not present the rendered sprite on window''' self.r.color = self.red self.__rendercircle(self.__x + SIZE / 2, self.__y + SIZE / 2) def build_maze(self): '''build maze in window does not present the rendered maze on window''' self.r.color = self.black for i in range(self.widx): for j in range(self.widy): if self.data[i][j] == 1: self.__draw_square(j * SIZE, i * SIZE) # pylint: disable=no-self-argument, protected-access, not-callable def renderfirst(fun): '''takes a yielding function which performs a certain rendering of the sprite in a direction and returns a wrapper over it which takes care of things like rendering maze, handling mouse click events, clearing and rendering the content of window etc''' def fullfun(self): self.__clear() for _ in fun(self): i = sdl2.SDL_GetTicks() self.build_maze() self.__rendersprite() events = sdl.get_events() for e in events: if e.type == sdl2.SDL_QUIT: return False self.__present() self.__clear() i = sdl2.SDL_GetTicks() - i if i < (1000 // 500): sdl2.SDL_Delay(1000 // 500 - i) return True return fullfun @renderfirst def move_up(self): '''move the sprite up''' for _ in range(SIZE // 2): self.__y -= 2 yield @renderfirst def move_down(self): '''move the sprite down''' for _ in range(SIZE // 2): self.__y += 2 yield @renderfirst def move_right(self): '''move the sprite right''' for _ in range(SIZE // 2): self.__x += 2 yield @renderfirst def move_left(self): '''move the sprite left''' for _ in range(SIZE // 2): self.__x -= 2 yield def __clear(self): self.r.clear(self.white) def __present(self): self.r.present()
class Renderer: WINDOW_X = 1280 WINDOW_Y = 960 PIXCNT = WINDOW_X * WINDOW_Y scale = 5 pixels = array.array('i', [c_int(0).value for i in range(PIXCNT)]) pitch = c_int() frameCount = 0 backgroundColor = sdle.Color(0, 0, 0) previousFrameTime = 0 setPixels = [] 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 blit(self, _x, _y, _sx, _sy): sdl.SDL_UpdateTexture(self.texture, None, c_void_p(self.pixels.buffer_info()[0]), c_int(self.WINDOW_X * 4)) sdl.SDL_RenderCopy(self.renderer.renderer, self.texture, None, None) self.renderer.present() def drawRect(self, _x, _y, _sx, _sy, r, g, b, a=255): for y in range(_y, _y + _sy, 1): if y >= self.WINDOW_Y - 1 or y < 0: continue for x in range(_x, _x + _sx, 1): if x >= self.WINDOW_X - 1 or x < 0: continue self.pixels[c_int(getPixel(x, y, self.WINDOW_X)).value] = c_int( getColor(r, g, b, a)).value def setPixel(self, x, y, color): #if x >=0 and y >=0 and x < self.WINDOW_X and y < self.WINDOW_Y: self.pixels[c_int(getPixel(x, y, self.WINDOW_X)).value] = color self.setPixels.append([x, y]) def drawSprite(self, sprite, ex, ey): for y in range(sprite.sy): #if y >= self.WINDOW_Y - 1 or y < 0 or y >= sprite.sy: # continue for x in range(sprite.sx): #if x >= self.WINDOW_X-1 or x < 0 or x >= sprite.sx: # continue self.setPixel(x + ex, y + ey, sprite.pixels[getPixel(x, y, sprite.sx)]) def clearScreen(self): for x, y in self.setPixels: self.pixels[c_int(getPixel(x, y, self.WINDOW_X)).value] = 0 self.setPixels = [] def render(self): self.clearScreen() for k, e in self.entities.items(): self.drawSprite(e.sprites[e.currentSprite], e.x, e.y) self.blit(0, 0, self.WINDOW_X, self.WINDOW_Y) self.frameCount = self.frameCount + 1 if self.timer.currentTime - self.previousFrameTime >= 1.0: print("fps:", self.frameCount) self.previousFrameTime = self.timer.currentTime self.frameCount = 0