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 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 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 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 _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 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):
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 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 circle(self, center, radius, color=Color.DEFAULT, width=1, filled=False,
alpha=-1, aalias=True):
"""
Draw a circle given a location and a radius.
:param center:
:param radius:
:param color:
:param width:
:param filled:
:param alpha:
:param aalias:
:return:
"""
if filled:
width = 0
if aalias == False or width > 1 or filled:
sdl.draw.circle(self._surface,
self._csv_rgb2sdl_color(color, alpha),
center, int(radius), int(width))
else:
gfxdraw.aacircle(self._surface, int(center[0]), int(center[1]),
int(radius), self._csv_rgb2sdl_color(color, alpha))
cen = tuple(int(x) for x in center)
self._svg.add(self._svg.circle(center=cen, r=radius))
return None
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 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 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 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, 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_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 draw(self,screen):
if not self.selected:
self.reDrawImage()
else:
#pygame.draw.circle(self.image,(255,0,0), (self.cellSize// 2, self.cellSize// 2),25,1)
gfxdraw.aacircle(self.image, self.cellSize// 2, self.cellSize// 2, 20,self.color)
screen.blit(self.image,self.rect)
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 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 display(self, screen):
if self.typen == 'c':
gfx.aaellipse(screen, self.x, self.y, self.size, self.sizeb, self.colour)
gfx.aacircle(screen, self.x, self.y, 2, (0,0,0))
elif self.typen == 'r':
gfx.rectangle(screen, pg.Rect(self.x-self.size/2, self.y-self.sizeb/2, self.size, self.sizeb), self.colour)
gfx.aacircle(screen, self.x, self.y, 2, (0,0,0))
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 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 _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, 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(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_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_circle(self, surface):
gfxdraw.aacircle(surface, self.pos[0], self.pos[1], self.radius,
color_W)
gfxdraw.filled_circle(surface, self.pos[0], self.pos[1], self.radius,
color_W)
gfxdraw.aacircle(surface, self.pos[0], self.pos[1], self.radius - 2,
self.color)
gfxdraw.filled_circle(surface, self.pos[0], self.pos[1],
self.radius - 2, self.color)
def draw_ring(self, surface, thickness):
gfxdraw.aacircle(surface, self.pos[0], self.pos[1],
self.radius + thickness // 2, self.color)
gfxdraw.filled_circle(surface, self.pos[0], self.pos[1],
self.radius + thickness // 2, self.color)
gfxdraw.aacircle(surface, self.pos[0], self.pos[1],
self.radius - thickness // 2, BG_COLOR)
gfxdraw.filled_circle(surface, self.pos[0], self.pos[1],
self.radius - thickness // 2, BG_COLOR)
def single_circle(surface, progress, mood):
width, height = surface.get_size()
r = int(progress*(sqrt((width/2)**2+(height/2)**2)+width//20))
w = width//40
aacircle(surface, width//2, height//2, r, mood.primary_color)
filled_circle(surface, width//2, height//2, r, mood.primary_color)
if r-w > 0:
aacircle(surface, width//2, height//2, r-w, (0, 0, 0))
filled_circle(surface, width//2, height//2, r-w, (0, 0, 0))
def draw():
for bird in birds:
#gfxdraw.filled_circle(screen, bird.x_pos, bird.y_pos, bird.radius, bird_color)
gfxdraw.aacircle(screen, bird.x_pos, round(bird.y_pos), bird.radius, bird_color)
#pygame.draw.circle(screen, bird_color, (bird.x_pos, bird.y_pos), bird.radius)
for obs in obstacles:
pygame.draw.rect(screen, obstacle_color, (obs.x_pos, 0, obs.width, obs.gap_y))
pygame.draw.rect(screen, obstacle_color, (obs.x_pos, obs.gap_y + obs.gap_size, obs.width, screen_size[1] - obs.gap_y - obs.gap_size))
def draw_circle(screen, pos, size, color, color_border=None, size_border=1):
if color_border:
if size_border > 1:
filled_circle(screen, pos[0], pos[1], size + size_border,
color_border)
aacircle(screen, pos[0], pos[1], size + size_border, color_border)
# inner color circle
filled_circle(screen, pos[0], pos[1], size, color)
aacircle(screen, pos[0], pos[1], size, 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():
global screen, curve
screen.fill((0, 0, 0))
for point in points:
gfxdraw.aacircle(screen, point[0], point[1], 4, (255, 255, 255))
gfxdraw.filled_circle(screen, point[0], point[1], 4, (255, 255, 255))
if len(curve) > 1:
pygame.draw.aalines(screen, (255, 255, 255), False, curve, True)
def render_piece(self, output, circle_pos):
"""Renders the piece on the board"""
# note: rendering is XY system
y, x = circle_pos[self.position]
# Experimental features PyGame may break it in the future
gfxdraw.filled_circle(output, x, y, 32, self.color)
gfxdraw.aacircle(output, x, y, 32, color.BLACK)
gfxdraw.aacircle(output, x, y, 31, color.BLACK)
def __init__(self):
pg.sprite.Sprite.__init__(self)
self.rect = pg.Rect((0, 0), GRID_SIZE)
self.image = pg.Surface(GRID_SIZE, pg.SRCALPHA)
self.radius = RADIUS
gdraw.aacircle(self.image, self.rect.center[0], self.rect.center[1],
int(self.radius), WHITE)
gdraw.filled_circle(self.image, self.rect.center[0],
self.rect.center[1], int(self.radius), WHITE)
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 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(self):
#Draws a circle,
w = []
if self.lit: # has it been clicked?
thickness = 0
else:
self.color = [255,255,255]
thickness = 1
gfxdraw.aacircle(self.screen, self.pos_x, self.pos_y, self.radius - 5, (255,255,255))
# Draws a square
pygame.draw.rect(self.screen,self.color,(self.pos_x-25, self.pos_y-25, 50,50),thickness)
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 redraw_screen():
global gunX
global gunY
pygame.draw.rect(window, (0, 0, 0), (0, 0, windowX, windowY))
if(mouseX==playerX and mouseY==playerY):
gunX=mouseX
gunY=mouseY
else:
gunX=playerX+playerSize*(mouseX-playerX)/math.sqrt((mouseX-playerX)**2+(mouseY-playerY)**2)
gunY=playerY+playerSize*(mouseY-playerY)/math.sqrt((mouseX-playerX)**2+(mouseY-playerY)**2)
gfxdraw.aacircle(window, int(playerX),int(playerY),playerSize,(255,255,255))
#gfxdraw.line(window,int(playerX),int(playerY),int(gunX),int(gunY),(255,255,255))
pygame.draw.aaline(window, (255,255,255),(int(playerX),int(playerY)),(int(gunX),int(gunY)))
playerBulletList.draw()
pygame.display.flip()
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 draw(self, screen):
h = screen.get_height()
s = self.scale_sim_to_vis
if self.shape == 'quad':
verts = self.fixture.shape.vertices
verts = [self.body.transform * vert for vert in verts]
verts = [(s * x, h - s * y) for (x, y) in verts]
gfxdraw.aapolygon(screen, verts, self.object_color)
elif self.shape == 'circle':
x = self.body.position[0]
y = self.body.position[1]
gfxdraw.aacircle(screen, int(s * x), int(h - s * y), int(s *
self.HALF_H * self.scale_real_to_sim), self.object_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 draw(self, screen):
h = screen.get_height()
s = self.scale_sim_to_vis
center = self.body.position
top = self.body.GetWorldPoint((0.0, self.sim_radius))
if center.x < 0 or center.y < 0:
print(center)
return
cx = int(round(s * center.x))
cy = int(round(h - s * center.y))
top_x = int(round(s * top.x))
top_y = int(round(h - s * top.y))
gfxdraw.aacircle(screen, cx, cy, self.pixel_radius, self.circle_color)
draw.aaline(screen, self.line_color, (cx, cy), (top_x, top_y))
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_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 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
while True:
screen.fill(pygame.Color(200, 200, 200))
# screen.fill((0, 0, 0))
# Filling with black makes the following work...
# It therefore seems that somehow aacircle is getting it's blue
# value from max(background_blue_channel, specified_blue_channel)
# The left circle is still blue when drawn on black. This is only
# for aa circle though, aalines seems to just override specified
# channel value with background blue channel value...
gfxdraw.aacircle(
screen,
50,
150,
30,
(0, 0, 255)
)
gfxdraw.aacircle(
screen,
130,
150,
30,
(255, 0, 0)
)
pygame.draw.aalines(
screen,
(0, 0, 255, 0),
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)
time_step = time_step + 0.01
elif event.key == K_MINUS:
time_step = time_step - 0.01
env['light_pos'] = light_pos
# draw labyrinth and object
screen.fill((0, 0, 0, 0))
labyrinth.draw(screen)
push_object.draw(screen)
# draw light
light_pos = env['light_pos']
lx = int(SCALE_REAL_TO_VIS * light_pos[0, 0])
ly = int(screen.get_height() - SCALE_REAL_TO_VIS * light_pos[0, 1])
gfxdraw.aacircle(screen, lx, ly, 5, (255, 255, 0, 255))
# handle kilobot movement and drawing
for kb in kilobots:
kb.step()
kb.setVelocities()
kb.draw(screen)
if not paused:
# step physics objects using 10 pos and vel update iterations
world.Step(time_step, 10, 10)
curr_time = curr_time + time_step
pygame.display.set_caption('kbsim - {:.2f}s - ts: {:.0f}ms'.
format(curr_time, time_step * 1000))
def draw(self):
gfxdraw.aacircle(window, int(self.X),int(self.Y),int(self.size),self.color)
def main():
"""
The main game function. Welcome to the beginning of the end.
:return:
"""
# First we must initialize the pygame module and game clock before most things happen
pygame.init()
game_clock = pygame.time.Clock()
# Grab the settings from the settings file. They are placed in a dictionary.
settings = settings_parse.parse_settings('settings.cfg')
window_name = 'Pong'
window_resolution = settings['x_resolution'], settings['y_resolution']
# Check to see if the game should run in full screen
flags = 0
if settings['full_screen']:
flags = pygame.FULLSCREEN
# Build the main game window according to the settings provided
pygame.display.set_caption(window_name)
window = pygame.display.set_mode(window_resolution, flags, 32)
window_rect = window.get_rect()
# Get the joysticks/gamepads connected
joysticks = [pygame.joystick.Joystick(x) for x in range(pygame.joystick.get_count())]
for joystick in joysticks:
joystick.init()
# Create the game and score area
# The score area is along the top with a height 1/10th of the window
score_height = window_rect.height / 10
game_height = window_rect.height - score_height
score_surface = pygame.Surface((window_rect.width, score_height))
game_surface = pygame.Surface((window_rect.width, game_height))
game_resolution = (settings['x_resolution'], game_height)
# Font used for FPS counter
fps_font = pygame.font.SysFont(None, 48)
# Font used for score
score_font = pygame.font.SysFont(None, score_height - 4)
# The number of players in the game
number_players = 2
# Determine the players of the game
if settings['player_one'] == 'human':
pass
else:
pass
if settings['player_two'] == 'human':
pass
else:
pass
# Create the starting game objects
balls = [Ball(10, 200, window.get_rect().center)]
players = [Player(0, (0, window.get_rect().centery - 50)),
skynet.AiPlayer(0, (window.get_rect().right - 10, window.get_rect().centery - 50))]
winner = players[1]
# Initialize the variable game loop time step
last_time = time.time()
while True:
# The heart of the variable game loop. Keeps track of how long a frame takes to complete
current_time = time.time()
time_elapsed = current_time - last_time
last_time = current_time
# Game clock used for fps calculation
game_clock.tick()
# Handle the pygame events
# TODO: Move this to a more sensible place
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
pygame.quit()
elif event.key == pygame.K_UP:
[player.paddle.move_up() for player in players]
elif event.key == pygame.K_DOWN:
[player.paddle.move_down() for player in players]
elif event.key == pygame.K_SPACE:
balls.append(Ball(10, 200, window.get_rect().center))
if event.type == pygame.KEYUP:
[player.paddle.stop() for player in players]
if (event.type == pygame.JOYAXISMOTION) and (event.axis == 1):
players[event.joy].paddle.direction = -event.value
if (event.type == pygame.JOYBUTTONUP) and (event.button == 0):
player_paddle = players[event.joy].paddle
ball = Ball(10, 200, player_paddle.position)
ball.direction = Direction(True, event.joy)
ball.position = [player_paddle.get_front(), player_paddle.get_center()]
if not event.joy:
ball.position[0] = player_paddle.get_front() + player_paddle.size[0]
balls.append(ball)
# Update game objects
for player in players:
player.paddle.update(time_elapsed, game_resolution)
for ball in balls:
if player.paddle.collision(ball):
ball.paddle_bounce()
if not (ball.update(time_elapsed, game_resolution, players)):
balls.remove(ball)
if not balls:
balls.append(Ball(10, 200, game_surface.get_rect().center))
# Run AI
for player in players:
try:
player.target_ball(balls)
player.update()
except AttributeError:
pass
# Render all game objects
window.fill((0, 0, 0))
# Draw the playing field
board_colour = (232, 221, 203)
line_colour = (205, 179, 128)
width = game_surface.get_rect().width
height = game_surface.get_rect().height
center_x = game_surface.get_rect().centerx
center_y = game_surface.get_rect().centery
game_surface.fill(board_colour)
pygame.draw.line(game_surface, line_colour, (0, 0), (width, 0), 4)
pygame.draw.line(game_surface, line_colour, (width - 2, 0), (width - 2, height), 4)
pygame.draw.line(game_surface, line_colour, (0, 0), (0, height), 4)
pygame.draw.line(game_surface, line_colour, (0, height - 2), (width, height - 2), 4)
pygame.draw.line(game_surface, line_colour, (center_x, 0), (center_x, height), 2)
gfxdraw.aacircle(game_surface, center_x, center_y, 100, line_colour)
gfxdraw.aacircle(game_surface, center_x, center_y, 101, line_colour)
for ball in balls:
game_surface.blit(ball.surface, ball.position)
for player in players:
game_surface.blit(player.paddle.surface, player.paddle.position)
window.blit(game_surface, (0, score_height))
# Draw The score
score_string = str(players[0].score) + ' ' + str(players[1].score)
score = score_font.render(score_string, True, board_colour, (0, 0, 0))
score_surf_rect = score_surface.get_rect()
score_rect = score.get_rect()
score_surface.blit(score, (score_surf_rect.centerx - score_rect.centerx,
score_surf_rect.centery - score_rect.centery))
pygame.draw.line(score_surface, line_colour, (score_surf_rect.centerx, 0),
(score_surf_rect.centerx, score_surf_rect.height), 2)
window.blit(score_surface, (0, 0))
if settings['show_fps']:
fps = fps_font.render(str(int(game_clock.get_fps())), True, (255, 255, 255), (0, 0, 0))
window.blit(fps, (0, 0))
# Update the display
pygame.display.update()
def draw(self):
gfxdraw.aacircle(window, int(self.X), int(self.Y), 10, self.color)
for i in self.list:
i.movement()
i.draw()
def _draw_circle(self, x, y, r, c):
if drawing == "gfxdraw":
gfxdraw.aacircle(self.screen, x, y, r, c)
elif drawing == "draw":
pygame.draw.circle(self.screen, c, (x,y), r, 1)
def draw(self):
gfxdraw.aacircle(window, int(self.globalX),int(self.globalY),3,self.color)
gfxdraw.aacircle(window, int(self.globalX),int(self.globalY),2, (255,255,255))
if e.key == K_q and ctrl_held:
sys.exit()
elif e.key == K_SPACE:
lockscreen = False
# Check if lock icon should drag
if mb[0] == 1 and lock_icon_rect.collidepoint(mpos):
drag_lock_icon = True
elif mb[1] == 0:
drag_lock_icon = False
# Drag lock icon
if drag_lock_icon:
gfxdraw.aacircle(main, 250, 540, 140, (255,255,255))
lock_icon_pos_x = mx - 40
lock_icon_pos_y = my - 40
lock_icon_dist = hypot(mx - 250, my - 540)
if abs(lock_icon_dist) >= 150:
time.wait(150)
lockscreen = False
else:
# Set normal lock icon
lock_icon_pos_x = 210
lock_icon_pos_y = 500
# Lockscreen time text
def _generateSamples(self):
# create kilobots
self.kilobots = []
for i in range(self.numKilobots):
kilobot = Kilobot(self.world, self.SCALE_REAL_TO_SIM,
self.SCALE_REAL_TO_VIS, [0, 0])
kilobot.fixture.friction = 20
self.kilobots += [kilobot]
self.pushObject = Object(self.world, self.SCALE_REAL_TO_SIM,
self.SCALE_REAL_TO_VIS, [0, 0], self.objectShape)
numSamples = self.numEpisodes * self.numStepsPerEpisode
# fixed object start position
objStartX = 1.0
objStartY = 0.5
objStart = array([objStartX, objStartY])
# kilobots start in a circel around the object
r = 1.5 * self.pushObject.HALF_W
A = linspace(0, 2 * math.pi, self.numEpisodes + 1)[0:self.numEpisodes]
startPositions = c_[objStartX + np.cos(A) * r,
objStartY + np.sin(A) * r];
r = self.kilobots[0].RADIUS
kilobotOffsets = array([[-r, -r], [r, -r], [-r, r], [r, r]])
# s: light.x light.y kb.x1 kb.y1 ... kb.xn kb.yn
# everything is relative to the object position
# a: light movement (dx, dy)
S = asmatrix(empty((numSamples, 2 + 2 * self.numKilobots)))
A = asmatrix(empty((numSamples, 2)))
R = asmatrix(empty((numSamples, 1)))
S_ = asmatrix(empty((numSamples, 2 + 2 * self.numKilobots)))
for ep in range(startPositions.shape[0]):
self.pushObject.body.position = vec2(objStartX, objStartY) *\
self.SCALE_REAL_TO_SIM
self.pushObject.body.angle = 0
# light starts in circel around the object
start = startPositions[ep, :]
lightPos = matrix(start)
# kilobots start at the light position in a fixed formation
for (i, kilobot) in zip(range(self.numKilobots), self.kilobots):
x = start[0] + (1 + i / 4) * kilobotOffsets[i % 4, 0]
y = start[1] + (1 + i / 4) * kilobotOffsets[i % 4, 1]
kilobot.body.position = vec2(x, y) * self.SCALE_REAL_TO_SIM
for step in range(self.numStepsPerEpisode):
""" user interaction """
# handle keys
for event in pygame.event.get():
if event.type == KEYDOWN:
if event.key == K_PLUS:
self.stepsPerSec *= 2
elif event.key == K_MINUS:
self.stepsPerSec = np.max([1, self.stepsPerSec / 2])
""" drawing """
self.screen.fill((0, 0, 0, 0))
self.pushObject.draw(self.screen)
for kilobot in self.kilobots:
kilobot.draw(self.screen)
# draw light
lx = int(self.SCALE_REAL_TO_VIS * lightPos[0, 0])
ly = int(self.screen.get_height() - self.SCALE_REAL_TO_VIS *
lightPos[0, 1])
lr = int(self.SCALE_REAL_TO_VIS * 0.02)
gfxdraw.aacircle(self.screen, lx, ly, lr, (255, 255, 0))
pygame.display.set_caption(('ep: {} - step: {} - ' +
'stepsPerSec: {}').format(ep + 1, step + 1, self.stepsPerSec))
pygame.display.flip()
self.clock.tick(self.stepsPerSec)
""" simulation """
# current state
objPos = self.pushObject.getRealPosition()
objPosOld = objPos
s = asmatrix(empty((1, S.shape[1])))
s[0, 0] = lightPos[0, 0] - objPos[0, 0]
s[0, 1] = lightPos[0, 1] - objPos[0, 1]
for (i, kilobot) in zip(range(self.numKilobots), self.kilobots):
kbPos = kilobot.getRealPosition()
s[0, 2 + 2 * i + 0] = kbPos[0, 0] - objPos[0, 0]
s[0, 2 + 2 * i + 1] = kbPos[0, 1] - objPos[0, 1]
# choose action
if self.useMean:
a = self.policy.getMeanAction(s)
else:
if random.random() <= self.epsilon:
a = self.policy.getRandomAction()
else:
a = self.policy.sampleActions(s)
# take action
n = linalg.norm(a)
if n > 0.015:
lightPos += (a * 0.015 / n)
else:
lightPos += a
# move directly toward the light
for kilobot in self.kilobots:
kbPos = kilobot.getRealPosition()
v = lightPos - kbPos
# cap max velocity
n = linalg.norm(v)
if n > 0.01:
v *= (0.01 / n)
kilobot.body.linearVelocity = vec2(v[0, 0], v[0, 1]) * \
self.SCALE_REAL_TO_SIM
kilobot.body.linearDamping = 0.0
for i in range(10):
self.world.Step(0.1, 10, 10)
# next state
objPos = self.pushObject.getRealPosition()
s_ = asmatrix(empty((1, S.shape[1])))
s_[0, 0] = lightPos[0, 0] - objPos[0, 0]
s_[0, 1] = lightPos[0, 1] - objPos[0, 1]
for (i, kilobot) in zip(range(self.numKilobots), self.kilobots):
kbPos = kilobot.getRealPosition()
s_[0, 2 + 2 * i + 0] = kbPos[0, 0] - objPos[0, 0]
s_[0, 2 + 2 * i + 1] = kbPos[0, 1] - objPos[0, 1]
# reward: learn to move the object to the right
objMovement = objPos - objPosOld
r = objMovement[0, 0] - 0.5 * np.abs(objMovement[0, 1])
# record sample
sampleIdx = ep * self.numStepsPerEpisode + step
S[sampleIdx, :] = s
A[sampleIdx, :] = a
R[sampleIdx, :] = r
S_[sampleIdx, :] = s_
return S, A, R, S_
def _testMazePolicy(self):
# create kilobots
self.kilobots = []
for i in range(self.numKilobots):
kilobot = Kilobot(self.world, self.SCALE_REAL_TO_SIM,
self.SCALE_REAL_TO_VIS, [0, 0])
kilobot.fixture.friction = 20
self.kilobots += [kilobot]
self.pushObject = Object(self.world, self.SCALE_REAL_TO_SIM,
self.SCALE_REAL_TO_VIS, [0, 0], self.objectShape)
# fixed object start position
objStartX = 1.25
objStartY = 0.75
r = self.kilobots[0].RADIUS
kilobotOffsets = array([[-r, -r], [r, -r], [-r, r], [r, r]])
self.pushObject.body.position = vec2(objStartX, objStartY) *\
self.SCALE_REAL_TO_SIM
self.pushObject.body.angle = 0
# light starts over the object
lightPos = matrix([objStartX, objStartY])
HALF_W = self.pushObject.HALF_W
# kilobots start left of the object
for (i, kilobot) in zip(range(self.numKilobots), self.kilobots):
x = objStartX - 2.0 * HALF_W + (1 + i / 4) * kilobotOffsets[i % 4, 0]
y = objStartY + (1 + i / 4) * kilobotOffsets[i % 4, 1]
kilobot.body.position = vec2(x, y) * self.SCALE_REAL_TO_SIM
s = asmatrix(empty((1, 2 + 2 * self.numKilobots)))
targetPos = matrix([objStartX, objStartY])
while True:
""" user interaction """
# handle keys
for event in pygame.event.get():
if event.type == KEYDOWN:
if event.key == K_PLUS:
self.stepsPerSec *= 2
elif event.key == K_MINUS:
self.stepsPerSec = np.max([1, self.stepsPerSec / 2])
""" drawing """
self.screen.fill((0, 0, 0, 0))
self.maze.draw(self.screen)
self.pushObject.draw(self.screen)
for kilobot in self.kilobots:
kilobot.draw(self.screen)
# draw light
lx = int(self.SCALE_REAL_TO_VIS * lightPos[0, 0])
ly = int(self.screen.get_height() - self.SCALE_REAL_TO_VIS *
lightPos[0, 1])
lr = int(self.SCALE_REAL_TO_VIS * 0.02)
gfxdraw.aacircle(self.screen, lx, ly, lr, (255, 255, 0))
objPos = self.pushObject.getRealPosition()
# draw line from object to target position
ox = int(self.SCALE_REAL_TO_VIS * objPos[0, 0])
oy = int(self.screen.get_height() - self.SCALE_REAL_TO_VIS *
objPos[0, 1])
tx = int(self.SCALE_REAL_TO_VIS * targetPos[0, 0])
ty = int(self.screen.get_height() - self.SCALE_REAL_TO_VIS *
targetPos[0, 1])
pygame.draw.aaline(self.screen, (0, 0, 255), (ox, oy), (tx, ty))
pygame.display.flip()
self.clock.tick(self.stepsPerSec)
""" simulation """
# current state
s[0, 0] = lightPos[0, 0] - objPos[0, 0]
s[0, 1] = lightPos[0, 1] - objPos[0, 1]
for (i, kilobot) in zip(range(self.numKilobots), self.kilobots):
kbPos = kilobot.getRealPosition()
s[0, 2 + 2 * i + 0] = kbPos[0, 0] - objPos[0, 0]
s[0, 2 + 2 * i + 1] = kbPos[0, 1] - objPos[0, 1]
# solve maze
targetPos = self.mazePolicy.getTargetPosition(objPos)
# rotate state
direction = targetPos - objPos
angle = -math.atan2(direction[0, 1], direction[0, 0])
sx = s.flat[0::2] * math.cos(angle) - s.flat[1::2] * math.sin(angle)
sy = s.flat[1::2] * math.cos(angle) + s.flat[0::2] * math.sin(angle)
s.flat[0::2] = sx
s.flat[1::2] = sy
# choose action
a = self.objPolicy.getMeanAction(s)
# rotate action
ax = a[0, 0] * math.cos(-angle) - a[0, 1] * math.sin(-angle)
ay = a[0, 1] * math.cos(-angle) + a[0, 0] * math.sin(-angle)
a[0, 0] = ax
a[0, 1] = ay
# take action
n = linalg.norm(a)
if n > 0.015:
lightPos += (a * 0.015 / n)
else:
lightPos += a
# move directly toward the light
for kilobot in self.kilobots:
kbPos = kilobot.getRealPosition()
v = lightPos - kbPos
# cap max velocity
n = linalg.norm(v)
if n > 0.01:
v *= (0.01 / n)
kilobot.body.linearVelocity = vec2(v[0, 0], v[0, 1]) * \
self.SCALE_REAL_TO_SIM
kilobot.body.linearDamping = 0.0
for i in range(10):
self.world.Step(0.1, 10, 10)
#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)
