Exemplo n.º 1
0
    def _get_initial_positions_frame(self):
        '''Returns the position of each robot and ball for the initial frame'''
        pos_frame: Frame = Frame()

        def x():
            return random.uniform(-1.5, 1.5)

        def y():
            return random.uniform(1.5, -1.5)

        pos_frame.ball = Ball(x=x(), y=y())
        factor = (pos_frame.ball.y / abs(pos_frame.ball.y))
        offset = 0.115 * factor
        angle = 270 if factor > 0 else 90
        pos_frame.robots_blue[0] = Robot(x=pos_frame.ball.x,
                                         y=pos_frame.ball.y + offset,
                                         theta=angle)
        shooter = np.array(
            [pos_frame.robots_blue[0].x, pos_frame.robots_blue[0].y])
        recv_x = x()
        while abs(recv_x - pos_frame.ball.x) < 1:
            recv_x = x()
        receiver = np.array([recv_x, -pos_frame.ball.y])
        vect = receiver - shooter
        recv_angle = np.rad2deg(np.arctan2(vect[1], vect[0]) + np.pi)

        pos_frame.robots_blue[1] = Robot(x=receiver[0],
                                         y=receiver[1],
                                         theta=recv_angle)

        return pos_frame
Exemplo n.º 2
0
    def _get_initial_positions_frame(self):
        '''Returns the position of each robot and ball for the initial frame'''
        half_len = self.field.length / 2
        half_wid = self.field.width / 2
        pen_len = self.field.penalty_length
        half_pen_wid = self.field.penalty_width / 2

        def x():
            return random.uniform(0.2, half_len - 0.1)

        def y():
            return random.uniform(-half_wid + 0.1, half_wid - 0.1)

        def theta():
            return random.uniform(0, 360)

        pos_frame: Frame = Frame()

        pos_frame.robots_blue[0] = Robot(x=0., y=0., theta=0.)

        def in_gk_area(obj):
            return obj.x > half_len - pen_len and abs(obj.y) < half_pen_wid

        pos_frame.ball = Ball(x=x(), y=y())
        while in_gk_area(pos_frame.ball):
            pos_frame.ball = Ball(x=x(), y=y())

        min_dist = 0.2

        places = KDTree()
        places.insert((pos_frame.ball.x, pos_frame.ball.y))
        places.insert((pos_frame.robots_blue[0].x, pos_frame.robots_blue[0].y))
        for i in range(self.n_robots_yellow):
            pos = (x(), y())
            while places.get_nearest(pos)[1] < min_dist:
                pos = (x(), y())

            places.insert(pos)
            pos_frame.robots_yellow[i] = Robot(x=pos[0],
                                               y=pos[1],
                                               theta=theta())

        return pos_frame
Exemplo n.º 3
0
    def _get_initial_positions_frame(self):
        '''Returns the position of each robot and ball for the initial frame'''
        # TODO

        pos_frame: Frame = Frame()

        pos_frame.ball = Ball(x=-0.1, y=0.)

        pos_frame.robots_blue[0] = Robot(x=0., y=0., theta=180.)

        pos_frame.robots_yellow[0] = Robot(x=self.node_0, y=0., theta=180.)
        pos_frame.robots_yellow[1] = Robot(x=self.node_1, y=0., theta=180.)
        pos_frame.robots_yellow[2] = Robot(x=self.node_2, y=0., theta=180.)
        pos_frame.robots_yellow[3] = Robot(x=self.node_3, y=0., theta=180.)

        return pos_frame
Exemplo n.º 4
0
    def _get_initial_positions_frame(self):
        '''Returns the position of each robot and ball for the initial frame'''
        half_len = self.field.length / 2
        half_wid = self.field.width / 2
        pen_len = self.field.penalty_length
        half_pen_wid = self.field.penalty_width / 2
        pos_frame: Frame = Frame()
        def x(): return random.uniform(pen_len, half_len - pen_len)
        def y(): return random.uniform(-half_pen_wid, half_pen_wid)
        
        pos_frame.robots_blue[0] = Robot(x=0, y=0, theta=0.)
        enemy_x = x()
        enemy_y = y()

        pos_frame.ball = Ball(x=enemy_x-0.1, y=enemy_y)
        pos_frame.robots_yellow[0] = Robot(x=enemy_x, y=enemy_y, theta=180.)

        return pos_frame
Exemplo n.º 5
0
    def _get_initial_positions_frame(self):
        '''Returns the position of each robot and ball for the initial frame'''
        field_half_length = self.field.length / 2
        field_half_width = self.field.width / 2

        def x():
            return random.uniform(-field_half_length + 0.1,
                                  field_half_length - 0.1)

        def y():
            return random.uniform(-field_half_width + 0.1,
                                  field_half_width - 0.1)

        def theta():
            return random.uniform(0, 360)

        pos_frame: Frame = Frame()

        pos_frame.ball = Ball(x=x(), y=y())

        min_dist = 0.1

        places = KDTree()
        places.insert((pos_frame.ball.x, pos_frame.ball.y))

        for i in range(self.n_robots_blue):
            pos = (x(), y())
            while places.get_nearest(pos)[1] < min_dist:
                pos = (x(), y())

            places.insert(pos)
            pos_frame.robots_blue[i] = Robot(x=pos[0], y=pos[1], theta=theta())

        for i in range(self.n_robots_yellow):
            pos = (x(), y())
            while places.get_nearest(pos)[1] < min_dist:
                pos = (x(), y())

            places.insert(pos)
            pos_frame.robots_yellow[i] = Robot(x=pos[0],
                                               y=pos[1],
                                               theta=theta())

        return pos_frame
Exemplo n.º 6
0
    def _get_initial_positions_frame(self):
        '''Returns the position of each robot and ball for the initial frame'''
        if self.random_init:
            half_len = self.field.length / 2
            half_wid = self.field.width / 2
            penalty_len = self.field.penalty_length

            def x():
                return random.uniform(0.3, half_len - penalty_len - 0.3)

            def y():
                return random.uniform(-half_wid + 0.1, half_wid - 0.1)

            def theta():
                return random.uniform(0, 360)
        else:

            def x():
                return self.field.length / 4

            def y():
                return self.field.width / 8

            def theta():
                return 0

        pos_frame: Frame = Frame()

        def same_position_ref(obj, ref, dist):
            if abs(obj.x - ref.x) < dist and abs(obj.y - ref.y) < dist:
                return True
            return False

        pos_frame.ball = Ball(x=x(), y=y())

        d_ball_rbt = (self.field.ball_radius + self.field.rbt_radius) * 1.1
        pos_frame.robots_blue[0] = Robot(x=x(), y=-y(), theta=theta())
        while same_position_ref(pos_frame.robots_blue[0], pos_frame.ball,
                                d_ball_rbt):
            pos_frame.robots_blue[0] = Robot(x=x(), y=y(), theta=theta())

        return pos_frame