def run(self): radius = 70 (xoff, yoff) = (self.dim[0] / 2, self.dim[1] / 2) (xscale, yscale) = (1, 0.5) while True: if self.iter > 2 * math.pi: self.iter = 0 self.iter += 0.01 (x1, y1) = (math.cos(self.iter) * xscale, math.sin(self.iter) * yscale) (x2, y2) = (math.cos(self.iter + math.pi / 2) * xscale, math.sin(self.iter + math.pi / 2) * yscale) (x3, y3) = (int(-x1 * radius + xoff), int(-y1 * radius + yoff)) (x4, y4) = (int(-x2 * radius + xoff), int(-y2 * radius + yoff)) (x1, y1) = (int(x1 * radius + xoff), int(y1 * radius + yoff)) (x2, y2) = (int(x2 * radius + xoff), int(y2 * radius + yoff)) # self.lock.acquire() self.surface.fill(black) draw.lines(self.surface, green, True, [(x1, y1), (x2, y2), (x3, y3), (x4, y4)], 3) draw.lines(self.surface, green, True, [(x1, y1 - radius), (x2, y2 - radius), (x3, y3 - radius), (x4, y4 - radius)], 3) draw.line(self.surface, green, (x1, y1), (x1, y1 - radius), 3) draw.line(self.surface, green, (x2, y2), (x2, y2 - radius), 3) draw.line(self.surface, green, (x3, y3), (x3, y3 - radius), 3) draw.line(self.surface, green, (x4, y4), (x4, y4 - radius), 3) vdot = rotate_vector((0, 0.6), self.iter) draw.circle(self.surface, green, (int(vdot[0] * radius * xscale + xoff), int(vdot[1] * radius * yscale + yoff - radius)), 5) # self.clock.lock.acquire() self.surface.blit(self.clock.surface, (self.dim[0] - self.clock.get_dimensions()[0] - 10, 0)) # self.clock.lock.release() # self.lock.release() time.sleep(0.005)
def tieFighter (pos, screen, color, height=40): x, y = pos width = height/8 draw.rect(screen, color, (x, y, width, height)) draw.rect(screen, color, (x+height-width, y, width, height)) draw.rect(screen, color, (x, y+(height-width)/2, height, width)) draw.circle(screen, color, (x+height/2, y+height/2), height/4)
def main(): rect = Rect((0, 0), SCREEN_SIZE) surface = Surface(SCREEN_SIZE) pxarray = PixelArray(surface) P = [(0, 100), (100, 0), (200, 0), (300, 100), (400, 200), (500, 200), (600, 100), (400, 400), (700, 50), (800, 200)] n = len(P) - 1 # n = len(P) - 1; (P[0], ... P[n]) k = 3 # degree of curve m = n + k + 1 # property of b-splines: m = n + k + 1 _t = 1 / (m - k * 2) # t between clamped ends will be evenly spaced # clamp ends and get the t between them t = k * [0] + [t_ * _t for t_ in xrange(m - (k * 2) + 1)] + [1] * k S = Bspline(P, t, k) # insert a knot (just to demonstrate the algorithm is working) S.insert(0.9) step_size = 1 / STEP_N for i in xrange(STEP_N): t_ = i * step_size try: x, y = S(t_) # if curve not defined here (t_ is out of domain): skip except AssertionError: continue x, y = int(x), int(y) pxarray[x][y] = (255, 0, 0) del pxarray for p in zip(S.X, S.Y): draw.circle(surface, (0, 255, 0), p, 3, 0) SCREEN.blit(surface, (0, 0)) while 1: for ev in event.get(): if ev.type == KEYDOWN: if ev.key == K_q: exit() display.update()
def draw_points(poly, surface, color=None, width=None): polygon = orient_multipoint(poly) c = polygon.centroid.coords[0] p = poly.position dx, dy = [p[i] - c[i] for i in range(2)] if color is None: color = (0,255,0) if width is None: width = 1 maxd = (0,None,None) for i in range(len(polygon.geoms)): p = polygon.geoms[i] draw.circle(surface, color, defloat(scale(offset((p.x,p.y), dx, dy))), 3*width) for j in range(i+1, len(polygon.geoms)): q = polygon.geoms[j] d = p.distance(q) if d > maxd[0]: maxd = (d, p, q) if maxd[0] > 0: p, q = maxd[1], maxd[2] draw.line(surface, color, defloat(scale(offset((p.x,p.y), dx, dy))), defloat(scale(offset((q.x,q.y), dx, dy))), width)
def draw(self, surface, offset): adjusted_center = (int(self.center[0] + offset[0]), int(self.center[1] + offset[1])) real_colour = [self.colour[i] + self.colour_change[i] * self.age for i in range(3)] # Typecast to an int to stop float warning radius = int(self.radius + self.radius_change * self.age) draw.circle(surface, bound_colour(real_colour), adjusted_center, radius, min(2, radius))
def draw_tie(surf, color, pos, size=40): x, y = pos width = size/8 draw.rect(surf, color, (x,y,width,size)) #first vertical line draw.rect(surf, color, (x+size-width,y,width,size)) #second vertical line draw.rect(surf, color, (x,y+(size-width)/2,size,width)) #middle horizontal draw.circle(surf, color, (x+size/2,y+size/2), size/4) #circle
def draw_tie(surf, pos, color=RED): "draw a tie fighter at location" x,y = pos draw.rect(surf, color, (x, y, 5, 40)) draw.rect(surf, color, (x+35, y, 5, 40)) draw.rect(surf, color, (x, y+17, 40, 5)) draw.circle(surf, color, (x+20, y+20), 10)
def test_filled_circles(test_surf): """Draw several filled circles""" for cent_x, color in ((100, (0, 0, 255, 255)), (400, (0, 255, 255, 255)), (600, (255, 0, 255, 255))): cent_y = 10 for radius in range(10, 100, 10): cent_y += radius + 1 draw.circle(test_surf, color, (cent_x, cent_y), radius)
def draw_tie(surf, color, pos, size=40): x, y = pos width = size/8 draw.rect(surf, color, (x,y,width,size)) draw.rect(surf, color, (x+size-width,y,width,size)) draw.rect(surf, color, (x,y+(size-width*5),size,width)) draw.circle(surf, color, (x+size/2,y+size/2),size/4)
def runGUI(): pygame.display.set_mode((800,600)) pygame.display.set_caption("Neuro Junk 2012/13") screen = pygame.display.get_surface() while True: input(pygame.event.get()) screen.fill((0,0,0)) circle(screen, (255,255,255), (0,0), radius, 1) line(screen, (255,255,255), point1, point2, 1) polygon(screen, (255,255,255), outer_line, 2) polygon(screen, (255,255,255), inner_line,2) if intersectCircle(point1, point2, radius): rect(screen, (0,255,0), Rect(600, 200, 100, 100), 0) inn = changeField(inner_line, car) out = changeField(outer_line, car) csect = curSection(inn, out) polygon(screen, (0,0,255), out, 2) polygon(screen, (0,0,255), inn, 2) rect(screen, (255,255,255), Rect(car.x-2, car.y-2, 4, 4), 0) if csect is not None: line(screen, (0,255,0), csect.inner_start, csect.inner_end, 1) line(screen, (0,255,0), csect.outer_start, csect.outer_end, 1) pygame.display.update()
def drawGeom(geom): if type(geom) is ode.GeomBox: x, y, _ = geom.getPosition() a, b, _ = geom.getLengths() r = geom.getRotation() costheta = r[0]; sintheta = r[1] p1 = to_screen_pnt(x + a/2 * costheta + b/2 * sintheta, y - a/2 * sintheta + b/2 * costheta) p2 = to_screen_pnt(x + a/2 * costheta - b/2 * sintheta, y - a/2 * sintheta - b/2 * costheta) p3 = to_screen_pnt(x - a/2 * costheta - b/2 * sintheta, y + a/2 * sintheta - b/2 * costheta) p4 = to_screen_pnt(x - a/2 * costheta + b/2 * sintheta, y + a/2 * sintheta + b/2 * costheta) draw.lines(screen, actual_color(getattr(geom, 'color', blue)), True, [p1, p2, p3, p4]) elif type(geom) is ode.GeomSphere: x, y, _ = geom.getPosition() r = geom.getRadius() rotmat = geom.getRotation() costheta = rotmat[0]; sintheta = rotmat[1] px, py = to_screen_pnt(x, y) pr = to_screen_len(r) draw.circle(screen, actual_color(getattr(geom, 'color', blue)), (int(px), int(py)), int(pr), 1) drawLine((x,y), (x + costheta * r, y - sintheta * r), getattr(geom, 'color', blue)) elif type(geom) is ode.GeomCapsule: x, y, _ = geom.getPosition() pass elif isinstance(geom, ode.SpaceBase): for i in geom: drawGeom(i) else: assert False
def test_hollow_circles(test_surf): """Draw several circles of different thicknesses and sizes""" for thickness in range(1, 7): cent_x = 100 + thickness * 50 cent_y = 10 for radius in range(10, 200, 10): cent_y += radius + 1 draw.circle(test_surf, (255, 255, 255, 255), (cent_x, cent_y), radius, thickness)
def drawTie(surf, color, pos, size=80): x, y = pos width = size / 8 # Drawing Tie Fighter here draw.rect(surf, color, (x, y, width, size)) draw.rect(surf, color, (x + size - width, y, width, size)) draw.rect(surf, color, (x, y + (size - width) / 2, size, width)) draw.circle(surf, color, (x + size / 2, y + size / 2), size / 4)
def red_bike(surf, pos, color=(255, 0, 0), size=40): x, y = pos width = size / 8 draw.circle(surf, color, (x, y, width, size)) draw.rect(surf, color, (x + (size - width), y, width, size)) draw.circle(surf, color, (x + size / 2, y + size / 2), size / 4)
def _show_detection(self): if hasattr(self.status, 'detected_by'): radius = 0 for obj in self.status.detected_by: if obj.selected: radius += 6 pos = (self.rect.width // 2, self.rect.height // 2) circle(self.image, obj._debug_color, pos, radius, 3)
def head(surface, mod, pos): # adjust for body size radius = ((mod["bodySize"] + 1) * 4) + 10 color = skinColor(mod) draw.circle(surface, (0,0,0), pos, radius) draw.circle(surface, color, pos, int(radius * .90)) return Rect(pos[0] - radius, pos[1] - radius, radius * 2, radius * 2)
def draw(self): # light = self._LIGHT # for px, py, r in self.trail[::-1]: # pygame.draw.circle(self.surface, # (light,0,0), # list(map(Utils.round_int,[px,py])), # r) # light += self._LIGHT draw.circle(self.surface, self._COLOR, list(map(Utils.round_int, self.pos)), self.radius)
def drawTieFighter(surf, pos, size = 40, col=(100,100,100)): width = size / 8 x,y = pos draw.rect(screen, col, (x+0, y+0, width, size)) draw.rect(screen, col, (x+size - width, y, width, size)) draw.rect(screen, col, (x, y + (size - width)/2, size,width)) draw.circle(screen, col, (x + size/2, y+ size / 2), size/4)
def draw_chess(screen, gobang): board = gobang.board cols, rows = board.shape chess_radius = grid_size / 2 - 2 for c in xrange(cols): for r in xrange(rows): v = board[(c,r)] if v in chess_colors: draw.circle(screen, chess_colors[v], to_pixel_pos((c, r)), chess_radius)
def display(self, surface): myfont = font.Font(None, 2*self.display_weight) label = myfont.render(self.label, 1, Config.vertex_label_color) d_pos = ( int(self.x) + (Config.frameWidth/2), int(self.y) + (Config.frameHeight/2) ) circle(surface, self.color, d_pos, self.display_weight, self.width) surface.blit(label, (d_pos[0]+self.display_weight+5,d_pos[1]))
def draw_tie(surf, pos, color=(255,0,0), size=40): "Draws a tie fighter" x,y = pos width = size/8 draw.rect(surf, color, (x, y, width, size)) draw.rect(surf, color, (x+(size-width), y, width, size)) draw.rect(surf, color, (x, y+(size-width)/2, size, width)) draw.circle(surf, color, (x+size/2, y+size/2), size/4)
def draw(self, surface): pos = self.spiral.screen.adjust_to_viewport(self.cart()) if not self.screen.collidepoint(pos): return pos = map(int, pos) if self.unhittable: color = (100, 100, 100) else: color = self.spiral.screen.gc("avatar", self.color) draw.circle(surface, color, pos, 10, 1 if self.hit else 0)
def build_Turtle_list_images(self,w,h): """ cree 360 images de tortues (une par degre)""" imglist = [pygame.Surface((w,h)).convert() for a in range(360)] for a,img in zip(range(360),imglist): img.set_colorkey( (0,0,0) ) img.fill((0,0,0)) circle(img, glo.WHITE, (w/2,h/2), self.taille_geometrique/2 - self.penwidth,self.penwidth) polygons.draw_arrow(img,w/2,h/2,a * pi/180,r=self.taille_geometrique-14,clr=glo.WHITE) #pygame.gfxdraw.aacircle(self.image, w/2,h/2, self.taille_geometrique/2 - self.penwidth,glo.WHITE) return imglist
def update(self, seconds): self.paintmap() draw.rect(self.image, (255,255,255), (round(-game_data.camera[0] * self.factorx,0), round(-game_data.camera[1] * self.factory,0), round(game_data.width * self.factorx, 0), round((game_data.height - game_data.infobar_height) * self.factory, 0)),1) for unit in groups.unitgroup: pos = unit.trueX, unit.trueY draw.circle(self.image, unit.owner.color, (int(pos[0] * self.factorx), int(pos[1] * self.factory)), unit.size )
def draw_tie(surf, tie): "Draws a tie fighter" color = 255,0,0 x,y,dx,dy,size = tie width = size/8 draw.rect(surf, color, (x, y, width, size)) draw.rect(surf, color, (x+(size-width), y, width, size)) draw.rect(surf, color, (x, y+(size-width)/2, size, width)) draw.circle(surf, color, (x+size/2, y+size/2), size/4)
def draw_tie(surf, pos, color=(randrange(100,256), randrange(100,256), randrange(100,256)), size=40): "Draws a tie fighter" x,y = pos wall = size/8 x0,x1 = x - (size/2), x + (size/2) y0,y1 = y - (size/2), y + (size/2) draw.rect(surf, color, (x0, y0, wall, size)) draw.rect(surf, color, (x1-wall, y0, wall, size)) draw.rect(surf, color, (x0, y-(wall/2), size, wall)) draw.circle(surf, color, (x, y), size/4)
def __init__(self): super(Bullet, self).__init__() self.r = config.bulletR self.m = config.bulletM self.shape = ShapeCircle(self.r) self.t = 0 self.length = 0 self.I = 0 self.damage = 0 # image self.image = Surface(Size).convert_alpha() self.image.fill((0, 0, 0, 0)) self.rect = Rect((0, 0), Size) draw.circle(self.image, (0, 0, 0, 0xff), self.rect.center, self.r)
def draw(self): dr.circle(screen, self.color, self.pos, self.size)
from pygame import display, draw, time, event import random import pygame import sys screen = display.set_mode([800,600]) clock = time.Clock() circles = [] random.seed() while True: screen.fill([0,0,0]) action = event.poll() if action.type == pygame.KEYDOWN: sys.exit() for i in range(len(circles)-1): lst = list(circles[i]) lst[3] += 1 circles[i] = tuple(lst) draw.circle(circles[i][0],circles[i][1],circles[i][2],circles[i][3],circles[i][4]) reusedCircles = [] for i in range(len(circles)): if circles[i][3] <= 80: reusedCircles.append(circles[i]) circles = reusedCircles if len(circles) <= 20: circles.append((screen, [255,255,255], [random.randint(0,800),random.randint(0,600)],0,1)) display.flip() clock.tick(60)
done = True if is_red: color2 = (0, 0, 255) else: color2 = (255, 0, 0) if is_red: color = (255, 0, 0) else: color = (0, 0, 255) screen.fill((0, 0, 0)) if xp <= r: xp = r if yp <= r: yp = r if xp >= col_right: xp = col_right if yp >= col_bott: yp = col_bott draw.circle(screen, color, (xp, yp), r) draw.circle(screen, color2, (xf, yf), r) timerString = timerFont.render(gameTimer.render(), True, (255, 255, 255)) screen.blit(timerString, (0, 0)) display.flip() clock.tick(60) while done: for e in event.get(): if e.type == QUIT: quit() exit()
def draw_tie(surf, color, pos): x,y = pos draw.rect(surf, color, (x,y,5,40)) draw.rect(surf, color, (x+35,y,5,40)) draw.rect(surf, color, (x,y+17,40,5)) draw.circle(surf, color, (x+20,y+20), 10)
def render(self): global game, fadeout if self.hp > 0: # Наклон картинки self.angle = angle_calc(self.x, self.y, self.aim[0], self.aim[1]) self.image_active = rotate(self.images[self.state], self.angle) # Обработка нажатия клавиш if self.up: if self.dy - self.Acceleration > -self.Move: self.dy -= self.Acceleration else: self.dy = -self.Move if self.down: if self.dy + self.Acceleration < self.Move: self.dy += self.Acceleration else: self.dy = self.Move if self.left: if self.dx - self.Acceleration > -self.Move: self.dx -= self.Acceleration else: self.dx = -self.Move if self.right: if self.dx + self.Acceleration < self.Move: self.dx += self.Acceleration else: self.dx = self.Move if self.click: if not self.rect.collidepoint(self.aim): if ((self.shoot_delay0 >= weapons[self.weapon]['rate']) and (self.rapidfire0 == 0)) or \ ((self.shoot_delay0 >= weapons[self.weapon]['rate'] // 2) and (self.rapidfire0 != 0)): if self.bullet_count0 < weapons[self.weapon]['bull_c']: self.shoot_delay0 = 0 self.bullet_count0 += 1 self.state = 'active' # Создание пули if self.weapon == 'flamethrower': Player.bullet.append( Bullet( self.x, self.y, self.weapon, self.fire_bullet, uniform(self.angle - 30, self.angle + 30))) elif self.weapon == 'shotgun': Player.bullet.extend( Bullet( self.x, self.y, self.weapon, self.fire_bullet, uniform(self.angle - 10, self.angle + 10)) for n in range(2)) elif self.weapon == 'ak47': Player.bullet.append( Bullet( self.x, self.y, self.weapon, self.fire_bullet, uniform(self.angle - 8, self.angle + 8))) elif self.weapon == 'm249': Player.bullet.append( Bullet( self.x, self.y, self.weapon, self.fire_bullet, uniform(self.angle - 15, self.angle + 15))) elif self.weapon in ['gun', 'rifle', 'launcher']: Player.bullet.append( Bullet(self.x, self.y, self.weapon, self.fire_bullet, self.angle)) # Звук выстрела weapons[self.weapon]['sound'].play() # Эффекы при выстреле if self.weapon != 'flamethrower': Player.effects.append( Effect(self.x, self.y, self.angle, 5, 'fire')) if self.shoot_delay0 + 1 <= weapons[self.weapon]['rate']: self.shoot_delay0 += 1 # Перезарядка if weapons[self.weapon]['bull_c'] <= self.bullet_count0: self.reload0 += 1 if self.reload0 == 1: if self.weapon != 'launcher': weapons[self.weapon]['sound_r'].play() if self.reload0 >= weapons[self.weapon]['reload']: self.reload0 = self.bullet_count0 = 0 # Скорострельный режим if self.rapidfire0 > 0: self.rapidfire0 += 1 if self.rapidfire0 >= self.rapidfire: self.rapidfire0 = 0 # Торможение if (self.up is False) and (self.down is False): if self.dy - self.Break > 0: self.dy -= self.Break elif self.dy + self.Break < 0: self.dy += self.Break else: self.dy = 0 if (self.left is False) and (self.right is False): if self.dx - self.Break > 0: self.dx -= self.Break elif self.dx + self.Break < 0: self.dx += self.Break else: self.dx = 0 # Бронежилет if self.armor > 0: circle(Player.screen, (48, 163, 244), Player.camera.get_pos(self.x, self.y, True), 25, int(self.armor / 20 + 1)) # Отображение картинки Player.screen.blit( self.image_active, Player.camera.get_pos(self.x - self.image_active.get_width() // 2, self.y - self.image_active.get_height() // 2)) # Границы мира if (self.x <= self.image_active.get_width() // 2) and (self.dx < 0): self.dx = 0 self.x = self.image_active.get_width() // 2 if (self.x + self.image_active.get_width() // 2 >= F_SIZE[0]) and (self.dx > 0): self.dx = 0 self.x = F_SIZE[0] - self.image_active.get_width() // 2 if (self.y <= self.image_active.get_height() // 2) and (self.dy < 0): self.dy = 0 self.y = self.image_active.get_height() // 2 if (self.y + self.image_active.get_height() // 2 >= F_SIZE[1]) and (self.dy > 0): self.dy = 0 self.y = F_SIZE[1] - self.image_active.get_height() // 2 # Жизни героя if self.hp <= 0: self.hp = 0 if self.weapon != 'launcher': weapons[self.weapon]['sound_r'].stop() fadeout.set_alpha(fadeout.get_alpha() + 1) self.up = self.down = self.right = self.left = self.click = False if self.hurt: self.hurt_delay0 += 1 if self.hurt_delay0 > 0: self.hurt_delay0 += 1 if self.hurt_delay0 >= self.hurt_delay: self.hurt = False self.hurt_delay0 = 0 # Перемещение self.x += self.dx self.y += self.dy # Столкновение self.rect.centerx = self.x self.collision(self.dx, 0) self.rect.centery = self.y self.collision(0, self.dy)
def recolorBase(self,value:float): edge = Color(int(min(255 * (2 - 2 * value), 255)), int(min(255 * value * 2, 255)), 0) self.surface.fill(edge) draw.rect(self.surface, Color(0, 0, 0), Rect(self.sizeX / 10, self.sizeY / 10, self.sizeX * 0.8, self.sizeY * 0.8)) draw.circle(self.surface, Color(0, 0, 80), (self.sizeX / 2, self.sizeX / 2), (self.sizeX * 0.4))
def DrawBubbles(Bubbles): for bubble in Bubbles: draw.circle(screen, bubble.colour, bubble.center, bubble.radius, 1) if bubble.radius < 50: bubble.expand()
def draw(a, screen): """Draws an object on the screen """ circle(screen, a.colour, (norm_pos(a.x) + width / 2, norm_pos(a.y) + height / 2), norm_rad(a.radius), 0)
def __init__(self, parent_obj, location, radius, load_img=False): super().__init__(parent_obj, location, radius * 2, radius * 2, load_img) self.radius = radius draw.circle(self.surface, Color("#2931b3"), [self.radius, self.radius], self.radius)
def show(self, surface): for ray in self.rays: ray.show(surface) draw.circle(surface, self.color, self.pos/4, 6)
from random import randint import pygame from pygame import display, draw, time, event class circle: def __init__(self): self.color = [randint(0, 255), randint(0, 255), randint(0, 255)] self.center = [randint(0, 800), randint(0, 600)] self.radius = 1 self.maxr = randint(20, 100) screen = display.set_mode([800, 600]) clock = time.Clock() drops = [] while True: screen.fill([0, 0, 0]) for d in drops[:]: draw.circle(screen, d.color, d.center, d.radius, 1) d.radius += 1 if d.radius >= d.maxr: drops.remove(d) drops.append(circle()) display.flip() clock.tick(60) if event.poll().type == pygame.KEYDOWN: break
def draw(self, screen): draw.circle(screen, self.color, [int(self.x), int(self.y)], int(width / len(particles) / 2))
def circle(x, y, radius, color, width=0): """Zeichnet einen Kreis. X und y sind der Mittelpunkt""" pydraw.circle(DISPLAY, color, (x, y), radius, width)
def _draw_close_over(self, image, size): image.fill(self._settings["col_border"]) draw.circle(image, (234, 14, 50), (size[0] / 2, size[1] / 2), 8) draw.line(image, (0, 0, 1), (5, 5), (11, 11), 5) draw.line(image, (0, 0, 1), (5, 11), (11, 5), 5)
def _draw(self, deco: List[Tuple[int, str, Any]], surface: 'pygame.Surface') -> None: """ Draw. :param deco: Decoration list :param surface: Pygame surface :return: None """ if len(deco) == 0: return rect = self._obj.get_rect() for d in deco: dtype, decoid, data = d if not self._decor_enabled[decoid]: continue if dtype == DECORATION_POLYGON: points, color, filled, width, gfx, kwargs = data points = self._update_pos_list(rect, decoid, points, **kwargs) if gfx: if filled: gfxdraw.filled_polygon(surface, points, color) else: gfxdraw.polygon(surface, points, color) else: pydraw.polygon(surface, color, points, width) elif dtype == DECORATION_CIRCLE: points, r, color, filled, width, gfx, kwargs = data points = self._update_pos_list(rect, decoid, points, **kwargs) x, y = points[0] if filled: if gfx: gfxdraw.filled_circle(surface, x, y, r, color) else: pydraw.circle(surface, color, (x, y), r) else: pydraw.circle(surface, color, (x, y), r, width) elif dtype == DECORATION_SURFACE or dtype == DECORATION_BASEIMAGE or dtype == DECORATION_TEXT: pos, surf, centered, kwargs = data if isinstance(surf, pygame_menu.BaseImage): surf = surf.get_surface(new=False) pos = self._update_pos_list(rect, decoid, pos, **kwargs)[0] surfrect = surf.get_rect() surfrect.x += pos[0] surfrect.y += pos[1] if centered: surfrect.x -= surfrect.width / 2 surfrect.y -= surfrect.height / 2 surface.blit(surf, surfrect) elif dtype == DECORATION_ELLIPSE: pos, rx, ry, color, filled, kwargs = data pos = self._update_pos_list(rect, decoid, pos, **kwargs)[0] if filled: gfxdraw.filled_ellipse(surface, pos[0], pos[1], rx, ry, color) else: gfxdraw.ellipse(surface, pos[0], pos[1], rx, ry, color) elif dtype == DECORATION_CALLABLE: data(surface, self._obj) elif dtype == DECORATION_CALLABLE_NO_ARGS: data() elif dtype == DECORATION_TEXTURE_POLYGON: pos, texture, tx, ty, kwargs = data pos = self._update_pos_list(rect, decoid, pos, **kwargs) if isinstance(texture, pygame_menu.BaseImage): texture = texture.get_surface() gfxdraw.textured_polygon(surface, pos, texture, tx, ty) elif dtype == DECORATION_ARC: points, r, ia, fa, color, width, gfx, kwargs = data points = self._update_pos_list(rect, decoid, points, **kwargs) x, y = points[0] rect_arc = pygame.Rect(x - r, y - r, x + 2 * r, y + 2 * r) if gfx: gfxdraw.arc(surface, x, y, r, ia, fa, color) else: pydraw.arc(surface, color, rect_arc, ia / (2 * pi), fa / (2 * pi), width) elif dtype == DECORATION_PIE: points, r, ia, fa, color, kwargs = data points = self._update_pos_list(rect, decoid, points, **kwargs) x, y = points[0] gfxdraw.pie(surface, x, y, r, ia, fa, color) elif dtype == DECORATION_BEZIER: points, color, steps, kwargs = data points = self._update_pos_list(rect, decoid, points, **kwargs) gfxdraw.bezier(surface, points, steps, color) elif dtype == DECORATION_FILL: surface.fill(data, rect) elif dtype == DECORATION_RECT: drect: 'pygame.Rect' pos, drect, color, width, kwargs = data pos = self._update_pos_list(rect, decoid, pos, **kwargs)[0] drect = drect.copy() drect.x += pos[0] drect.y += pos[1] pygame.draw.rect(surface, color, drect, width) elif dtype == DECORATION_PIXEL: pos, color, kwargs = data pos = self._update_pos_list(rect, decoid, pos, **kwargs)[0] gfxdraw.pixel(surface, pos[0], pos[1], color) elif dtype == DECORATION_LINE: pos, color, width, kwargs = data pos = self._update_pos_list(rect, decoid, pos, **kwargs) pydraw.line(surface, color, pos[0], pos[1], width) else: raise ValueError('unknown decoration type')
def draw(self, surface): draw.circle(surface, Colors.white, self.pos.int_tuple(), Projectile.max_radius)
for s in range(iterations): ''' A single movement/action/update... ''' for event in pygame.event.get(): if event.type == pygame.QUIT: pygame.quit(); sys.exit(); takeAction() for i in range(0, grid_h): for j in range(0, grid_w): x,y = j*pixWid+offset, i*pixWid+offset circle(gui, (190,190,190), (x,y), rad, 0) q = state[i][j].quality # [up-q, right-q, down-q, left-q] line(gui,color(q[0]),True,((x-ll,y-rad),(x-ll,y-pixWid+rad)),ll*2) line(gui,color(q[1]),True,((x+rad,y-ll),(x+pixWid-rad,y-ll)),ll*2) line(gui,color(q[2]),True,((x+ll,y+rad),(x+ll,y+pixWid-rad)),ll*2) line(gui,color(q[3]),True,((x-rad,y+ll),(x-pixWid+rad,y+ll)),ll*2) pygame.display.update() # highlight the best route moveDelay = 0.25 row, col, movNum = 0, 0, 0
finalize_button.update(elapsed, mouse.get_pos(), any(mouse.get_pressed())) unfinalize_button.update(elapsed, mouse.get_pos(), any(mouse.get_pressed())) reset_land_button.update(elapsed, mouse.get_pos(), any(mouse.get_pressed())) screen.fill((0, 0, 0)) viewport.draw(screen) create_landmass_button.draw(screen) finalize_button.draw(screen) unfinalize_button.draw(screen) reset_land_button.draw(screen) if is_creating_landmass: draw.circle(screen, (255, 0, 0), mouse.get_pos(), 5) elif is_setting_landmass_distance: converted_origin = viewport.deconvert_mouse_pos(land_mass_origin) mouse_pos = mouse.get_pos() distance = ((mouse_pos[0] - converted_origin[0])**2 + (mouse_pos[1] - converted_origin[1])**2)**0.5 draw.circle(screen, (255, 0, 0), converted_origin, 5) draw.circle(screen, (255, 0, 0), converted_origin, max(5, int(distance)), 2) display.flip() display.quit() font.quit()
def draw(self, shape_name=None): super().draw(shape_name=shape_name) if self.selected: radius = round((BLOCK_SPACING() / 2) * self.scale * 1.5) circle(gui.SCREEN, Color('red'), self.rect.center, radius, 1)
def render(self): # .. draw a dot draw.circle(screen, WHITE, self.position, self.size, 0)
COLORS = [RED, BLUE, YELLOW, GREEN, MAGENTA, CYAN] class Ball(): def __init__(self, color, x, y, r, speed_x, speed_y, lifes): self.x = x self.y = y self.r = r self.color = color self.lifes = lifes self.speed_x = speed_x self.speed_y = speed_y d.circle(screen, self.color, (self.x, self.y), self.r) def move(self): d.circle(screen, BLACK, (self.x, self.y), self.r) self.x += self.speed_x self.y += self.speed_y d.circle(screen, self.color, (self.x, self.y), self.r) def change_color(self, color): self.color = color
def move(self): d.circle(screen, BLACK, (self.x, self.y), self.r)
def remove_ball(self): d.circle(screen, BLACK, (self.x, self.y), self.r)
import pygame import pygame.draw as d pygame.init() FPS = 30 screen = pygame.display.set_mode((400, 400)) d.rect(screen, (255, 255, 255), (0, 0, 400, 400)) d.circle(screen, (255, 255, 0), (200, 175), 100) d.circle(screen, (0, 0, 0), (200, 175), 101, 1) d.line(screen, (0, 0, 0), (95, 80), (180, 140), 10) d.line(screen, (0, 0, 0), (220, 140), (300, 105), 10) d.circle(screen, (255, 0, 0), (150, 150), 20) d.circle(screen, (0, 0, 0), (150, 150), 21, 1) d.circle(screen, (255, 0, 0), (250, 150), 15) d.circle(screen, (0, 0, 0), (250, 150), 16, 1) d.circle(screen, (0, 0, 0), (150, 150), 10) d.circle(screen, (0, 0, 0), (250, 150), 8) d.rect(screen, (0, 0, 0), (145, 220, 110, 25)) pygame.display.update() clock = pygame.time.Clock() finished = False while not finished: clock.tick(FPS) for event in pygame.event.get(): if event.type == pygame.QUIT: finished = True
def draw(self): (w, h) = self.screen.get_size() circle(self.screen, (255, 0, 0), (w // 2, h // 2), self.radius)
def draw(self) -> None: """ Draw the ball """ draw.circle(self._window, self._color, (self._x_pos, self._y_pos), BALL_RADIUS)
def _draw_close_off(self, image, size): image.fill(self._settings["col_border"]) draw.circle(image, (140, 6, 15), (size[0] / 2, size[1] / 2), 8) draw.line(image, (0, 0, 1), (5, 5), (11, 11), 3) draw.line(image, (0, 0, 1), (5, 11), (11, 5), 3)
def render(self): draw.circle(self.screen, (0, 0, 0), (int(self.xPos), int(self.yPos)), self.rad, 0)
while not close_game: # Event handling for e in pygame.event.get(): # Quit event handling if e.type == pygame.QUIT: pygame.quit() break # Key press event handling if e.type == pygame.KEYDOWN: if e.key == pygame.K_ESCAPE: pygame.quit() break # Mouse moved event handling if e.type == pygame.MOUSEMOTION: pos = e.pos # Clearing screen screen.fill((0, 0, 0)) # Rendering # draw.rect(screen, (255, 0 ,0), [pos[0]-5, pos[1]-5, 10, 10]) draw.circle(screen, (255, 0, 0), pos, 10) # Update screen display.update()
def draw2(a, screen): """Draws an object in the middle of the screen """ circle(screen, a.colour, (width / 2, height / 2), a.radius, 0)
def draw(self, screen): draw.circle( screen, (0, 0, 0), (int(self.x), int(self.y)), self.rad )
def drawUpdatedMinimap(self, world, player, rays, coords): scale = self.minimap_scale player_coords = ((player.coords+1) * scale).rounded().toInt().toTuple() player_direction = player.direction * scale player_direction = (player_direction + player_coords).rounded().toInt().toTuple() minimap = self.minimap_surface.copy() draw.circle( minimap, player.map_color, player_coords, round(player.size*scale) ) for ray in rays: draw.line( minimap, (0,255,0), player_coords, ((ray['coords'][0]+1)*scale, (ray['coords'][1]+1)*scale) ) draw.line( minimap, player.map_color, player_coords, player_direction ) self.screen.blit(minimap, coords)
def _draw(self): intersected = set() objs = self.objects for e1 in self.edges: for e2 in self.edges: if e1 != e2 and e1 not in intersected: s1 = gd2.Segment(objs[e1[0]], objs[e1[1]]) s2 = gd2.Segment(objs[e2[0]], objs[e2[1]]) if gd2.intersect_seg(s1, s2, self.config.accuracy): intersected.add(e1) intersected.add(e2) for edge in self.edges: p1 = self.objects[edge[0]] p2 = self.objects[edge[1]] color = self.config.line.color if edge in intersected: color = self.config.line.bad_color if self.grub_id is not None: if edge[0] == self.grub_id or edge[1] == self.grub_id: color = self.config.line.active_color pd.line(self.display, color, (p1.x, p1.y), (p2.x, p2.y), self.config.line.width) #pd.aaline(self.display, color, (p1.x, p1.y), (p2.x, p2.y), True) for id, point in self.objects.items(): color = self.config.circle.color if id == self.grub_id: color = self.config.circle.active_color pd.circle(self.display, color, (int(round(point.x)), int(round(point.y))), int(round(point.radius))) #pgfx.aacircle(self.display, int(round(point.x)), int(round(point.y)), int(round(point.radius)), color) self._render_info("tangled: {}/{}".format(len(intersected), len(self.edges)))