Esempio n. 1
0
    def update(self, walls, acceleration, friction):
        # Move by a given acceleration
        self.move(Vector(acceleration[0], acceleration[1]))

        # Iterate through all walls
        # and check for collisions
        for wall in walls:
            # Don't check walls if
            # they're too far from
            # a particle
            wallToLine = vector.subtract(wall.start, self.position)
            if (vector.magnitude(wallToLine) > vector.magnitude(wall.line)):
                continue

            # If the returned value is
            # greater than 0, the ball
            # is colliding with the wall
            clipVal = self.intersectsWall(wall)

            if (clipVal > 0):
                # Move the particle out of the wall
                dPos = vector.multiply(wall.normal, clipVal)
                self.position.addVector(dPos)

                # Bounce the particle off of the wall
                self.velocity = self.getReflection(copy.copy(wall.normal))

                # Reduce the particle's velocity by
                # the friction coefficient
                self.velocity.scalarMultiply(friction)
Esempio n. 2
0
    def update(self, delta, all_boids, attractors, obstacles):
        """This is main function which figures out all the conditions and determine resultant change in the boid location per cycle. It calls all the function given above and find resultant change in location and applies it to the boid."""
        #start with determining nearby boids.
        self.determine_nearby_boids(all_boids)

        # obstacles = self.nearby_obj(objs, _MIN_OBSTACLE_DISTANCE)
        self.nearby_obj(obstacles, _MIN_OBSTACLE_DISTANCE)
        #initializing all the change vectors
        # cohesion_factor = self.average_position()
        # alignment_factor = self.average_velocity()
        # seperation_factor = self.avoid_collisions(self.neighbours, _BOID_COLLISION_DISTANCE)
        p = self.all_in_one()
        cohesion_factor = p[0]
        alignment_factor = p[1]
        seperation_factor = p[2]
        collision_factor = self.avoid_collisions(self.obj_nearby,
                                                 _MIN_OBSTACLE_DISTANCE)
        attraction_factor = self.attraction(attractors)
        bound_factor = self.know_bound()

        self.force_factors = [[_FACTOR_COHESION, cohesion_factor],
                              [_FACTOR_ALIGNMENT, alignment_factor],
                              [_FACTOR_BOID_AVOIDANCE, seperation_factor],
                              [_FACTOR_OBSTACLE_AVOID, collision_factor],
                              [_FACTOR_ATTRACT, attraction_factor],
                              [_FACTOR_BOUND, bound_factor]]
        # print(_FACTOR_COHESION)
        # print(cohesion_factor)
        # y = _FACTOR_COHESION*cohesion_factor[0]
        for x in self.force_factors:
            self.velocity[0] += x[1][0] * x[0]
            self.velocity[1] += x[0] * x[1][1] * 0.2
            self.velocity[2] += x[0] * x[1][2]

        velocity2 = vector.limit_magnitude(self.velocity, _SPEED_MAX,
                                           _SPEED_MIN, True)

        #changing the boids position in accordance with velocity.
        for i in range(0, len(self.position)):
            self.position[i] += delta * velocity2[i]
            # if (self.position[i] > self.bound[i]) or (self.position[i]< -self.bound[i]):
            # 	self.position[i] = -self.position[i]

        # for i in range(3):
        # 	if (self.position[i] > self.bound[i]) or (self.position[i]< -self.bound[i]):
        # 		self.position = vector.limit_magnitude(self.position, self.bound[i], -self.bound[i], True)

        self.force = self.mass * vector.magnitude(
            self.velocity[0] - velocity2[0], self.velocity[1] - velocity2[1],
            self.velocity[2] - velocity2[2]) / (self.dt * 50)
        self.velocity = velocity2
        cross = vector.cross(self.velocity, self.position)
        self.ang_mom = self.mass * vector.magnitude(cross[0], cross[1],
                                                    cross[2]) / 1000
        self.energy = self.mass * (vector.magnitude(
            self.velocity[0], self.velocity[1], self.velocity[2])**2) / 4000000
Esempio n. 3
0
    def update(self, step_time):
        def change_dir_vel(entities, direction, velocity):
            for entity in entities:
                entity.body.direction = direction
                entity.body.set_velocity(velocity)

        if (self.moving_left or self.moving_right):
            if self.moving_left:
                change_dir_vel(self.paddles, Vector2(-1, 0), PADDLE_VELOCITY)
                if self.game_status == GameLayer.INITIALIZATION:
                    change_dir_vel(self.balls, Vector2(-1, 0), PADDLE_VELOCITY)
            else:
                change_dir_vel(self.paddles, Vector2(1, 0), PADDLE_VELOCITY)
                if self.game_status == GameLayer.INITIALIZATION:
                    change_dir_vel(self.balls, Vector2(1, 0), PADDLE_VELOCITY)
        else:
            change_dir_vel(self.paddles, ZERO2, magnitude(ZERO2))
            if self.game_status == GameLayer.INITIALIZATION:
                change_dir_vel(self.balls, ZERO2, magnitude(ZERO2))

        if self.push_balls and self.game_status == GameLayer.INITIALIZATION:
            for ball in self.balls:
                if ball.body.is_static:
                    ball.body.is_static = False
            v = Vector2(BALL_VELOCITY_X, BALL_VELOCITY_Y)
            change_dir_vel(self.balls, normalize(v), magnitude(v))
            self.push_balls = False
            self.game_status = GameLayer.GAME_LOOP

        # Remove bricks that have been destroyed
        free_brick_list = []
        for brick in self.bricks:
            if brick.health_points == 0:
                self.unregister_entity(brick)
                free_brick_list.append(brick)
        self.bricks = [b for b in self.bricks if free_brick_list.count(b) == 0]

        for paddle in self.paddles:
            # Integrate paddle
            paddle.body.rect.position = sum(
                paddle.body.rect.position,
                mul(paddle.body.direction, paddle.body.velocity * step_time))

            # Relocate paddle position to a valid position range
            paddle.body.rect.position.x = utils.clamp(
                paddle.body.rect.position.x, 0, WINDOW_WIDTH - PADDLE_WIDTH)
            paddle.body.rect.position.y = WINDOW_HEIGHT - PADDLE_HEIGHT - PADDLE_LINE_SPACING

        for ball in self.balls:
            if ball.body.is_static:
                pos_r = Vector2((PADDLE_WIDTH - BALL_WIDTH) * 0.5,
                                -BALL_HEIGHT)
                ball.body.rect.position = sum(
                    self.paddles[0].body.rect.position, pos_r)
Esempio n. 4
0
    def update(self, step_time):
        def change_dir_vel(entities, direction, velocity):
            for entity in entities:
                entity.body.direction = direction
                entity.body.set_velocity(velocity)
           
        if(self.moving_left or self.moving_right):
            if self.moving_left:
                change_dir_vel(self.paddles, Vector2(-1,0), PADDLE_VELOCITY)
                if self.game_status == GameLayer.INITIALIZATION:
                    change_dir_vel(self.balls, Vector2(-1,0), PADDLE_VELOCITY)  
            else:
                change_dir_vel(self.paddles, Vector2(1,0), PADDLE_VELOCITY)
                if self.game_status == GameLayer.INITIALIZATION:
                    change_dir_vel(self.balls, Vector2(1,0), PADDLE_VELOCITY)    
        else:
            change_dir_vel(self.paddles, ZERO2, magnitude(ZERO2))
            if self.game_status == GameLayer.INITIALIZATION:
                change_dir_vel(self.balls, ZERO2, magnitude(ZERO2))
                    
        if self.push_balls and self.game_status == GameLayer.INITIALIZATION:                  
            for ball in self.balls:
                if ball.body.is_static:
                    ball.body.is_static = False
            v = Vector2(BALL_VELOCITY_X, BALL_VELOCITY_Y) 
            change_dir_vel(self.balls, normalize(v), magnitude(v))
            self.push_balls = False
            self.game_status = GameLayer.GAME_LOOP
             
        # Remove bricks that have been destroyed
        free_brick_list = []
        for brick in self.bricks:
            if brick.health_points == 0:
                self.unregister_entity(brick)
                free_brick_list.append(brick)
        self.bricks = [ b for b in self.bricks if free_brick_list.count(b) == 0 ] 
                
        for paddle in self.paddles:          
            # Integrate paddle
            paddle.body.rect.position = sum(paddle.body.rect.position,
                                            mul(paddle.body.direction, paddle.body.velocity * step_time))
    
            # Relocate paddle position to a valid position range
            paddle.body.rect.position.x = utils.clamp(paddle.body.rect.position.x, 0, 
                                                      WINDOW_WIDTH - PADDLE_WIDTH)
            paddle.body.rect.position.y = WINDOW_HEIGHT - PADDLE_HEIGHT - PADDLE_LINE_SPACING

        for ball in self.balls:
            if ball.body.is_static:
                pos_r = Vector2((PADDLE_WIDTH - BALL_WIDTH) * 0.5,  - BALL_HEIGHT)
                ball.body.rect.position = sum(self.paddles[0].body.rect.position, pos_r)
Esempio n. 5
0
 def set_velocity(self, velocity):
     magnitude = V.magnitude(velocity)
     # Limit velocity to prevent the body from escaping its borders
     if magnitude > self.maximum_speed:
         velocity *= self.maximum_speed / magnitude
     velocity = V.address_data(velocity)
     self.velocity[:] = velocity
Esempio n. 6
0
    def avoid_collisions(self, objs, collision_distance):
        # determine nearby objs using distance only
        nearby_objs = (obj for obj in objs if (
            obj != self and vector.magnitude(
                obj.position[0] - self.position[0], obj.position[1] -
                self.position[1]) - self.size <= collision_distance))

        c = [0.0, 0.0]
        for obj in nearby_objs:
            diff = obj.position[0] - self.position[0], obj.position[
                1] - self.position[1]
            inv_sqr_magnitude = 1 / ((vector.magnitude(*diff) - self.size)**2)

            c[0] = c[0] - inv_sqr_magnitude * diff[0]
            c[1] = c[1] - inv_sqr_magnitude * diff[1]
        return vector.limit_magnitude(c, MAX_COLLISION_VELOCITY)
    def circle_circle(bodies, resolve=True):
        restitution = max(bodies[0].body_restitution,
                          bodies[1].body_restitution)

        position_0 = bodies[0].position
        position_1 = bodies[1].position
        total_radius = bodies[0].radius + bodies[1].radius

        # 两个物体的距离如果没有相交,则返回false
        direction = position_0 - position_1
        distance = V.magnitude(direction)
        if distance <= 0.0 or distance >= (total_radius):
            return False

        # 两个物体的距离如果相交
        # 计算单位方向向量
        normal = V.normalize(direction)
        penetration = total_radius - distance

        if resolve:
            Collision._resolve_circle_circle_velocity(bodies, normal,
                                                      restitution)
            Collision._resolve_circle_circle_interpenetration(
                bodies, normal, penetration)

        return True
Esempio n. 8
0
 def __init__(self, rect, velocity, object_type, tag_ent, is_static=True):
     self.rect = rect
     self.set_velocity(vector.magnitude(velocity))
     self.direction = vector.normalize(velocity)
     self.object_type = object_type
     self.is_static = is_static
     self.tag_ent = tag_ent
Esempio n. 9
0
 def determine_nearby_boids(self, all_boids):
     for boid in all_boids:
         diff = (boid.position[0] - self.position[0],
                 boid.position[1] - self.position[1])
         if (boid != self and vector.magnitude(*diff) <= BOID_RANGE
                 and vector.angle_between(self.velocity,
                                          diff) <= BOID_VIEW_ANGLE):
             yield boid
Esempio n. 10
0
 def nearby_obj(self, objs, _MIN_OBSTACLE_DISTANCE):
     """It takes a list of predators and a safe distance from it and update the list of nearby objects in it."""
     self.obj_nearby = [
         obj for obj in objs
         if (vector.magnitude(obj.position[0] -
                              self.position[0], obj.position[1] -
                              self.position[1], obj.position[2] -
                              self.position[2]) <= _MIN_OBSTACLE_DISTANCE)
     ]
Esempio n. 11
0
 def determine_nearby_boids(self, all_boids):
     """This function takes a list of boids as input update neighbours list of boids. It also takes field of view into consideration."""
     if (len(all_boids) > 0):
         (self.neighbours).clear()
         for boid in all_boids:
             diff = (boid.position[0] - self.position[0],
                     boid.position[1] - self.position[1],
                     boid.position[2] - self.position[2])
             if (boid != self and vector.magnitude(*diff) <= _RANGE_OF_BOID
                     and vector.angle_between(self.velocity,
                                              diff) <= _VIEW_ANGLE):
                 (self.neighbours).append(boid)
    def circle_line(body, line, screen=None):
        # 计算circle与直线最近的点
        relative_position = body.position - line.p1
        projected_vector = line.direction * relative_position.dot(
            line.direction)
        closest_point = line.p1 + projected_vector

        # 记录参数
        cx, cy = closest_point
        lx1, ly1 = line.p1
        lx2, ly2 = line.p2

        # Make sure that closest point lies on the line
        if lx1 - lx2 > 0:
            cx = max(min(cx, lx1), lx2)
        else:
            cx = min(max(cx, lx1), lx2)
        if ly1 - ly2 > 0:
            cy = max(min(cy, ly1), ly2)
        else:
            cy = min(max(cy, ly1), ly2)
        closest_point[:] = cx, cy

        distance = V.magnitude(body.position - closest_point)

        collided = distance < body.radius
        if collided:
            # Resolve interpenetration
            orthogonal_vector = relative_position - projected_vector
            penetration = body.radius - V.magnitude(orthogonal_vector)
            disposition = V.normalize(orthogonal_vector) * penetration
            body.position += disposition

            # Resolve Velocity
            velocity = body.get_velocity() - line.normal * body.get_velocity(
            ).dot(line.normal) * (1 + body.wall_restitution)
            body.set_velocity(velocity)

        return collided
Esempio n. 13
0
    def avoid_collisions(self, objs, collision_distance):
        """This takes list of objects nearby it and determines how much boid should change direction to avoid collission with them."""
        c = [0.0, 0.0, 0.0]
        for obj in objs:
            diff = obj.position[0] - self.position[0], obj.position[
                1] - self.position[1], obj.position[2] - self.position[2]
            inv_sqr_magnitude = 1 / (
                (vector.magnitude(*diff) - self.size[0])**2)

            c[0] = c[0] - inv_sqr_magnitude * diff[0]
            c[1] = c[1] - inv_sqr_magnitude * diff[1]
            c[2] = c[2] - inv_sqr_magnitude * diff[2]
        return vector.limit_magnitude(c, _COLLISION_VELOCITY_MAX)
Esempio n. 14
0
    def all_in_one(self):
        if len(self.neighbours) > 0:
            c = [0.0, 0.0, 0.0]
            sum_x, sum_y, sum_z = 0.0, 0.0, 0.0
            sum_x1, sum_y1, sum_z1 = 0.0, 0.0, 0.0
            for boid in self.neighbours:
                sum_x += boid.position[0]
                sum_y += boid.position[1]
                sum_z += boid.position[2]

                sum_x1 += boid.velocity[0]
                sum_y1 += boid.velocity[1]
                sum_z1 += boid.velocity[2]

                diff = boid.position[0] - self.position[0], boid.position[
                    1] - self.position[1], boid.position[2] - self.position[2]
                inv_sqr_magnitude = 1 / (
                    (vector.magnitude(*diff) - self.size[0])**4)
                c[0] = c[0] - inv_sqr_magnitude * diff[0]
                c[1] = c[1] - inv_sqr_magnitude * diff[1]
                c[2] = c[2] - inv_sqr_magnitude * diff[2]
            average_x, average_y, average_z = (sum_x / len(self.neighbours),
                                               sum_y / len(self.neighbours),
                                               sum_z / len(self.neighbours))
            out = [[
                average_x - self.position[0], average_y - self.position[1],
                average_z - self.position[2]
            ]]

            average_x, average_y, average_z = (sum_x1 / len(self.neighbours),
                                               sum_y1 / len(self.neighbours),
                                               sum_z1 / len(self.neighbours))
            out.append([
                average_x - self.position[0], average_y - self.position[1],
                average_z - self.position[2]
            ])
            out.append(vector.limit_magnitude(c, _COLLISION_VELOCITY_MAX,
                                              True))
            return out
        else:
            return [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]]
Esempio n. 15
0
    def intersectsWall(self, wall1):
        # Get the directional vector
        # representing the wall
        wallDir = vector.normalize(wall1.line)

        # Get the length of the line
        # from the start of the wall
        # to the nearest point to the ball
        projectedMag = vector.dot(wallDir, vector.subtract(self.position, wall1.start))

        # Scale the directional vector
        # by the projected magnitude
        wallDir.scalarMultiply(projectedMag)

        # Get the line between the
        # ball and the nearest point on the wall
        wallToBall = vector.subtract(vector.add(wallDir, wall1.start), self.position)

        # Return the amount the wall
        # is intersecting with the ball
        return self.size - vector.magnitude(wallToBall)
Esempio n. 16
0
    def buildObject(self, newComp):

        # Create a new sketch.
        sketches = newComp.sketches
        xyPlane = newComp.xYConstructionPlane
        sketch0 = sketches.add(xyPlane)

        circles = sketch0.sketchCurves.sketchCircles

        p0 = adsk.core.Point3D.create(0, 0, 0)

        # create beam profile
        if self._outer_d > 0:
            circles.addByCenterRadius(p0, self._outer_d / 2.0)  # outer circle
        if self._inner_d > 0:
            circles.addByCenterRadius(p0, self._inner_d / 2.0)  # inner circle

        if self.length != 0:
            distance = adsk.core.ValueInput.createByReal(self.length)
            prof = sketch0.profiles.item(0)
            # mm150 = adsk.core.ValueInput.createByString("150 mm")
            # mm0 = adsk.core.ValueInput.createByString("0 mm")
            extrudes = newComp.features.extrudeFeatures
            extrudeInput = extrudes.createInput(
                prof, adsk.fusion.FeatureOperations.NewBodyFeatureOperation)
            distanceDefinition = adsk.fusion.DistanceExtentDefinition.create(
                distance)
            extrudeInput.setOneSideExtent(
                distanceDefinition,
                adsk.fusion.ExtentDirections.PositiveExtentDirection)
            obj = extrudes.add(extrudeInput)
            if obj.bodies.count > 0:
                body = obj.bodies.item(0)
                body.name = "Konecne"
            obj.name = "myTube"
            obj.partNumber = "xyss75478"

            # Create a collection of entities for move
            bodies = adsk.core.ObjectCollection.create()
            bodies.add(obj.bodies.item(0))

            # Create a transform to do move
            move_vector = adsk.core.Vector3D.create(self.start_position[0],
                                                    self.start_position[1],
                                                    self.start_position[2])

            vec = vector.create(self.start_position, self.end_position)
            vec_length = vector.magnitude(vec)

            beam_vector = adsk.core.Vector3D.create(vec[0], vec[1], vec[2])
            start_vector = adsk.core.Vector3D.create(0, 0, 1)
            beam_vector.normalize()

            # radial distance
            transform = adsk.core.Matrix3D.create()
            transform.setToRotateTo(start_vector, beam_vector)
            moveFeats = newComp.features.moveFeatures
            moveFeatureInput = moveFeats.createInput(bodies, transform)
            moveFeats.add(moveFeatureInput)

            if move_vector.length != 0:
                transform = adsk.core.Matrix3D.create()
                transform.translation = move_vector
                moveFeats = newComp.features.moveFeatures
                moveFeatureInput = moveFeats.createInput(bodies, transform)
                moveFeats.add(moveFeatureInput)
Esempio n. 17
0
print(result_vec_sum)

# умножение вектора на скаляр
result_vec_dist = vector.scalar_multiply(scalar, grades)
print(result_vec_dist)

# покомпонентное среднее значение списка векторов
result_vec_mean = vector.vector_mean(A)
print(result_vec_mean)

# скалярное произведение
result_dot = vector.dot(height_weight_age, grades)
print(result_dot)

# сумма квадратов вектора
result_sum_of_squares = vector.sum_of_squares(grades)
print(result_sum_of_squares)

# длина вектора
result_magnitude = vector.magnitude(grades)
print(result_magnitude)

# квадрат растояния между двумя векторами
result_squared_distance = vector.squared_distance(grades, height_weight_age)
print(result_squared_distance)

# растояние между двумя векторами
result_distance = vector.distance(grades, height_weight_age)
print(result_distance)

Esempio n. 18
0
# assertions.py

from vector import (add, subtract, vector_sum, scalar_multiply, vector_mean,
                    dot, sum_of_squares, magnitude, distance)

from matrices import shape, identity_matrix, get_column, get_row, make_matrix

# Vector
assert add([1, 2, 3], [4, 5, 6]) == [5, 7, 9]
assert subtract([5, 7, 9], [4, 5, 6]) == [1, 2, 3]
assert vector_sum([[1, 2], [3, 4], [5, 6], [7, 8]]) == [16, 20]
assert scalar_multiply(2, [1, 2, 3]) == [2, 4, 6]
assert vector_mean([[1, 2], [3, 4], [5, 6]]) == [3, 4]
assert dot([1, 2, 3], [4, 5, 6]) == 32  # 1 * 4 + 2 * 5 + 3 * 6
assert sum_of_squares([1, 2, 3]) == 14  # 1 * 1 + 2 * 2 + 3 * 3
assert magnitude([3, 4]) == 5

# Matrices
assert shape([[1, 2, 3], [4, 5, 6]]) == (2, 3)  # 2 rows, 3 columns
assert identity_matrix(5) == [[1, 0, 0, 0, 0], [0, 1, 0, 0,
                                                0], [0, 0, 1, 0, 0],
                              [0, 0, 0, 1, 0], [0, 0, 0, 0, 1]]
Esempio n. 19
0
    def step(self,
             robot_action=None,
             human_action=None,
             debug=False,
             n_steps=4):

        dt = 0.25  # dt is randomly in interval [1, 2)
        time_iter = dt * n_steps

        # 记录上一步的游戏状态
        past_bottom_pos = self.bottom_mallet.get_position()

        # 如果输入参数是None,就使用AI move
        if robot_action is None:
            if self.use_object['puck']:
                # robot_action = self.bottom_ai.move()
                robot_action = [0, 0]
            else:
                robot_action = [0, 0]
        if human_action is None:
            if self.use_object['top_mallet']:
                human_action = self.top_ai.move()
                # human_action = [0, 0]
            elif not self.use_object['puck']:
                human_action = [0, 0]
            else:
                human_action = [0, 0]

        self.bot_mallet_motion.set_motion(robot_action)
        self.top_mallet_motion.set_motion(self.top_ai.move())
        # self.bottom_ai_motion.update_motion(robot_action)

        # 用数组来储存n_steps循环中
        # puck_was_hit 和 border_was_hit 和 scored 的值

        n_puck_was_hit = np.zeros(n_steps, dtype=np.float32)
        n_hit_the_border = np.zeros(n_steps, dtype=np.float32)
        n_score_flag = np.zeros(n_steps, dtype=np.float32)

        for k in range(n_steps):

            # Clear forces from last frame
            for body in self.bodies:
                body.clear_accumulated_v()

            self.motions.update_motions()

            # Move bodies
            for body in self.bodies:
                body.speed_position_update(dt)

            # Check collisions between all possible pairs of bodies
            if self.use_object['top_mallet']:
                Collision.circle_circle([self.puck, self.top_mallet])

            Collision.circle_circle([self.top_mallet, self.bottom_mallet])

            if self.use_object['puck']:
                n_puck_was_hit[k] = bool(
                    Collision.circle_circle([self.puck, self.bottom_mallet]))
            else:
                n_puck_was_hit[k] = False

            in_the_target = Collision.circle_circle(
                [self.bottom_mallet, self.bottom_target], resolve=False)

            # Make sure all bodies are within their borders
            collided = [False, False, False]
            for i, body in enumerate(self.bodies):
                for border in body.borders:
                    if Collision.circle_line(body, border):
                        collided[i] = True
            n_hit_the_border[k] = collided[2]

            puck_is_at_the_bottom = self.puck.position[1] > self.dim.center[1]

            distance_decreased = False
            if puck_is_at_the_bottom:
                distance = V.magnitude(self.puck.position -
                                       self.bottom_mallet.position)
                distance_decreased = distance < self.distance
                self.distance = distance
            else:
                self.distance = P.max_distance

            _, n_score_flag[k] = self.score.update(self.puck)

        puck_position = self.puck.get_position()
        puck_velocity = V.address_data(self.puck.get_velocity())
        bottom_mallet_position = self.bottom_mallet.get_position()
        bottom_mallet_velocity = V.address_data(
            self.bottom_mallet.get_velocity())
        for i in range(len(past_bottom_pos)):
            if np.linalg.norm(past_bottom_pos[i] -
                              self.bottom_mallet.get_position()[i]) < 1e-5:
                bottom_mallet_velocity[i] = 0
            else:
                pass
        top_mallet_position = self.top_mallet.get_position()
        top_mallet_velocity = V.address_data(self.top_mallet.get_velocity())
        puck_was_hit = np.any(n_puck_was_hit == 1)
        hit_the_border = np.any(n_hit_the_border == 1)

        scored = None
        score_flag = 0
        if np.any(n_score_flag == 1):
            score_flag = 1
            self.score.add_bottom()
            scored = 'bottom'
        elif np.any(n_score_flag == -1):
            score_flag = -1
            self.score.add_top()
            scored = 'top'

        puck_position_mode = bool(
            self.dim.center[1] <= puck_position[1] <= self.dim.rink_bottom)
        game_info = GameInfo([], puck_position, puck_velocity,
                             bottom_mallet_position, bottom_mallet_velocity,
                             top_mallet_position, top_mallet_velocity,
                             robot_action, human_action, scored, score_flag,
                             puck_was_hit, puck_is_at_the_bottom,
                             distance_decreased, hit_the_border, in_the_target,
                             time_iter, puck_position_mode)

        return game_info