def _do_graphics(self, y_r1, y_r2, x_ball, y_ball):
"""
Draw the main game graphics.
:param y_r1: y coordinate of the first pad
:param y_r2: y coordinate of the second pad
:param x_ball: x coordinate of the ball
:param y_ball: y coordinate of the ball
:return: None
"""
self.__screen.fill(COLOR_LIGHT_GRAY)
for i in range(int(self.__width / self.__grid_width)):
for j in range(int(self.__height / self.__grid_width)):
gfxdraw.aacircle(self.__screen,
self.__grid_x_offset + i * self.__grid_width,
self.__grid_y_offset + j * self.__grid_width,
self.__grid_radius, COLOR_SILVER)
aa_rounded_rect(self.__screen,
(self.__x_r1, y_r1, self.__width_r, self.__height_r),
COLOR_BLUE_2, 1)
aa_rounded_rect(self.__screen,
(self.__x_r2, y_r2, self.__width_r, self.__height_r),
COLOR_RED_2, 1)
gfxdraw.aacircle(self.__screen, round(x_ball), round(y_ball),
self.__ball_radius, COLOR_GRAY)
gfxdraw.filled_circle(self.__screen, round(x_ball), round(y_ball),
self.__ball_radius, COLOR_GRAY)
pygame.display.flip()
def render(self):
#~ draw magnetradius
if self.magnetradius:
#~ gfxdraw.aacircle(scr,self.centerx,self.centery,int(self.magnetradius),(150,130,110,int(self.magnetradius)))
m = image.load('img/magnetichalo.png')
m = transform.smoothscale(m,[int(self.magnetradius*2)]*2)
scr.blit(m,m.get_rect(center=self.center))
#~ draw shieldbar
r = draw.rect(scr,(50,50,50),(10,500,380,18),1)
osdlayer.fill((100,100,200,self.shieldfxttl*4+150),(10,0,self.shield_/self.shieldmax*380,18))
scr.blit(self.SHIELDTEXT,self.SHIELDRECT)
#~ draw lazerstate
r = draw.rect(scr,(50,50,50),(10,520,380,18),1)
osdlayer.blit(self.lazertempfx,(10,20),(0,0,DoubleLazer.temper/DoubleLazer.tempmax*380,18))
scr.blit(self.LAZERTEXT,self.LAZERRECT)
#~ draw bonusbar
self.settingbonus_.render()
self.loader1_.render()
#~ draw shieldcircle
if self.shieldfxttl:
self.shieldcolor.a = int(4*self.shieldfxttl)
gfxdraw.filled_circle(scr, self.centerx, self.centery, self.w, self.shieldcolor)
self.shieldfxttl -= 1
if self.foo:
self.foo -= 1
scr.blit(self.img2,ship)
return
#~ draw ship
scr.blit(self.img,ship)
def draw_o(self, loc):
B = self.board
loc = B.resolve_loc(loc)
rad = iround((B.tilesize/2) * 0.6)
gfxdraw.filled_circle(B.sfc, loc[0], loc[1], rad, (120,120,120))
gfxdraw.aacircle(B.sfc, loc[0], loc[1], rad + 2, black)
B.scr.blit(B.sfc, (0,0))
def undo_move(board, row, col):
drop_piece(board, row, col, 0)
filled_circle(screen, int(row), int(col), radius, black)
aacircle(screen, int(row), int(col), radius, black)
draw_black_coin(
int(col * sq_size) + 5, height - int(row * sq_size + sq_size - 5))
print_board(board)
def render(self, surf: pygame.Surface):
color = self.color
n = len(self.points) - 1
i = 0
last_pos = None
for t in range(self.reso):
t /= self.reso
tt = 1 - t
end = V2(0, 0)
for k, p in enumerate(self.points):
end += comb(n, k) * p * t**k * tt**(n - k)
if end.ti == last_pos:
i += 1
continue
else:
last_pos = end.ti
if callable(self.color):
color = self.color(t)
if self.line_width < 2:
surf.set_at(end.ti, color)
else:
x, y = end.ti
gfxdraw.aacircle(surf, x, y, round(self.line_width / 2), color)
gfxdraw.filled_circle(surf, x, y, round(self.line_width / 2),
color)
print(i, self.reso, sep='/')
def shineCircle(r):
w = h = r * 2 + 1
sf = pg.Surface((w, h), flags=pg.SRCALPHA)
for i in range(r):
alpha = (255 // r) * (i + 1)
gfx.filled_circle(sf, r, r, r - i, (255, 255, 255, alpha))
return sf
def getDiceSurface(self, surface, n, rectArgs):
if (n > 0):
x, y, width, height = rectArgs
dice = {
1: [[False] * 3, [False, True, False], [False] * 3],
2: [[True, False, False], [False] * 3, [False, False, True]],
3: [[True, False, False], [False, True, False],
[False, False, True]],
4: [[True, False, True], [False] * 3, [True, False, True]],
5: [[True, False, True], [False, True, False],
[True, False, True]],
6: [[True, False, True]] * 3
}
diceList = dice[n]
spacing = width / 7
for i in range(3):
for j in range(3):
x = 2 * i + 1
y = 2 * j + 1
x0 = int(x * spacing)
y0 = int(y * spacing)
x1 = int(x0 + spacing)
y1 = int(y0 + spacing)
r = spacing / 2
cx, cy = x0 + r, y0 + r
cx, cy = int(cx), int(cy)
r = int(r * 1.5)
if (diceList[i][j]):
gfxdraw.aacircle(surface, cx, cy, r, Colors.WHITE)
gfxdraw.filled_circle(surface, cx, cy, r, Colors.WHITE)
def disp_board(self):
score = [0, 0]
RED = (255, 0, 0)
BLUE = (0, 0, 255)
self.Black = (0, 0, 0)
for i, point in enumerate(self.gamm.board):
gfxdraw.filled_circle(self.SURF, point.x, point.y, 5, self.Black)
gfxdraw.aacircle(self.SURF, point.x, point.y, 5, self.Black)
dot_num = self.dot_font.render(str(i), True, self.Black)
self.SURF.blit(dot_num, (point.x + 10, point.y - 20))
if len(self.gamm.moves_done) > 0:
for move in self.gamm.moves_done:
p1 = self.gamm.board[self.gamm.id_to_index(move.partners[0])]
p2 = self.gamm.board[self.gamm.id_to_index(move.partners[1])]
thickness = 3
if move.O == "X":
pygame.draw.line(self.SURF, BLUE, (p1.x, p1.y),
(p2.x, p2.y), thickness)
elif move.O == "O":
pygame.draw.line(self.SURF, RED, (p1.x, p1.y),
(p2.x, p2.y), thickness)
pygame.display.update()
def draw(self): global BLINDMODE for s in self.mainplayer.selected: gfxdraw.aacircle(self.screen,s.x,s.y,s.radius+5,selectedcolor) gfxdraw.filled_circle(self.screen,s.x,s.y,s.radius+5,selectedcolor) gfxdraw.aacircle(self.screen,s.x,s.y,s.radius+3,(0,0,0)) gfxdraw.filled_circle(self.screen,s.x,s.y,s.radius+3,(0,0,0)) for planet in self.planets: planet.draw(self.screen) if not BLINDMODE: planet.drawpower(self.screen) else: if planet.team==self.mainplayer.team or planet.team==0: planet.drawpower(self.screen) for fleet in self.fleets: fleet.draw(self.screen) self.drawselectionbox(self.screen) if self.paused: pause=pygame.Rect(0,0,30,100) pause.center=map(lambda l:l/2,self.screen.get_size()) pause.x-=30 pygame.draw.rect(self.screen,(255,255,255),pause) pause.x+=60 pygame.draw.rect(self.screen,(255,255,255),pause)
def circle(surface: Surface, x: int, y: int, r: int, colour):
x = int(x)
y = int(y)
r = int(r)
aacircle(surface, x, y, r, colour)
filled_circle(surface, x, y, r, colour)
def draw(self, surface): if self.status == 'dead': return elif self.status == 'dying': N = int(np.sqrt(self.power) * 10 * 4 * (float(self.death_animation) / clock.GOAL_FPS)**2) else: N = int(10 * np.sqrt(self.power)) c_inner, c_outer = self.colouring() r = self.radius x = self.position[0] y = self.position[1] for i in range(N): # d = rn.uniform(0,360) # gfx.pixel(surface, int(x+r*np.cos(d)), int(y+r*np.sin(d)), 3, c_inner) if self.direction is None: d = rn.uniform(0,360) else: s = 180 * 4 * (float(self.death_animation) / clock.GOAL_FPS)**2 d = self.direction + rn.uniform(-s,s) gfx.filled_circle(surface, int(x+r*np.cos(np.radians(d))), int(y+r*np.sin(np.radians(d))), 3, c_inner) gfx.aacircle(surface, int(x+r*np.cos(np.radians(d))), int(y+r*np.sin(np.radians(d))), 3, c_outer)
def draw(self, surface):
# cast to center
sx = ((self.x - width / 2) / self.z) * width
sy = ((self.y - height / 2) / self.z) * height
# cast back for drawing
sx = math.floor(sx + width / 2)
sy = math.floor(sy + height / 2)
# radius
r = math.floor(-(r_max / width) * self.z + r_max)
# draw star
gfxdraw.aacircle(surface, sx, sy, r, (255, 255, 255))
gfxdraw.filled_circle(surface, sx, sy, r, (255, 255, 255))
# calculate previous location
psx = math.floor(((self.x - width / 2) / self.pz) * width + width / 2)
psy = math.floor(((self.y - height / 2) / self.pz) * height +
height / 2)
# draw linne
pygame.draw.line(surface, (255, 255, 255), (psx, psy), (sx, sy), 1)
# set current depth
self.pz = (self.z + 2 * speed)
def draw(self, screen, aa=False, color=None, image=None):
if image is not None and color is not None:
planet_texture = GUI.Background(
'physics_weed.png',
[round(self.pos_x), round(self.pos_y)])
planet_texture.image = GUI.colorize(planet_texture.image, color)
screen.blit(planet_texture.image, planet_texture.rect)
elif image is not None:
planet_texture = GUI.Background(
'physics_weed.png',
[round(self.pos_x), round(self.pos_y)])
screen.blit(planet_texture.image, planet_texture.rect)
elif not aa:
if color is None:
pg.draw.circle(screen, (self.R, self.G, self.B),
(round(self.pos_x), round(self.pos_y)),
self.radius)
else:
pg.draw.circle(screen, color,
(round(self.pos_x), round(self.pos_y)),
self.radius)
else:
if color is None:
gfx.aacircle(screen, round(self.pos_x), round(self.pos_y),
self.radius, (self.R, self.G, self.B))
gfx.filled_circle(screen, round(self.pos_x), round(self.pos_y),
self.radius, (self.R, self.G, self.B))
else:
gfx.aacircle(screen, round(self.pos_x), round(self.pos_y),
self.radius, color)
gfx.filled_circle(screen, round(self.pos_x), round(self.pos_y),
self.radius, color)
def draw(self):
pygame.draw.rect(self.win, self.colour,
(self.x, self.y, self.width, self.height))
if self.vertical:
if self.curved:
pygame.draw.circle(self.win, self.colour,
(self.x + self.width // 2, self.y),
self.radius)
pygame.draw.circle(
self.win, self.colour,
(self.x + self.width // 2, self.y + self.height),
self.radius)
circle = (self.x + self.width // 2,
int(self.y + (self.max - self.value) /
(self.max - self.min) * self.height))
else:
if self.curved:
pygame.draw.circle(self.win, self.colour,
(self.x, self.y + self.height // 2),
self.radius)
pygame.draw.circle(
self.win, self.colour,
(self.x + self.width, self.y + self.height // 2),
self.radius)
circle = (int(self.x + (self.value - self.min) /
(self.max - self.min) * self.width),
self.y + self.height // 2)
gfxdraw.filled_circle(self.win, *circle, self.handleRadius,
self.handleColour)
gfxdraw.aacircle(self.win, *circle, self.handleRadius,
self.handleColour)
def update(self, *args):
#for particle in self.particle_array:
#pygame.draw.circle(self.surface, (100,100,100), (particle[0], particle[1]), particle[2], 0)
#gfxdraw.circle(self.surface, particle[0], particle[1], particle[2], (100,100,100))
#gfxdraw.pixel(self.surface, particle[0], particle[1], (100,100,100))
#for anomolyparticle in self.anomoly_array:
for particle in self.particle_array:
if (not self.pausing):
particle.update()
gfxdraw.filled_circle(self.surface, particle.x, particle.y,
particle.size, particle.color)
if (abs(anomolyparticle.x - particle.x) <
anomolyparticle.anomolygravity) and (
abs(anomolyparticle.y - particle.y) <
anomolyparticle.anomolygravity):
for particle2 in self.particle_array:
if (abs(particle2.x - particle.x) <
anomolyparticle.anomolygravity) and (
abs(particle2.y - particle.y) <
anomolyparticle.anomolygravity) and (
particle.size == particle2.size):
rednumber = (particle.color[0] +
particle2.color[0]) / 2
greennumber = (particle.color[1] +
particle2.color[1]) / 2
bluenumber = (particle.color[2] +
particle2.color[2]) / 2
color = (int(rednumber), int(greennumber),
int(bluenumber))
pygame.draw.aaline(self.surface, color,
(particle.x, particle.y),
(particle2.x, particle2.y), 1)
def drawHead(self):
for player in self.model.player_list:
if player.is_alive:
pos = tuple(map(int, player.pos))
color = player.color
if player.is_dash:
color = tuple([int(i * 127 / 255 + 128) for i in color])
gfxdraw.filled_circle(self.gameSurface, *pos,
int(player.radius), color)
# draw triangle
triRadius = player.radius * 0.7
theta = math.atan2(player.direction.y, player.direction.x)
relativeVertexStart = pg.math.Vector2(triRadius, 0).rotate(
theta * 180 / math.pi)
relativeVertices = [
relativeVertexStart.rotate(i * 120) for i in range(3)
]
vertices = [player.pos + vertex for vertex in relativeVertices]
intVertices = [int(x) for vertex in vertices for x in vertex]
gfxdraw.filled_trigon(self.gameSurface, *intVertices,
viewConst.Color_Snow)
if player.is_circling:
innerVertices = [
player.pos + 0.6 * vertex
for vertex in relativeVertices
]
intInnerVertices = [
int(x) for vertex in innerVertices for x in vertex
]
gfxdraw.filled_trigon(self.gameSurface, *intInnerVertices,
color)
def draw_fat_point(screen, point, emsize = 1024, zoom = 1.0, radius = 4, color = red):
x = int(ux(point) * zoom)
y = int((emsize-uy(point)) * zoom)
# Radius given in em units; convert to screen units
screen_height = screen.get_size()[1]
pixel_radius = radius * screen_height / float(emsize)
filled_circle(screen, x, y, int(pixel_radius), color)
def render(self, screen):
"""Renders the selected and unselected lines and the handle
Parameters
----------
screen: pygame.Surface
pygame screen
"""
pygame.draw.line(screen, self.line_a_color, self.start_a, self.end_a,
2)
pygame.draw.line(screen, self.line_b_color, self.start_b, self.end_b,
2)
if self.pressed:
shadow = pygame.Surface((50, 50), pygame.SRCALPHA)
pygame.draw.circle(shadow, (66, 134, 244, 50), (25, 25), 25)
screen.blit(shadow,
(self.ellipse_pos[0] - 25, self.ellipse_pos[1] - 25))
elif self.hover:
shadow = pygame.Surface((40, 40), pygame.SRCALPHA)
pygame.draw.circle(shadow, (66, 134, 244, 50), (20, 20), 20)
screen.blit(shadow,
(self.ellipse_pos[0] - 20, self.ellipse_pos[1] - 20))
gfxdraw.filled_circle(screen, self.ellipse_pos[0], self.ellipse_pos[1],
10, self.ellipse_color)
gfxdraw.aacircle(screen, self.ellipse_pos[0], self.ellipse_pos[1], 10,
self.ellipse_color)
def draw(self):
gfxdraw.aacircle(environment.explosionSurface,
self.x,self.y,
self.r,self.col)
gfxdraw.filled_circle(environment.explosionSurface,
self.x,self.y,
self.r,self.col)
def draw(self, ctx):
if self.img != None:
ctx.blit(self.img, (int(self.x) - self.r, int(self.y) - self.r))
else:
gfxdraw.filled_circle(ctx, int(self.x), int(self.y), self.r,
self.color)
gfxdraw.aacircle(ctx, int(self.x), int(self.y), self.r, self.color)
def draw(self, game_data: GameData):
"""
Draws the game state, including the board and the pieces.
:param game_data: All of the data associated with the game.
"""
if game_data.action == "undo":
filled_circle(
self.screen,
game_data.last_move_row,
game_data.last_move_col,
self.game_data.radius,
black,
)
aacircle(
self.screen,
game_data.last_move_row,
game_data.last_move_col,
self.game_data.radius,
black,
)
self.draw_black_coin(
game_data.last_move_col * self.game_data.sq_size + 5,
self.game_data.height -
(game_data.last_move_row * self.game_data.sq_size +
self.game_data.sq_size - 5),
)
game_data.game_board.print_board()
game_data.action = None
self.draw_board(game_data.game_board)
def draw(self, center, n): nm=2*n-1 rads = self.radius * 2/(nm*np.pi) gfxdraw.aacircle(self.screen,*center,int(rads),COLORS[(n-1)%len(COLORS)]) x = int(center[0] + (-1)**n * rads * np.cos(nm*self.theta)) y = int(center[1] + (-1)**n * rads * np.sin(nm*self.theta)) self.theta=(self.theta+self.speed)%(2*np.pi) pygame.draw.aaline(self.screen,COLORS[(n-1)%len(COLORS)],center,(x,y)) gfxdraw.aacircle(self.screen,x,y,0,COLORS[0]) gfxdraw.filled_circle(self.screen,x,y,0,COLORS[0]) if n<N: self.draw((x,y),n+1) else: dst=self.center[0]+150 gfxdraw.aacircle(self.screen,dst,y,1,COLORS[0]) gfxdraw.filled_circle(self.screen,dst,y,1,COLORS[0]) self.plotp[n-1].insert(0,y) pygame.draw.aaline(self.screen,COLORS[0],(x,y),(dst,y)) points=[(dst,y),(dst,y)] for i,pt in enumerate(self.plotp[n-1]): # gfxdraw.pixel(self.screen,dst+i,pt,(255,0,0)) points.append((dst+i,pt)) # pygame.draw.polygon(self.screen,(255,0,0),points,1) pygame.draw.aalines(self.screen,(255,0,0),False,points) if len(self.plotp[n-1])>600: self.plotp[n-1].pop()
def update(self):
self.rect = pygame.draw.circle(self.screen, self.color, CITY_LOCATION[self.areaname], CITY_SCALE_LIST[self.citysize])
gfxdraw.aacircle(self.screen,
CITY_LOCATION[self.areaname][0], CITY_LOCATION[self.areaname][1],
CITY_SCALE_LIST[self.citysize], self.color)
gfxdraw.filled_circle(self.screen,
CITY_LOCATION[self.areaname][0], CITY_LOCATION[self.areaname][1],
CITY_SCALE_LIST[self.citysize], self.color)
def circleFadedEdges(r, startFade):
w = h = r * 2 + 1
startR = int(startFade * r)
sf = pg.Surface((w, h), flags=pg.SRCALPHA)
for i in range(r - startR):
alpha = (255 // (r - startR)) * (i + 1)
gfx.filled_circle(sf, r, r, r - i, (255, 255, 255, alpha))
return sf
def drawButtons(self):
buttonR = int(self.buttonWidth / 2)
gfxdraw.filled_circle(self.surface,
self.getX() + self.width - buttonR,
self.getY() + buttonR, buttonR, self.color)
gfxdraw.circle(self.surface,
self.getX() + self.width - buttonR - self.buttonWidth,
self.getY() + buttonR, buttonR, self.color)
def render(self, *args):
for particle in self.particle_array:
gfxdraw.filled_circle(self.surface, particle.x, particle.y,
particle.size, particle.color)
for particle_frame in particle.previous_frames:
gfxdraw.filled_circle(self.surface, particle_frame[0],
particle_frame[1], particle.size,
particle_frame[2])
def draw_circle(self, x, y, radius, color=(0, 0, 0)):
x, y, radius = math.ceil(x), math.ceil(y), math.ceil(radius)
try:
gfxdraw.aacircle(self.window, x, y, radius, color)
gfxdraw.filled_circle(self.window, x, y, radius, color)
except:
print(f"x={x}, y={y}, radius={radius}, color={color}")
sys.exit()
def draw(self):
"""
Рисует шарик по координатам
:return: параметр обновленного экрана
"""
gfxdraw.aacircle(self.screen, int(self.coords[0]), int(self.coords[1]), self.radius, self.color)
gfxdraw.filled_circle(self.screen, int(self.coords[0]), int(self.coords[1]), self.radius, self.color)
return self.screen
def draw(self,screen):
if not self.show:
self.image.fill(self.empty)
else:
#pygame.draw.circle(self.image,(255,0,0), (self.cellSize// 2, self.cellSize// 2),25,1)
gfxdraw.filled_circle(self.image, self.cellSize// 2, self.cellSize// 2, 10,self.color)
screen.blit(self.image,self.rect)
def _aa_render_region(self, image, rect, color, rad):
corners = rect.inflate(-2 * rad - 1, -2 * rad - 1)
for attribute in ("topleft", "topright", "bottomleft", "bottomright"):
x, y = getattr(corners, attribute)
gfxdraw.aacircle(image, x, y, rad, color)
gfxdraw.filled_circle(image, x, y, rad, color)
image.fill(color, rect.inflate(-2 * rad, 0))
image.fill(color, rect.inflate(0, -2 * rad))
def draw(self, surface): c_inner, c_outer = self.colouring() for arm in self.arms: pdraw.aaline(surface, c_outer, arm.p1, arm.p2, 1) gfx.filled_circle(surface, int(self.position[0]), int(self.position[1]), self.radius, c_inner) gfx.aacircle(surface, int(self.position[0]), int(self.position[1]), self.radius, c_outer)
def draw(self, screen):
self.g = max(self.g - 10, 40)
self.b = max(self.b - 10, 0)
gfxdraw.aacircle(screen, int(self.position.x), int(self.position.y),
self.size, (self.r, self.g, self.b))
gfxdraw.filled_circle(screen, int(self.position.x),
int(self.position.y), self.size,
(self.r, self.g, self.b))
def draw_cell(cell):
font_size = 16
virus_sizes = {100:1, 106:2, 113:3, 119:4, 125:5, 131:6, 136:7}
cx,cy = world_to_win_pt(cell.pos,c.player.center)
try:
mov_ang = cell.movement_angle
p2 = cell.pos + Vec( math.cos(mov_ang + mechanics.eject_delta*math.pi/180), math.sin(mov_ang + mechanics.eject_delta*math.pi/180) ) * (cell.size+700)
p3 = cell.pos + Vec( math.cos(mov_ang - mechanics.eject_delta*math.pi/180), math.sin(mov_ang - mechanics.eject_delta*math.pi/180) ) * (cell.size+700)
cx2,cy2 = world_to_win_pt(p2,c.player.center)
cx3,cy3 = world_to_win_pt(p3,c.player.center)
except (AttributeError, TypeError):
cx2,cy2=cx,cy
cx3,cy3=cx,cy
radius = world_to_win_length(cell.size)
if cell.is_virus:
color = (0,255,0)
color2 = (100,255,0)
polygon = generate_virus(int(cell.size*0.3), 10*zoom, radius, (cx, cy))
polygon2 = generate_virus(int(cell.size*0.3), 10*zoom, radius-10, (cx, cy))
gfxdraw.filled_polygon(screen, polygon, color2)
gfxdraw.polygon(screen, polygon, (0,0,0))
gfxdraw.aapolygon(screen, polygon, (0,0,0))
gfxdraw.filled_polygon(screen, polygon2, color)
gfxdraw.aapolygon(screen, polygon2, color)
draw_text((cx, cy), "%s / 7" % virus_sizes.get(cell.size, "?"), (64,0,0), font_size*2, False, True)
draw_text((cx, cy + radius + 10), str(cell.cid), (0,0,0), font_size, False, True)
else:
color=(int(cell.color[0]*255), int(cell.color[1]*255), int(cell.color[2]*255))
if not (cell.is_ejected_mass or cell.is_food):
gfxdraw.aapolygon(screen, [(cx,cy),(cx2,cy2),(cx3,cy3),(cx,cy)] ,(255,127,127))
gfxdraw.filled_circle(screen, cx, cy, radius, color)
gfxdraw.aacircle(screen, cx, cy, radius, (0,0,0))
gfxdraw.aacircle(screen, cx, cy, int(radius/2), (255,255,255))
gfxdraw.circle(screen, cx, cy, int(radius/2), (255,255,255))
draw_text((cx, cy + radius + 10), cell.name, (0, 0, 0), font_size, False, True)
draw_text((cx, cy + radius + 10 + font_size), str(cell.cid), (0,0,0), font_size, False, True)
# surface = draw_text(cell.name, (0, 0, 0), font_size)
# screen.blit(surface, (cx - (surface.get_width()/2), cy + radius + 5))
draw_text((cx, cy), str(int(cell.mass))+"/"+str(int(cell.size)), (255, 255, 255), font_size, False, True)
# surface = draw_text(str(int(cell.mass)), (255, 255, 255), font_size)
# screen.blit(surface, (cx - (surface.get_width()/2), cy - (surface.get_height()/2)))
else:
gfxdraw.aacircle(screen, cx, cy, radius, color)
gfxdraw.filled_circle(screen, cx, cy, radius, color)
def _aa_render_region(image, rect, color, rad):
"""Helper function for aa_round_rect."""
corners = rect.inflate(-2*rad-1, -2*rad-1)
for attribute in ("topleft", "topright", "bottomleft", "bottomright"):
x, y = getattr(corners, attribute)
gfxdraw.aacircle(image, x, y, rad, color)
gfxdraw.filled_circle(image, x, y, rad, color)
image.fill(color, rect.inflate(-2*rad,0))
image.fill(color, rect.inflate(0,-2*rad))
def draw(self):
if self.kind == "dot":
pixel_points = CoorsAndPixels.coor_to_pixel(self.pos, scale, size)
radius = int((self.charge)**(1.0/3.0)*scale)
gfxdraw.filled_circle(screen, pixel_points[0], pixel_points[1], radius, self.color)
if radius > 1:
gfxdraw.aacircle(screen, pixel_points[0], pixel_points[1], radius, self.color)
elif self.kind == "line":
#pygame.draw.aaline(screen, self.color, CoorsAndPixels.coor_to_pixel(self.pos, scale, size, True), CoorsAndPixels.coor_to_pixel([self.pos[0]+self.length*self.cos_a, self.pos[1]+self.length*self.sin_a], scale, size, True))
pygame.draw.line(screen, self.color, CoorsAndPixels.coor_to_pixel(self.pos, scale, size, True), CoorsAndPixels.coor_to_pixel([self.pos[0]+self.length*self.cos_a, self.pos[1]+self.length*self.sin_a], scale, size, True), int(self.charge**(1.0/3.0)/5.0)+1)
def draw_circle(pos, r, color, filled=False, global_coords=True):
if global_coords:
pos = world_to_win_pt(pos, c.player.center)
r = world_to_win_length(r)
if filled:
gfxdraw.filled_circle(screen, pos[0], pos[1], r, color)
else:
gfxdraw.circle(screen, pos[0], pos[1], r, color)
gfxdraw.aacircle(screen, pos[0], pos[1], r, color)
def circle(surface, pos, radius, color, width=0):
if width == 0:
# we need the aacircle even when the hole is filled
# because filled circles look like shit
aacircle(surface, pos[0], pos[1], radius, color)
filled_circle(surface, pos[0], pos[1], radius, color)
elif width == 1:
aacircle(surface, pos[0], pos[1], radius, color)
else:
for i in range(1, width):
aacircle(surface, pos[0], pos[1], radius-i, color)
return
def draw(self, screen):
"""
Argument:
screen : the surface to draw on
This function draws an antialiased circle at the X,Y of the piece.
Unfortuately, antialiased filled circles don't exsist so we draw
the antialiased outline before drawing the filled inside, as recommneded
by the offical docs (otherwise the circles look horrendously ugly).
"""
cur_color = self.COLORS[self.STATUS]
gfxdraw.aacircle(screen, self.X, self.Y, self.radius, cur_color)
gfxdraw.filled_circle(screen, self.X, self.Y, self.radius, cur_color)
def circ(s, r, p, c): filled_circle(i, p+r, p+r, r, c) filled_circle(i, p+2*s-r, p+r, r, c) filled_circle(i, p+r, p+2*s-r, r, c) filled_circle(i, p+2*s-r, p+2*s-r, r, c) box(i, (p+r, p+0, 2*s-2*r, 2*s+1), c) box(i, (p+0, p+r, 2*s+1, 2*s-2*r), c)
def blit_borders_on(self, surface):
if not self.light:
white = make_compatible(constants.WHITE, self.color)
self.light = mid_color(self.color, white)
if not self.dark:
black = make_compatible(constants.BLACK, self.color)
self.dark = mid_color(self.color, black)
## rect = Rect((0, 0), self.size)
x = y = r = self.size[0] // 2
r -= 2
filled_circle(surface, x, y, r, self.color)
## circle(surface, x, y, r, self.dark)
arc(surface, x, y, r, 135, 135 + 180, self.dark)
arc(surface, x, y, r, 135 + 180, 135 + 360, self.light)
def draw(self):
if self.kind == "dot":
pixel_points = coor_to_pixel(self.pos)
radius = int((self.charge)**(1.0/3.0)*scale)
gfxdraw.filled_circle(screen, pixel_points[0], pixel_points[1], radius, self.color)
if radius > 1:
gfxdraw.aacircle(screen, pixel_points[0], pixel_points[1], radius, self.color)
elif self.kind == "box":
pixel_pos = coor_to_pixel(self.pos, True)
end_pos = [self.pos[0]+self.length*self.cos_a, self.pos[1]+self.length*self.sin_a]
pixel_end_pos = coor_to_pixel(end_pos)
#pygame.draw.aaline(screen, self.color, (pixel_pos[0], pixel_pos[1]), coor_to_pixel([self.pos[0]+self.length*self.cos_a, self.pos[1]+self.length*self.sin_a], True))
pygame.draw.line(screen, self.color, (pixel_pos[0], pixel_pos[1]), coor_to_pixel([self.pos[0]+self.length*self.cos_a, self.pos[1]+self.length*self.sin_a]), int(self.charge**(1.0/3.0)/scale/2.0)+1)
#pygame.draw.line(screen, self.color, (int(pixel_pos[0]), int(pixel_pos[1])), ())
gfxdraw.aacircle(screen, int(pixel_pos[0]), int(pixel_pos[1]), 10, self.color)
def mkgui_tile(self, loc, only_clear=False):
""" Redraw the gui tile or just clear the tile.
only_clear: use to clear 'unmovable' tiles; if False, clear and then redraw tile
"""
loc = self.resolve_loc(loc)
ts = self.tilesize
if self.circle:
gfxdraw.filled_circle(self.sfc, loc[0], loc[1], iround(ts/2), white)
if not only_clear:
gfxdraw.aacircle(self.sfc, loc[0], loc[1], iround(ts/2-4), gray)
else:
r = center_square(loc, ts)
draw.rect(self.sfc, white, r, 0)
if not only_clear:
gfxdraw.rectangle(self.sfc, r, gray)
self.scr.blit(self.sfc, (0,0))
def dym(self,screen):
if self.Stan=="trafiony":
x0,y0=self.rect.topleft
x1,y1=self.rect.bottomright
xs=(x1+x0)/2
ys=(y1+y0)/2
r=10
dx=-5*self.move
dy=-5*self.move2
## gfx.filled_circle (screen ,xs+dx,ys+dy,r,pygame.Color("white"))
## gfx.filled_circle (screen ,xs+3*dx,ys+3*dy,2*r,pygame.Color("white"))
## gfx.filled_circle (screen ,xs+5*dx,ys+5*dy,3*r,pygame.Color("white"))
## gfx.filled_circle (screen ,xs+7*dx,ys+8*dy,4*r,pygame.Color("white"))
## gfx.filled_circle (screen ,xs+12*dx,ys+12*dy,5*r,pygame.Color("white"))
## gfx.filled_circle (screen ,xs+16*dx,ys+16*dy,6*r,pygame.Color("grey"))
## gfx.filled_circle (screen ,xs+20*dx,ys+20*dy,7*r,pygame.Color("black"))
for i in range (7):
gfx.filled_circle (screen ,xs+(1+2*i)*dx,ys+(1+2*i)*dy,(i+1)*r,pygame.Color(0xcc,0xcc,0xcc,255-20*i))
def move(self):
self.movetimer+=1
if self.movetimer>self.movetimemax:#random motion - after the move time is up another speed is added
self.changex+=choice(self.randomlist)
self.changey+=choice(self.randomlist)
self.movetimer=0
self.posx+=self.changex
self.posy+=self.changey
if self.posx>screenWidth-20:#to stay in the borders of the screen
self.changex=-3
elif self.posx<20:
self.changex=3
if self.posy>screenHeight-20:
self.changey=-3
elif self.posy<20:
self.changey=3
for x in range(0,15,3):#The whisps
gfxdraw.filled_circle(themap.screenmap[self.screen[0]][self.screen[1]],int(self.posx),int(self.posy),int(x),(255,238,0,50))
def __init__(self):
PG.sprite.Sprite.__init__(self)
if Speedometer.IMAGE is None:
Speedometer.IMAGE = \
PI.load("images/sprites/hud/speed_dial.png").convert()
Speedometer.IMAGE.set_colorkey((0, 0, 0))
Speedometer.NEEDLE = PI.load(
"images/sprites/hud/needle.png").convert_alpha()
self.image = Speedometer.IMAGE
self.rect = self.image.get_rect()
self.rect.topleft = (0, 0)
PD.filled_circle(Speedometer.IMAGE, self.image.get_width() / 2,
self.image.get_height() / 2, 8, Speedometer.RED)
self.speed = 0
self.needle = Speedometer.NEEDLE
self.needle.get_rect(center=self.rect.center)
Speedometer.NEEDLE.get_rect().center = self.rect.center
def demod_menu_response(): global mn,opt,retf global dostronger, autosint_enable, intrascan_enable global top_sf global top_sf global rec if opt.value == 1: # llamar menu node retf = demod_mode_response demod_mode() return if opt.value == 2: # AutoSINT autosint_enable = not autosint_enable dostronger = autosint_enable if opt.value == 3: # grabar rec = not rec # pinta el punto en fft_frame if not rec: pgd.filled_circle(top_sf, smx+sml+TOPALTO/2, TOPALTO/2, TOPALTO/4, BGCOLOR) #Borra botón rojo izquierda smeter mn = None
def update(self): CommandableSprite.update(self) mx = int(self.get_x()) my = int(self.get_y()) l = int(self.get_left()) t = int(self.get_top()) if self.circled: if self.border_width == 0: # no border --- just draw the background pygame.draw.circle(self.screen, self.circle_color, (mx, my), min(self.width/2,self.height/2) ) else: filled_circle(self.screen, mx, my, min(self.width/2,self.height/2), (0,0,0) ) # draw a black outer rim aacircle(self.screen, mx, my, min(self.width/2,self.height/2), (0,0,0) ) # draw a black outer rim filled_circle(self.screen, mx, my, min(self.width/2-self.border_width,self.height/2-self.border_width), self.circle_color) aacircle(self.screen, mx, my, min(self.width/2-self.border_width,self.height/2-self.border_width), self.circle_color) # and the inside the color we want # And draw each dot position for i in xrange(self.N): dx,dy = self.dot_positions[i] r = self.radii[i] # here we draw twice to antialias the edges filled_circle(self.screen, int(dx+l), int(dy+t), int(r), self.dot_color) aacircle(self.screen, int(dx+l), int(dy+t), int(r), self.dot_color)
def draw(self, transparent_colour, zoom):
"""
Main draw function for nodes. It will return a surface containing the drawing of the node.
:return:
"""
print zoom
size = int(self.size / zoom)
# Create the surface for this node
surface = pygame.surface.Surface((self.size, self.size))
surface.fill(transparent_colour)
third_size = size / 3
x = surface.get_rect().centerx
y = surface.get_rect().centery
draw.aacircle(surface, x, y, third_size, (0, 255, 128))
draw.filled_circle(surface, x, y, third_size, (0, 255, 128))
return surface
def draw(screen, now):
w, h = screen.get_size()
sunrise, noon, sunset = [((t - time.timezone) / 3600) % 12 for t in horology.sun_events(now, lon, lat)]
local_now = now - time.timezone
minutes = (local_now / 60) % 60
hours = (local_now / 3600) % 12
draw_dial(screen)
xo = w // 2
yo = h // 2
ro = 0.04 * min(w, h)
a = hours / 12
r = 0.22 * min(w, h)
x, y = artoxy(a, r, xo, yo)
points = (x, y), artoxy(a - 0.25, ro, xo, yo), artoxy(a + 0.25, ro, xo, yo)
gfxdraw.filled_polygon(screen, points, fg)
a = minutes / 60
r *= 1.61803
x, y = artoxy(a, r, xo, yo)
points = (x, y), artoxy(a - 0.25, ro, xo, yo), artoxy(a + 0.25, ro, xo, yo)
gfxdraw.filled_polygon(screen, points, fg)
gfxdraw.filled_circle(screen, xo, yo, int(ro), fg)
r = 0.25 * min(w, h)
a = sunrise / 12
x, y = artoxy(a, r, xo, yo)
gfxdraw.filled_circle(screen, x, y, int(0.25 * ro), fg)
a = sunset / 12
x, y = artoxy(a, r, xo, yo)
gfxdraw.filled_circle(screen, x, y, int(0.25 * ro), fg)
#for x in stars:
# pixel_pos = CoorsAndPixels.coor_to_pixel(x, scale, size)
# screen.blit(star_image, [int(pixel_pos[0]-radius*2.5), int(pixel_pos[1]-radius*2.5)])
#draw player ball
pixel_points = CoorsAndPixels.coor_to_pixel(my_dot_pos, scale, size, True)
screen.blit(my_dot_image, [pixel_points[0]-radius, pixel_points[1]-radius])
#gfxdraw.filled_circle(screen, pixel_points[0], pixel_points[1], radius, my_dot_color)
#if radius > 1:
# gfxdraw.aacircle(screen, pixel_points[0], pixel_points[1], radius, my_dot_color)
#draw line if aiming to shoot
if clicked_my_dot:
pygame.draw.aaline(screen, (0, 0, 0), pixel_points, mouse_pos)
#pixel_square_coors = coor_to_pixel([square[0], square[1]])
#pixel_square_to = [square[2]/scale, size, square[3]/scale]
#screen.fill((0, 255, 0), [pixel_square_coors[0], pixel_square_coors[1], pixel_square_to[0], pixel_square_to[1]])
#draw objective
pixel_points = CoorsAndPixels.coor_to_pixel(objective, scale, size)
gfxdraw.filled_circle(screen, pixel_points[0], pixel_points[1], int((objective_size)**(1.0/3.0)*scale), (0, 255, 0))
gfxdraw.aacircle(screen, pixel_points[0], pixel_points[1], int((objective_size)**(1.0/3.0)*scale), (0, 255, 0))
display_info()
pygame.display.update()
elapsed = clock.tick(60) #60 hz refresh rate
#save level locks
with open("level_locks.txt", 'w') as lock_files:
lock_files.writelines(locks)
def draw_body(screen, body):
gfxdraw.filled_circle(screen, int(body.x), int(body.y), body.r, body.color)
def circle(surf,c,coord,r,w):
x,y = coord
x,y,r = int(x),int(y),int(r)
filled_circle(surf,x,y,r,(20,20,60))
aacircle(surf,x,y,r,c)
aacircle(surf,x,y,r-1,c)
def draw(surf):
surf.fill((80,80,80))
x,y = pygame.mouse.get_pos()
gfxdraw.filled_circle(surf, x, y, 8, (0,0,0))
gfxdraw.filled_circle(surf, x, y, 5, (0,0,255))
def draw_powerup(powerup):
gfxdraw.aacircle(DISPLAYSURF,int(powerup.pos_x), int(powerup.pos_y),int(powerup.size),PINK)
gfxdraw.filled_circle(DISPLAYSURF,int(powerup.pos_x), int(powerup.pos_y),int(powerup.size),PINK)
font = pygame.font.SysFont("comicsansms", 12)
text = font.render(powerup.feature, True, WHITE)
DISPLAYSURF.blit(text,(powerup.pos_x - 20, powerup.pos_y - 10))
def draw_circ(circle, color, screen):
'''A nice wrapper for pygame's ugly-ass draw syntax. '''
gfxdraw.filled_circle(screen, int(circle.coord[0]), int(circle.coord[1]),
circle.radius, color)
def draw(self):
gfxdraw.filled_circle(window, self.globalX ,self.globalY ,jewelSize-1,self.color)
if(self.removeMark==1): gfxdraw.filled_circle(window, self.globalX ,self.globalY ,jewelSize-5,(255,255,255))
def drawplant(head_node):
devprint("drawing plant")
surface = Surface((40, 43), SRCALPHA)
rootpos = (surface.get_width()/2, surface.get_height()-3)
# the stack has the node, the currentx, and the currenty for each node in it
# currentx and currenty are without resizing of the surface
stack = []
# keeps track of offset needed because of resizing the surface
resizeoffset = (0, 0)
for i in range(head_node.repeatnumseparate):
stack.append(head_node)
firstx = potwidth * random.random() * head_node.brancharea + rootpos[0]
stack.append(firstx)
stack.append(rootpos[1])
stack.append(math.pi/2) # base angle strait up to start with
callcount = 0
while len(stack) != 0 and callcount < 1000:
callcount += 1
base_angle = stack.pop()
currenty = stack.pop()
currentx = stack.pop()
node = stack.pop()
randomspacings = [0]
spacingLength = 0
for i in range(node.repeatnumcircle-1):
randomspacings.append(random.uniform(node.anglespace-node.anglevariance*node.anglespace, node.anglespace+node.anglevariance*node.anglespace))
spacingLength += randomspacings[i+1]
startspacing = random.uniform(-node.anglevariance*node.anglespace, node.anglevariance*node.anglespace)/2 * random.choice((-1, 1))
# start angle so that it points up on average
angle = base_angle + startspacing - (spacingLength/2) + node.angleoffset*random.choice((-1, 1))
# update the random spacing to be final angles
for i in range(len(randomspacings)):
angle = angle + randomspacings[i]
randomspacings[i] = angle
for i in range(node.repeatnumcircle):
# draw all the plantshapes at this angle
# pick a random angle out of the list
angle = randomspacings.pop(random.randint(0, len(randomspacings)-1))
widthscalar = 1 + random.random()*node.widthvariance
heightscalar = 1 + random.random()*node.heightvariance
# now add the current node
surface, mainltranslated, mainloffset, new_resize_offset = surface_with_node(surface, node, angle, (currentx, currenty), resizeoffset, widthscalar, heightscalar)
resizeoffset = new_resize_offset
# find the new currentx and currenty
mainlistlen = len(mainltranslated)
# add all the children at the current position
for childnode in node.children:
futureindexpositions = getfuturenodeindexpositions(childnode.repeatnumseparate, mainlistlen, childnode.brancharea)
for i in range(childnode.repeatnumseparate):
futurex = mainltranslated[futureindexpositions[i]][0]+mainloffset[0]
futurey = mainltranslated[futureindexpositions[i]][1]+mainloffset[1]
stack.append(childnode)
stack.append(futurex)
stack.append(futurey)
futureangle = listangleatindex(mainltranslated, futureindexpositions[i])
stack.append(futureangle)
finalsurfaceanchor = (rootpos[0] + resizeoffset[0], rootpos[1]+resizeoffset[1])
# draw dirt clumps at bottom
clumpradius = 4
clumprange = 14
clumpnum = 4
for i in range(clumpnum):
gfxdraw.filled_circle(surface, int(finalsurfaceanchor[0] + i * clumprange/clumpnum - clumprange/2)+1,
int(finalsurfaceanchor[1]),
int(random.uniform(clumpradius/3, clumpradius)),
brighten(dirtcolor, -10))
return surface, finalsurfaceanchor
def pantalla_refresh(sf):
global pts,mpts
global xbw,xdev
global fq,fqc,bw
global modelabel,bwlabel,fqlabel1,fqlabel2
global ftqc, numx
global maxfill_enable, maxpts_enable, refreshfq
global azoom, base
global fft_sf,top_sf
global sq,xsq,asq,smval,smvaladj,possq,sqstate
global frame, count
global menusf, stereosf
a = FFTANCHO/2 # media pantalla
pleft = fqlabel1.get_size()[0]/2 + fqlabel2.get_size()[0]/2
fft_sf.fill(BGCOLOR) # Borra BW Más rapido que reescribir.
# PINTA ESCALA
for x in range(12): # Escala FFT
y = int(FFTALTO - (x*(FFTALTO/12))*azoom) + base
if y > 0 :
pgd.hline(fft_sf,0,FFTANCHO,y,ESCCOLOR)
lb = ftdev1.render(str((12-x)*-10), 0, ESCCOLOR,BGCOLOR) # pinta db text
fft_sf.blit(lb, (0,y-10)) # Pinta db label
# Pinta BW
if nobaile: txdev = FFTANCHO/2;
else: txdev = xdev
txbw = 2*xbw
tcodo = txdev - txbw/2
if not nobaile or (nobaile and (frame % 10) > 4 ): # parapedea dev si introscan
if tmode != "FM W" and tmode != "FM ST": # WFM no tiene ancho de banda
if tmode == "USB":
txbw /= 2
tcodo = txdev
elif tmode == "LSB":
txbw /= 2
tcodo = txdev - txbw
fft_sf.fill(BWCOLOR2,(tcodo,BWY,txbw,FFTALTO-BWY),0) # Pinta BW
pgd.rectangle(fft_sf,(tcodo,BWY,txbw,FFTALTO-BWY),BWCOLOR)
pgd.vline(fft_sf,int(txdev),0,FFTALTO,DEVCOLOR) # Pinta linea dev
# PINTA MAX
if maxpts_enable: # Pintta puntos de max
mpts += [(FFTANCHO,FFTALTO),(0,FFTALTO)]
pgd.polygon(fft_sf,mpts,MAXCOLOR)
# PINTA FILL
if fftfill_enable: # Pintta FFT relleno (Más rápido que el fill)
for x in pts: pgd.vline(fft_sf,x[0],x[1],FFTALTO,FILLCOLOR)
# PINTA FFT
pgd.polygon(fft_sf,pts,FGCOLOR) # pinta FFT
# PINTA DETECT
if detect_enable : # Pinta detector picos
for x in dtc : pgd.circle(fft_sf,x[0],x[1],10,DETECTCOLOR)
# PINTA DEV text
if not nobaile or (nobaile and (frame % 10) > 4):
if tmode != "FM W" and tmode != "FM ST":
fft_sf.blit(bwlabel, (txdev-bwlabel.get_size()[0]/2,BWY+2)) # Pinta bw label
fft_sf.blit(fqlabel1, (txdev-pleft,BWY-22)) # Pinta dev label
fft_sf.blit(fqlabel2, (txdev-pleft+fqlabel1.get_size()[0]+4,BWY-20))
fft_sf.blit(modelabel,(txdev-modelabel.get_size()[0]/2,BWY-40)) # Pinta mode label
# pinta Sqelch
tc = SQCOLOR
if not sqstate: tc = (0,200,0) # Si está levantado pinta verde
pgd.hline(fft_sf,0,FFTANCHO,xsq+base, tc)
fsq = ftdev2.render(' SQ '+str(sq)+ ' ', 0, DEVCOLORHZ,(100,25,25))
fft_sf.blit(fsq, (FFTANCHO-fsq.get_size()[0],xsq-10+base)) # Pinta bw label
possq = (FFTANCHO-fsq.get_size()[0]+25,xsq-12+base+12) # Guardo posicion para el botón
#pgd.circle(fft_sf,possq[0],possq[1],50,(200,200,200))
#asq = tsq
# pinta smeter
pgd.box(top_sf,(smx+13,25,sml-28,9),(0,0,0))
pgd.box(top_sf,(smx+13,27,smval*smvaladj,6),(255,50,50))
# PINTA CIFRAS DE FREQ SI HAN CAMBIADO
if refreshfq:
sp = 4
size = 24
numx = [] # Repinta el indicador de frecuencia
txt = format(fqc,'010d')
txt = txt[:-9]+'.'+txt[-9:-6]+'.'+txt[-6:-3]+','+txt[-3:]
lon = len(txt)
anc = 0
for x in range(lon):
if txt[x] in ['.',','] :
col = BGCOLOR
anc = size / 2
else :
col = BGFQCCOLOR
anc = size
px = (TOPANCHO/2) - (lon+sp)*size/2 + (x*(size+sp)) # Calcula posición
fqclabel = ftqc.render(txt[x], 1, FQCCOLOR, col) # pinta fqc text
top_sf.blit(fqclabel,(px,0)) # blit
if txt[x] not in ['.',','] : numx += [px] # Almacena la coordenada del numero
# PARPADEA BOTON ROJO IF REC
if rec:
if frame == FPS/2:
pgd.filled_circle(top_sf, smx+sml+TOPALTO/2, TOPALTO/2, TOPALTO/4, BGCOLOR) #Borra botón rojo izquierda smeter
if frame == 1:
pgd.filled_circle(top_sf, smx+sml+TOPALTO/2, TOPALTO/2, TOPALTO/4, tc) #Pinta botón del color del smeter
# Pinta STEREO si STEREO
if REAL and tmode == "FM ST":
if (sdr.probe_st.level() > 0.5 ):
top_sf.blit(stereosf,(250,8))
else:
pgd.box(top_sf,(250,0,40,TOPALTO),BGCOLOR)
# Pinta BIRDIES
for i in birds:
fft_sf.blit(fbd, (i+((birdsize-16)/2),FFTALTO-16))
# PINTA MENU IF ANY
if mn : mn.refresca()
# Flipea/Vuelca la pantalla
pg.display.flip()
refreshfq = False
frame = (frame % FPS) +1
count += 1
def render(self):
# ~ draw magnetradius
if self.magnetradius:
# ~ gfxdraw.aacircle(scr,self.centerx,self.centery,int(self.magnetradius),(150,130,110,int(self.magnetradius)))
m = image.load("img/magnetichalo.png")
m = transform.smoothscale(m, [int(self.magnetradius * 2)] * 2)
scr.blit(m, m.get_rect(center=self.center))
# ~ draw shieldbar
r = draw.rect(scr, (50, 50, 50), (10, 500, 380, 18), 1)
osdlayer.fill((100, 100, 200, self.shieldfxttl * 4 + 150), (10, 0, self.shield_ / self.shieldmax * 380, 18))
# scr.blit(self.SHIELDTEXT,self.SHIELDRECT)
# ~ draw lazerstate
r = draw.rect(scr, (50, 50, 50), (10, 520, 380, 18), 1)
osdlayer.blit(self.lazertempfx, (10, 20), (0, 0, DoubleLazer.temper / DoubleLazer.tempmax * 380, 18))
# scr.blit(self.LAZERTEXT,self.LAZERRECT)
# ~ draw bonusbar
self.settingbonus_.render()
self.loader1_.render()
# ~ draw shieldcircle
if self.shieldfxttl:
self.shieldcolor.a = int(4 * self.shieldfxttl)
gfxdraw.filled_circle(scr, self.centerx, self.centery, self.w, self.shieldcolor)
self.shieldfxttl -= 1
if self.foo:
self.foo -= 1
scr.blit(self.img2, ship)
return
# ~ draw ship
scr.blit(self.img, ship)
