Beispiel #1
0
def draw_path(final_path):
    for i in final_path:
        dot = Circle(
            Point((i.j * square_size) + square_size / 2,
                  (i.i * square_size) + square_size / 2), 10)
        dot.setFill(color_rgb(66, 134, 244))
        dot.draw(win)
Beispiel #2
0
def blackHoles(field):

    # Create a list of numbers that could be X and Y coordinates
    numbers = []
    for i in range(60, 360, 40):
        numbers.append(i)

    # From that list, ceate first blackhole coordinates
    blackX1 = int(choice(numbers))
    blackY1 = int(choice(numbers))

    # Create second blackhole coordinates
    blackX2 = int(choice(numbers))
    blackY2 = int(choice(numbers))

    # Draw the black holes
    black1 = Circle(Point(blackX1, blackY1), 5)
    black1.setFill('black')
    black1.draw(field)
    black2 = Circle(Point(blackX2, blackY2), 5)
    black2.setFill('black')
    black2.draw(field)

    # Get the centers of the circles
    blackcenter1 = black1.getCenter()
    blackcenter2 = black2.getCenter()

    # Return the center locations for the black holes
    return blackcenter1, blackcenter2
Beispiel #3
0
    def draw_mark(self, move: tuple) -> None:
        """ Draw a mark as specified by a move 
        :param move: a legal move: (selected_tile.x_pos, selected_tile.y_pos, player.mark)
        :return: none
        """

        if self.window is None:
            raise ValueError('Board has no open window!')

        tile_x, tile_y, mark = move

        grid_x, grid_y = self.coord_tile_to_grid(tile_x, tile_y)

        rad = self.tile_size * 0.3

        if mark == 'O':
            cir = Circle(Point(grid_x, grid_y), rad)
            cir.setOutline('blue')
            cir.setWidth(3)
            cir.draw(self.window)
        else:
            downstroke = Line(Point(grid_x - rad, grid_y - rad),
                              Point(grid_x + rad, grid_y + rad))
            upstroke = Line(Point(grid_x - rad, grid_y + rad),
                            Point(grid_x + rad, grid_y - rad))
            downstroke.setOutline('red')
            downstroke.setWidth(3)
            upstroke.setOutline('red')
            upstroke.setWidth(3)
            upstroke.draw(self.window)
            downstroke.draw(self.window)
Beispiel #4
0
def update_board(second_per_update):
    # A*
    current = min(openSet, key=lambda o: o.f)
    # BFS
    # current = openSet[0]
    # DIJKSTRA
    # current = min(openSet, key=lambda o: o.g)
    for i in openSet:
        if i not in open_update:
            rect = i.rectangle(i.i, i.j)
            rect.setFill(color_rgb(167, 239, 180))
            rect.draw(win)
            open_update.append(i)
            text = i.hScoreText(i.i, i.j)
            text.setOutline(color_rgb(19, 10, 200))
            text.setStyle("bold")
            text.draw(win)
        dot = Circle(
            Point(current.j * square_size + square_size / 2,
                  current.i * square_size + square_size / 2), 10)
        dot.setOutline(color_rgb(19, 10, 200))
        dot.draw(win)
    for i in closeSet:
        if i not in closed_update:
            rect = i.rectangle(i.i, i.j)
            rect.setFill(color_rgb(239, 167, 167))
            rect.draw(win)
            closed_update.append(i)
            text = i.hScoreText(i.i, i.j)
            text.setOutline(color_rgb(19, 10, 200))
            text.setStyle("bold")
            text.draw(win)
    openSet_score.setText(openSet.__len__())
    closedSet_score.setText(closeSet.__len__())
    time.sleep(second_per_update)
Beispiel #5
0
class Intersection:
    """graphical representation of a vertex"""
    def __init__(self, vertex):
        self.id = vertex.id
        self.x = vertex.x
        self.y = vertex.y
        self.radius = 3
        self.shape = Circle(Point(self.x, self.y), self.radius)

    def __repr__(self):
        return "Intersection {0}: ({1}, {2})".format(self.id, self.x, self.y)

    def draw(self, canvas):
        self.shape.draw(canvas)

    def clicked(self, p):
        xmin = self.x - self.radius
        xmax = self.x + self.radius
        ymin = self.y - self.radius
        ymax = self.y + self.radius
        return (xmin <= p.getX() <= xmax and ymin <= p.getY() <= ymax)

    def get_info(self):
        info = {
            "type": "Intersection",
            "id": self.id,
            "x": "{0:.1f}".format(self.x),
            "y": "{0:.1f}".format(self.y),
        }
        return info
Beispiel #6
0
class Wheel():

    def __init__(self, center, wheel_radius, tire_radius):
        self.tire_circle = Circle(center, tire_radius)
        self.wheel_circle = Circle(center, wheel_radius)

    def draw(self, win): 
        self.tire_circle.draw(win) 
        self.wheel_circle.draw(win) 

    def move(self, dx, dy): 
        self.tire_circle.move(dx, dy) 
        self.wheel_circle.move(dx, dy)

    def set_color(self, wheel_color, tire_color):
        self.tire_circle.setFill(tire_color) 
        self.wheel_circle.setFill(wheel_color)

    def undraw(self): 
        self.tire_circle .undraw() 
        self.wheel_circle .undraw() 

    def get_size(self):
        return self.tire_circle.getRadius()

    def get_center(self):
        return self.tire_circle.getCenter()

    def animate(self, win, dx, dy, n):
        if n > 0:
            self.move(dx, dy)
            win.after(100, self.animate, win, dx, dy, n - 1)
Beispiel #7
0
 def __makePip(self, x, y):
     "Internal helper method to draw a pip at (x,y)"
     pip = Circle(Point(x, y), self.psize)
     pip.setFill(self.background)
     pip.setOutline(self.background)
     pip.draw(self.win)
     return pip
Beispiel #8
0
class ShotTracker:
    def __init__(self, win, angle, velocity, height):
        """win is the GraphWin to display the shot. angle, velocity,
            and height are initial projectile parameters.
        """

        self.proj = Projectile(angle, velocity, height)
        self.marker = Circle(Point(0, height), 3)
        self.marker.setFill("red")
        self.marker.setOutline("red")
        self.marker.draw(win)

    def update(self, dt):
        """Move the shot dt seconds farther along its flight """

        # Update the projectile
        self.proj.update(dt)

        # Moves the circle to the new projectile location
        center = self.marker.getCenter()
        dx = self.proj.getX() - center.getX()
        dy = self.proj.getY() - center.getY()
        self.marker.move(dx, dy)

    def getX(self):
        """ return the current x coordinate of the shot's center """
        return self.proj.getX()

    def getY(self):
        """ return the current y coordinate of the  shot's center """
        return self.proj.getY()

    def undraw(self):
        """ undraw the shot """
        self.marker.undraw()
 def createWindow(self, N):
     """
     Create the graphics window.
     Arguments:
         self - the SkewerUI instance
         N - the capacity of the skewer
     """
     self.win = GraphWin("Shish Kebab", 800, 200)
     self.win.setCoords( \
         WIN_LOW_LEFT_X, \
         WIN_LOW_LEFT_Y - 0.1, \
         WIN_LOW_LEFT_X+(N+1)*FOOD_WIDTH, \
         WIN_UP_RIGHT_Y + 0.1 \
     )
     
     # draw skewer
     line = Line( \
         Point(WIN_LOW_LEFT_X, WIN_LOW_LEFT_Y+WIN_HEIGHT/2.0), \
         Point(N, WIN_LOW_LEFT_Y+WIN_HEIGHT/2.0) \
     )
     line.setWidth(LINE_THICKNESS)
     line.draw(self.win)
     handle = Circle( \
         Point(N-.1, WIN_LOW_LEFT_Y+WIN_HEIGHT/2.0), \
         SKEWER_HANDLE_RADIUS \
     )
     handle.setFill(BKGD_COLOR)
     handle.setWidth(LINE_THICKNESS)
     handle.draw(self.win)
     self.items = []
Beispiel #10
0
    def set_graphicals(self):
        draw_x = scale(self.pos_x)
        draw_y = scale(self.pos_y)

        if self.circle is not None and self.get_trace is False:
            dubinc = Circle(self.circle.c.get_scaled_point(),
                            scale_vectors(self.circle.r))
            dubinc.setOutline('Green')
            dubinc.draw(self.win)

        if self.body is not None and self.get_trace is False:
            self.body.undraw()
        self.body = Circle(Point(draw_x, draw_y), self.body_radius)
        self.body.setFill('yellow')
        self.body.draw(self.win)
        if self.vel_arrow:
            self.vel_arrow.undraw()
        self.vel_arrow = Line(
            Point(draw_x, draw_y),
            Point(scale(self.pos_x + self.current_vel[0]),
                  scale(self.pos_y + self.current_vel[1])))
        self.vel_arrow.setFill('black')
        self.vel_arrow.setArrow("last")
        self.vel_arrow.draw(self.win)
        if self.acc_arrow:
            self.acc_arrow.undraw()
        self.acc_arrow = Line(
            Point(draw_x, draw_y),
            Point(scale(self.pos_x + self.current_acc[0] * 5),
                  scale(self.pos_y + self.current_acc[1] * 5)))
        self.acc_arrow.setFill('blue')
        self.acc_arrow.setArrow('last')
        self.acc_arrow.draw(self.win)
Beispiel #11
0
 def __moveBall(self, pos):
     """Move a graphic to a particular position on the window,
     rather than move by an amount"""
     old = self.graphic
     graphic = Circle(pos, self.rad)
     graphic.draw(self.window)
     self.graphic = graphic
     old.undraw()
Beispiel #12
0
def draw_path(final_path):
    for i in final_path:
        dot = Circle(
            Point((i.j * square_size) + square_size / 2,
                  (i.i * square_size) + square_size / 2), 10)
        dot.setFill(color_rgb(206, 141, 14))
        dot.setOutline(color="white")
        dot.setWidth(3)
        dot.draw(win)
Beispiel #13
0
    def _visualise_gap(self, alpha):
        alpha_rad = (alpha * 2 * math.pi / 360) - math.pi / 2
        y = self.r * math.sin(alpha_rad)
        x = -1 * self.r * math.cos(alpha_rad)
        gap = Circle(Point(x + 250, y + 250), 5)  # set center and radius
        gap.setFill("red")
        gap.draw(self.win)

        return gap
Beispiel #14
0
def drawLegalMoves(board, win, tile1):
    legalmoves = board.getLegalMoves(tile1)

    tileWidth = WIDTH/board.boardWidth
    tileHeight = HEIGHT/board.boardWidth

    for move in legalmoves:
        circ = Circle(tileToCoord(board, move), min(tileWidth, tileHeight)/4)
        circ.setFill('gray')
        circ.draw(win)
Beispiel #15
0
def draw_coin(window, x, y, score):
    coinCoord = Point(OFFSET + y * SCALE, OFFSET + x * VSCALE)
    if score == 2:
        coin = Circle(coinCoord, GOLD_SIZE)
        coin.setFill(GOLD_COIN)
    else:
        coin = Circle(coinCoord, SILVER_SIZE)
        coin.setFill(SILVER_COIN)
    coin.draw(window)
    return coin
def draw_circle(win, colour, centre, radius, current_tile, fill=False):
    """Helper function for drawing circles."""
    current_circle = Circle(Point(*centre), radius)
    if fill:
        current_circle.setFill(colour)
    else:
        current_circle.setOutline(colour)
    current_circle.setOutline(colour)
    current_circle.draw(win)
    current_tile.append(current_circle)
Beispiel #17
0
def draw_circle(board_column, board_row, color, dot_size):
    if color != "white":
        head = Circle(
            Point((board_column * (size * 2) + (offsetC + dot_size)),
                  (board_row * (size * 2) + (offsetR + dot_size))), dot_size)
        head.setFill(color)
    else:
        head = Circle(
            Point((board_column * (size * 2) + (offsetC + dot_size)),
                  (board_row * (size * 2) + (offsetR + dot_size))),
            dot_size / 3)
        head.setFill(color)
    head.draw(win)
Beispiel #18
0
class Asteroid:
    def __init__(self, pos, dest, win, vel, type):
        self.pos = pos
        self.dest = Point(dest.getX() - pos.getX(), dest.getY() - pos.getY())
        self.vel = vel
        self.type = type
        self.aliveFlag = True
        self.outOfBounds = False

        r = 25 * type
        self.object = Circle(self.pos, r)
        self.object.setFill(color_rgb(randrange(100, 255), 240, 90))

        self.draw(win)

    def draw(self, win):
        self.object.draw(win)

    def undraw(self):
        self.object.undraw()

    def update(self, dt, win):
        #normalize values
        dest = norm(self.dest.getX(), self.dest.getY())

        #calculate x and y movement
        x = dest.getX() * self.vel * dt
        y = dest.getY() * self.vel * dt

        self.object.move(x, y)
        self.pos = self.object.getCenter()

        if self.pos.getX() < -100:
            self.outOfBounds = True

    def getAliveFlag(self):
        return self.aliveFlag

    def setAliveFlag(self, statement=True):
        self.aliveFlag = statement

    def getOutOfBounds(self):
        return self.outOfBounds

    def getType(self):
        return self.type

    def getObject(self):
        return self.object
Beispiel #19
0
class Bullet:
    def __init__(self, pos, win, r, dest, vel=1.0, c=color_rgb(255, 255, 255)):
        self.pos = pos  #position
        self.dest = Point(dest.getX() - pos.getX(),
                          dest.getY() - pos.getY())  #destination
        self.radius = r  #radius
        self.vel = vel  #velocity

        self.object = Circle(self.pos, r)  #Circle
        self.object.setFill(c)  #set colour
        self.object.setOutline('black')
        self.draw(win)  #draw

        self.aliveFlag = True

    def getAliveFlag(self):
        return self.aliveFlag

    def update(self, dt, win):
        #normalize values
        dest = norm(self.dest.getX(), self.dest.getY())

        #calculate x and y movement
        x = dest.getX() * self.vel * dt
        y = dest.getY() * self.vel * dt

        #move object
        self.object.move(x, y)

        #set position
        self.pos = self.object.getCenter()

        #Split into two if statements for readability
        if self.pos.getX() > win.getWidth() or self.pos.getY() > win.getHeight(
        ):
            self.aliveFlag = False
        elif self.pos.getX() < 0 or self.pos.getY() < 0:
            self.aliveFlag = False

    def getObject(self):
        return self.object

    def draw(self, win):
        self.object.draw(win)

    #remove object from screen
    def undraw(self):
        self.object.undraw()
Beispiel #20
0
class Particle:
    def __init__(self, window, p=Point(0, 0)):
        self.particle = None
        self.drawn = False
        self.color = "RED"
        self.position = p
        self.x = p.getX()
        self.y = p.getY()
        self.size = 3
        self.dX = 0
        self.dY = 0
        self.win = window
        self.particleTurnCount = 0

    def setCoord(self, x, y):
        self.x = x
        self.y = y

    def setColor(self, color):
        self.color = color
        if self.particle:
            self.particle.setFill(color)

    def setSize(self, size):
        self.size = size
        if self.drawn:
            self.undraw()
            self.draw()

    def draw(self):
        self.particle = Circle(Point(self.x, self.y), self.size)
        self.particle.setFill(self.color)
        self.particle.draw(self.win)
        self.drawn = True

    def undraw(self):
        self.particle.undraw()
        self.drawn = False

    def setParticleMovement(self, dx, dy):
        self.dX = dx
        self.dY = dy

    def move(self):
        self.particle.move(self.dX, self.dY)
        self.position = Point(self.position.getX() + self.dX, self.position.getY() + self.dY)
        self.particle.undraw()
        self.particle.draw(self.win)
Beispiel #21
0
def five_click_stick_figure():
    """
    9. [harder] Write a five_click_stick_figure() function that allows the user
    to draw a (symmetric) stick figure in a graphics window using five clicks of
    the mouse to determine the positions of its features. Each feature should be
    drawn as the user clicks the points.

    Hint: the radius of the head is the distance between points 1 and 2 — see
    the previous practical.

    Note: only the y-coordinate of point (3) should be used — its x coordinate
    should be copied from point (1).
    """
    win = GraphWin("Five Click Stick Figure", 800, 600)
    message = Text(Point(400, 15), "Click to create your stick figure")
    message.draw(win)

    head_centre = win.getMouse()
    head_centreX, head_centreY = head_centre.getX(), head_centre.getY()
    head_perim = win.getMouse()
    head_perimX, head_perimY = head_perim.getX(), head_perim.getY()
    head_radius = math.sqrt((head_perimX - head_centreX)**2 +
                            (head_perimY - head_centreY)**2)
    head = Circle(head_centre, head_radius)
    head.draw(win)

    torso = win.getMouse()
    torso_line = Line(Point(head_centreX, head_centreY + head_radius),
                      Point(head_centreX, torso.getY()))
    torso_line.draw(win)

    arm_reach = win.getMouse()
    arm_length = head_centreX - arm_reach.getX()
    arms_line = Line(Point(arm_reach.getX(), arm_reach.getY()),
                     Point(head_centreX + arm_length, arm_reach.getY()))
    arms_line.draw(win)

    leg_reach = win.getMouse()
    left_leg_line = Line(Point(head_centreX, torso.getY()),
                         Point(leg_reach.getX(), leg_reach.getY()))
    left_leg_line.draw(win)

    leg_distance = head_centreX - leg_reach.getX()
    right_leg_line = Line(Point(head_centreX, torso.getY()),
                          Point(head_centreX + leg_distance, leg_reach.getY()))
    right_leg_line.draw(win)

    await_user_input(win)
Beispiel #22
0
    def _setup(self):
        circle = Circle(Point(250, 250), self.r)  # set center and radius
        circle.setWidth(3)
        circle.draw(self.win)

        line = Line(Point(250, 225), Point(250, 285))
        line.setWidth(3)
        line.draw(self.win)

        line2 = Line(Point(280, 250), Point(250, 225))
        line2.setWidth(3)
        line2.draw(self.win)

        line3 = Line(Point(220, 250), Point(250, 225))
        line3.setWidth(3)
        line3.draw(self.win)
Beispiel #23
0
def peas_in_a_pod():
    """
    5. Write a function peas_in_a_pod() that asks the user for a number, and
    then draws that number of 'peas' (green circles of radius 50) in a 'pod'
    (graphics window of exactly the right size). E.g. if the user enters 5, a
    graphics window of size 500 × 100 should appear.
    """
    peas = int(input("Enter a number of peas: "))
    win = GraphWin("Peas in a pod", peas * 100, 100)
    for pea in range(peas):
        circle = Circle(Point(50 + pea * 100, 50), 50)
        circle.setFill("green")
        circle.draw(win)

    win.getMouse()
    win.close()
Beispiel #24
0
def test(points,
         number_of_clusters,
         solution=None,
         max_iterations=100,
         method=Methods.method_heuristic_initial_clusters_max_dist):
    win = GraphWin("Results", 800, 600)
    displacement = 20

    time_start = time()

    for point in points:
        p = GPoint(point.x * displacement, point.y * displacement)
        p.draw(win)

    iteration_result = Methods.clustering(points, number_of_clusters,
                                          max_iterations, method)

    clusters = iteration_result.clusters

    for c in clusters:
        c = Circle(
            GPoint(c.center.x * displacement, c.center.y * displacement),
            c.radius * displacement)
        c.draw(win)

    time_end = time()

    time_range = time_end - time_start

    print("-----------------------------")
    print("Method used: " + get_method_name(method))
    print("Total time: " + str(time_range) + " s")
    print("Results after " + str(max_iterations) + " iterations:")
    print(str(clusters))
    if solution is not None:
        errors = Methods.compare_results(clusters, solution)
        print("Max error: " + str(errors[1]))
        print("Min error: " + str(errors[2]))
        print("Median error: " + str(errors[0]))

    try:
        win.getMouse()
        win.close()
    except:
        return 0
Beispiel #25
0
    def _visualise_gap_id(self, alpha, id):
        alpha_rad = (alpha * 2 * math.pi / 360) - math.pi / 2
        y = self.r * math.sin(alpha_rad)
        x = -1 * self.r * math.cos(alpha_rad)

        pos = Point(x + 250, y + 250)

        gap = Circle(pos, 8)  # set center and radius
        gap.setFill("red")
        gap.draw(self.win)

        text = Text(pos, str(id))
        text.setTextColor("black")
        text.setSize(8)
        text.setStyle('bold')
        text.draw(self.win)

        return (id, gap, text)
Beispiel #26
0
class Goal:
    def __init__(self, pos, win):
        #self.vel_x, self.vel_y = vel[0], vel[1]
        #self.vel = np.array([self.vel_x, self.vel_y])
        self.pos_x = pos[0]
        self.pos_y = pos[1]
        self.win = win

    def set_graphicals(self):
        # draw player
        self.body = Circle(Point(scale(self.pos_x), scale(self.pos_y)), 7)
        self.body.setFill('red')
        # Note: downwards in Y is the positive direction for this graphics lib
        #self.arrow = Line(Point(scale(self.pos_x), scale(self.pos_y)),
        #    Point(scale(self.pos_x + self.vel_x), scale(self.pos_y + self.vel_y)))
        #self.arrow.setFill('black')
        #self.arrow.setArrow('last')
        self.body.draw(self.win)
Beispiel #27
0
 def set_graphicals(self, quick_draw):
     """Draws the graph"""
     self.drawables = []
     self.drawable_path = []
     t = time.time()
     for node in self.graph:
         curr_loc = node.get_scaled_point()
         draw_node = Circle(curr_loc, 1)
         draw_node.setFill('red')
         draw_node.draw(self.win)
         self.drawables.append(draw_node)
         if not quick_draw:
             for neighbor in self.graph[node]:
                 if neighbor:
                     line = Line(curr_loc, neighbor.get_scaled_point())
                     line.draw(self.win)
                     self.drawables.append(line)
     if self.path is not None:
         for i in range(0, len(self.path) - 1):
             node_1 = self.path[i]
             node_2 = self.path[i + 1]
             cir = Circle(node_1.get_scaled_point(), 2)
             cir.setFill('Red')
             cir.setOutline('Red')
             self.drawable_path.append(cir)
             lin = Line(node_1.get_scaled_point(),
                        node_2.get_scaled_point())
             lin.setOutline('Red')
             lin.draw(self.win)
             self.drawable_path.append(lin)
         for i in range(0, len(self.optimal_path) - 1):
             node_1 = self.optimal_path[i]
             node_2 = self.optimal_path[i + 1]
             cir = Circle(node_1.get_scaled_point(), 5)
             cir.setFill('Blue')
             cir.setOutline('Blue')
             cir.draw(self.win)
             self.drawable_path.append(cir)
             lin = Line(node_1.get_scaled_point(),
                        node_2.get_scaled_point())
             lin.setOutline('Blue')
             lin.draw(self.win)
             self.drawable_path.append(lin)
     emit_verbose("Drawing RRT took", self.verbose, var=time.time() - t)
Beispiel #28
0
def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--size", type=int, default=3, help="Size of k")
    args = parser.parse_args()

    win = GraphWin("My Circle", WIN_SIZE, WIN_SIZE)

    k = args.size
    m = k * (k - 1) + 1
    r = min(pi * R / m * 0.50, 20)

    ds = DiffState(k)
    ds.search()

    points = []
    for i in range(m):
        ang = 2 * pi * i / m
        center = (CENTER[0] + R * sin(ang), CENTER[1] - R * cos(ang))
        points.append(Point(center[0], center[1]))

    if m < 20:
        for i in range(m):
            for j in range(i, m):
                if not (i in ds.current and j in ds.current):
                    l = Line(points[i], points[j])
                    l.draw(win)
                    l.setOutline(all_color)

    for i in range(m):
        for j in range(i, m):
            if i in ds.current and j in ds.current:
                l = Line(points[i], points[j])
                l.setWidth(3)
                l.draw(win)
                l.setOutline(set_color)

    for i in range(m):
        c = Circle(points[i], r)
        c.setFill('red')
        c.draw(win)

    win.getMouse()
    win.close()
Beispiel #29
0
def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--size", type=int, default=3, help="Size of k")
    args = parser.parse_args()

    win = GraphWin("My Circle", WIN_SIZE, WIN_SIZE)

    k = args.size
    m = k * (k - 1) + 1
    r = min(pi * R / m * 0.50, 20)

    ds = DiffState(k)
    ds.search()

    points = []
    for i in range(m):
        ang = 2 * pi * i / m
        center = (CENTER[0] + R * sin(ang), CENTER[1] - R * cos(ang))
        points.append(Point(center[0], center[1]))

    if m < 20:
        for i in range(m):
            for j in range(i, m):
                if not (i in ds.current and j in ds.current):
                    l = Line(points[i], points[j])
                    l.draw(win)
                    l.setOutline(all_color)

    for i in range(m):
        for j in range(i, m):
            if i in ds.current and j in ds.current:
                l = Line(points[i], points[j])
                l.setWidth(3)
                l.draw(win)
                l.setOutline(set_color)

    for i in range(m):
        c = Circle(points[i], r)
        c.setFill("red")
        c.draw(win)

    win.getMouse()
    win.close()
    def draw(self, from_update=False):
        radius = 10
        circle1 = Circle(center=self.location, radius=radius)
        if self.firing:
            circle1.setFill('red')
        else:
            if self.was_fired > 0:
                circle1.setFill('yellow')
            else:
                circle1.setFill(color_rgb(240, 240, 240))
        # if self.prev_firing and from_update:
        #     circle1.setFill('yellow')
        circle1.draw(self.brain.win)

        message = Text(self.location, self.presentation)
        message.setTextColor('red')
        # message.setStyle('italic')
        message.setSize(10)
        message.draw(self.brain.win)
Beispiel #31
0
 def __init__(self,window,P1,level):
     from graphics import GraphWin,Circle
     import random
     from time import time
     self.p1=P1
     self.window=window
     self.cir=Circle(self.p1,0.4)
     self.level=level
     self.cir.setWidth(0)
    
     i=random.randrange(6,9+self.level)
     self.color=i
     if self.color==6:                 #颜色对应数字
         self.cir.setFill("red")
     if self.color==7:
         self.cir.setFill("green")
     if self.color==8:
         self.cir.setFill("black")
     if self.color==9:
         self.cir.setFill("blue")
     if self.color==10:
         self.cir.setFill("orange")
     for s in range(100):
         cirs=Circle(self.p1,0.0+s*0.004)
         if self.color==6:
             cirs.setFill("red")
         if self.color==7:
             cirs.setFill("green")
         if self.color==8:
             cirs.setFill("black")
         if self.color==9:
             cirs.setFill("blue")
         if self.color==10:
             cirs.setFill("orange")
         cirs.draw(self.window)
         empty=0                     #空循环控制时间(time间隔太大)
         while empty<=30000:
             empty=empty+1
         cirs.undraw()    
     self.cir.draw(self.window)
     self.activate=True
Beispiel #32
0
    def set_graphicals(self):
        draw_x = scale(self.pos_x)
        draw_y = scale(self.pos_y)

        # Draw the new path
        if self.sling_path_calculated is not None:
            for action in self.sling_path_calculated:
                cir = Circle(action[0].get_scaled_point(), self.body_radius)
                cir.setFill('yellow')
                cir.draw(self.win)

        if self.circle is not None:
            dubinc = Circle(self.circle.c.get_scaled_point(),
                            scale_vectors(self.circle.r))
            dubinc.setOutline('Green')
            dubinc.draw(self.win)

        if self.body:
            self.body.undraw()
        self.body = Circle(Point(draw_x, draw_y), self.body_radius)
        self.body.setFill('yellow')
        self.body.draw(self.win)
        if self.vel_arrow:
            self.vel_arrow.undraw()
        self.vel_arrow = Line(
            Point(draw_x, draw_y),
            Point(scale(self.pos_x + self.current_vel[0] * 5),
                  scale(self.pos_y + self.current_vel[1] * 5)))
        self.vel_arrow.setFill('black')
        self.vel_arrow.setArrow("last")
        self.vel_arrow.draw(self.win)
        if self.acc_arrow:
            self.acc_arrow.undraw()
        self.acc_arrow = Line(
            Point(draw_x, draw_y),
            Point(scale(self.pos_x + self.current_acc[0] * 5),
                  scale(self.pos_y + self.current_acc[1] * 5)))
        self.acc_arrow.setFill('blue')
        self.acc_arrow.setArrow('last')
        self.acc_arrow.draw(self.win)
        '''
Beispiel #33
0
class Dado(object):
    def __init__(self, v, centro, ancho, alto):
        x, y = centro.getX(), centro.getY()
        w, h = ancho /2, alto /2
        self.ventana = v
        self.xmax, self.xmin = x+w, x-w
        self.ymax, self.ymin = y+h, y-h
        p1 = Point(self.xmin, self.ymin)
        p2 = Point(self.xmax, self.ymax)
        self.dado = Rectangle(p1, p2)
        self.dado.draw(v)
        self.dado.setFill('#FF0000')
        '''pintamos los circulos del dado con las posiciones reescalables de los puntos
    
            pos1            pos5
            pos2    pos4    pos6
            pos3            pos7
            
        '''
        self.pos1 = Point(self.xmin + w /2, self.ymin + h /2)
        self.pos2 = Point(self.xmin + w / 2, self.ymin + h)
        self.pos3 = Point(self.xmin + w / 2, self.ymin + h * 1.5)
        self.pos4 = Point(self.xmin + w, self.ymin + h)
        self.pos5 = Point(self.xmin + w * 1.5, self.ymin + h /2)
        self.pos6 = Point(self.xmin + w * 1.5, self.ymin + h)
        self.pos7 = Point(self.xmin + w * 1.5, self.ymin + h * 1.5)
        
        self.c1 = Circle(self.pos1, 4)
        self.c1.setOutline('#fff')
        self.c1.setFill('#fff')
        self.c1.draw(self.ventana)
            
        self.c2 = Circle(self.pos2, 4)
        self.c2.setOutline('#fff')
        self.c2.setFill('#fff')
        self.c2.draw(self.ventana)
            
        self.c3 = Circle(self.pos3, 4)
        self.c3.setOutline('#fff')
        self.c3.setFill('#fff')
        self.c3.draw(self.ventana) 
            
        self.c4 = Circle(self.pos4, 4)
        self.c4.setOutline('#fff')
        self.c4.setFill('#fff')
        self.c4.draw(self.ventana)
            
        self.c5 = Circle(self.pos5, 4)
        self.c5.setOutline('#fff')
        self.c5.setFill('#fff')
        self.c5.draw(self.ventana)
            
        self.c6 = Circle(self.pos6, 4)
        self.c6.setOutline('#fff')
        self.c6.setFill('#fff')
        self.c6.draw(self.ventana)
            
        self.c7 = Circle(self.pos7, 4)
        self.c7.setOutline('#fff')
        self.c7.setFill('#fff')
        self.c7.draw(self.ventana)
        
        self.limpiar()
        
    def colorDado(self, c):#personalizar el dado
        self.dado.setFill(c)
        
    def colorPunto(self, c):#personalizar los puntos del dado
        self.c1.setOutline(c)
        self.c1.setFill(c)
        self.c2.setOutline(c)
        self.c2.setFill(c)
        self.c3.setOutline(c)
        self.c3.setFill(c)
        self.c4.setOutline(c)
        self.c4.setFill(c)
        self.c5.setOutline(c)
        self.c5.setFill(c)
        self.c6.setOutline(c)
        self.c6.setFill(c)
        self.c7.setOutline(c)
        self.c7.setFill(c)
        
    def pulsado(self, p):#funcion para saber si se ha pulsado
        if p.getX() in range(self.xmin, self.xmax) and p.getY() in range(self.ymin, self.ymax):
            return True
        else:
            return False
        
    def ponValor(self, valor=1):#funcion para establecer la cara visible del dado
        self.limpiar()
        if valor == 1:
            self.c4.draw(self.ventana)
        elif valor == 2:
            self.c1.draw(self.ventana)
            self.c7.draw(self.ventana)
        elif valor == 3:
            self.c1.draw(self.ventana)
            self.c4.draw(self.ventana)
            self.c7.draw(self.ventana)
        elif valor == 4:
            self.c1.draw(self.ventana)
            self.c3.draw(self.ventana)
            self.c5.draw(self.ventana)
            self.c7.draw(self.ventana)
        elif valor == 5:
            self.c1.draw(self.ventana)
            self.c3.draw(self.ventana)
            self.c4.draw(self.ventana)
            self.c5.draw(self.ventana)
            self.c7.draw(self.ventana)
        elif valor == 6:
            self.c1.draw(self.ventana)
            self.c2.draw(self.ventana)
            self.c3.draw(self.ventana) 
            self.c5.draw(self.ventana)
            self.c6.draw(self.ventana)
            self.c7.draw(self.ventana)
            
    def limpiar(self):#limpiar el dado antes de pintar
        self.c1.undraw()
        self.c2.undraw()
        self.c3.undraw()
        self.c4.undraw()
        self.c5.undraw()
        self.c6.undraw()
        self.c7.undraw()
        
    def tirarDado(self):#funcion para visualizar aleatoriamente una cara
        posibles = [1, 2, 3, 4, 5, 6]
        num = choice(posibles)
        self.ponValor(num)
        return num
Beispiel #34
0
def draw_patch(patch, win):
    if win is not None:
        c = Circle(Point(patch.x_pos, patch.y_pos), patch.radius)
        c.setOutline("red")
        c.draw(win)
Beispiel #35
0
class circle:
    
    def __init__(self,window,P1,level):
        from graphics import GraphWin,Circle
        import random
        from time import time
        self.p1=P1
        self.window=window
        self.cir=Circle(self.p1,0.4)
        self.level=level
        self.cir.setWidth(0)
       
        i=random.randrange(6,9+self.level)
        self.color=i
        if self.color==6:                 #颜色对应数字
            self.cir.setFill("red")
        if self.color==7:
            self.cir.setFill("green")
        if self.color==8:
            self.cir.setFill("black")
        if self.color==9:
            self.cir.setFill("blue")
        if self.color==10:
            self.cir.setFill("orange")
        for s in range(100):
            cirs=Circle(self.p1,0.0+s*0.004)
            if self.color==6:
                cirs.setFill("red")
            if self.color==7:
                cirs.setFill("green")
            if self.color==8:
                cirs.setFill("black")
            if self.color==9:
                cirs.setFill("blue")
            if self.color==10:
                cirs.setFill("orange")
            cirs.draw(self.window)
            empty=0                     #空循环控制时间(time间隔太大)
            while empty<=30000:
                empty=empty+1
            cirs.undraw()    
        self.cir.draw(self.window)
        self.activate=True
            
    
    def click(self,pr):
        from graphics import Circle
        import time
        pd=False       
        if self.activate==True and (pr.getX()-self.p1.getX())**2+(pr.getY()-self.p1.getY())**2<=0.24:
            
            for i in range(3):                    #点击动画
                self.cir.move(0,-0.12/3.0)
                time.sleep(0.01)
            for i in range(3):
                self.cir.move(0,0.12/3.0)
                time.sleep(0.01)
            for i in range(3):
                self.cir.move(0,-0.12/3.0)
                time.sleep(0.01)
            for i in range(3):
                self.cir.move(0,0.12/3.0)
                time.sleep(0.01)
            pd=True
        return pd
  
            
           
    def undraw(self):
        self.cir.undraw()
    def close(self):
        self.cir.undraw()
        self.activate=False
    def move(self,pr):
        self.cir.move(pr.getX()-self.p1.getX(),pr.getY()-self.p1.getY())
        self.p1.move(pr.getX()-self.p1.getX(),pr.getY()-self.p1.getY())