Example #1
0
def plane_reader(properties):
    plane = Plane()
    for prop in properties:
        prop = prop.strip()
        props = prop.split(' ')
        if props[0] == 'pos:':
            plane.pos = vector.vec(float(props[1]), float(props[2]),
                                   -float(props[3]))
            continue
        if props[0] == 'nor:':
            plane.norm = vector.vec(float(props[1]), float(props[2]),
                                    float(props[3]))
            continue
        if props[0] == 'amb:':
            plane.amb = vector.vec(float(props[1]), float(props[2]),
                                   float(props[3]))
            continue
        if props[0] == 'dif:':
            plane.dif = vector.vec(float(props[1]), float(props[2]),
                                   float(props[3]))
            continue
        if props[0] == 'spe:':
            plane.spe = vector.vec(float(props[1]), float(props[2]),
                                   float(props[3]))
            continue
        if props[0] == 'shi:':
            plane.shine = float(props[1]) / 10
    return plane
Example #2
0
def test_Line2d_tangent_and_normal():
    p0 = vec(0, 0)
    p1 = vec(2, 1)
    l = Line2d(p0, p1.rotate(90))
    t = l.unit_tangent()
    n = l.unit_normal()
    (l.hvplot() * t.hvplot(color='r') * n.hvplot(color='g'))
Example #3
0
    def __init__(self, x, y, game):  #
        """Параметры:
		Начальное местоположение по осям X и Y
		Cсылка на игру, в которой находится игрок"""
        super().__init__()  # Конструирование базового класса
        self.frames = (
            pg.image.load("./images/ball0.png"),
            pg.image.load("./images/ball1.png"),
            pg.image.load("./images/ball2.png"),
            pg.image.load("./images/ball3.png"),
            pg.image.load("./images/ball4.png"),
            pg.image.load("./images/ball5.png"),
            pg.image.load("./images/ball6.png"),
            pg.image.load("./images/ball7.png")
        )  # Загружаем в кортеж с кадрами все изображения для анимации
        self.current_frame = 0  # Индекс текущего кадра анимации
        self.last_update = pg.time.get_ticks(
        )  # Время последней смены кадра; Изначально равен моменту создания игрока
        self.image = self.frames[
            self.
            current_frame]  # Текущее изображение из кортежа кадров по текущему индексу
        self.rect = self.image.get_rect()  # Взятие прямоугольника
        self.rect.center = (x, y)  # Задание координат центра
        self.vel = vec(0, 0)  # Вектор скоростей
        self.acc = vec(0, 0)  # Вектор ускорений
        self.pos = vec(x, y)  # Вектор местоположения игрока
        self.game = game  # Сохранене ссылки на игру
        self.on_ground = False  # Изначально не на земле
Example #4
0
def sphere_reader(properties):
    sphere = Sphere()
    for prop in properties:
        prop = prop.strip()
        props = prop.split(' ')
        if props[0] == 'pos:':
            sphere.pos = vector.vec(float(props[1]), float(props[2]),
                                    -float(props[3]))
            continue
        if props[0] == 'rad:':
            sphere.rad = float(props[1])
            continue
        if props[0] == 'amb:':
            sphere.amb = vector.vec(float(props[1]), float(props[2]),
                                    float(props[3]))
            continue
        if props[0] == 'dif:':
            sphere.dif = vector.vec(float(props[1]), float(props[2]),
                                    float(props[3]))
            continue
        if props[0] == 'spe:':
            sphere.spe = vector.vec(float(props[1]), float(props[2]),
                                    float(props[3]))
            continue
        if props[0] == 'shi:':
            sphere.shine = float(props[1]) / 5
    return sphere
Example #5
0
def test_Line2d_constructor_1():
    p0 = vec(0, 0)
    p1 = vec(2, 1)
    l = Line2d(p0, p1)
    overlay = (l.hvplot() * p0.hvplot(color='b', size=10) *
               p1.hvplot(color='r', size=10) *
               p1.rotate(90).hvplot(color='g', size=10))
    display(overlay)
Example #6
0
 def areaLight(self):
     global lights
     lights.append(
         Light(
             vector.vec(self.position.x + 0.5, self.position.y + 0.5,
                        self.position.z + 0.5), self.colour))
     lights.append(
         Light(
             vector.vec(self.position.x - 0.5, self.position.y - 0.5,
                        self.position.z - 0.5), self.colour))
Example #7
0
def test_Line2d_get_normal_band_2():
    from shapely.geometry import Polygon

    p0 = vec(0, 0)
    p1 = vec(2, 1)

    l = Line2d(p0, p1)
    band = l.get_normal_band(1)
    overlay = (l.hvplot() * l.unit_normal().hvplot(color='r', size=10) *
               hv.Polygons([Polygon(band)]).opts(alpha=0.1))
    display(overlay)
Example #8
0
 def __init__(self, surface, img):
     pygame.sprite.Sprite.__init__(self)
     self.surface = surface
     self.image = img
     # rect = self.image.get_rect()
     # pygame.draw.rect(self.image,(0, 0, 255),(0, 0, rect.width-1,rect.height -1),1)
     self.rect = self.image.get_rect()
     self.vel = vec(0, 0)
     self.acc = vec(0, 0)
     width, height = self.surface.get_size()
     self.pos = vec(width / 2, height - HEIGHT - 10)
     self.rect.center = self.pos
Example #9
0
def sdEquilateralTriangle(query):
    """
    Signed distance function for a unit length equilateral triangle centered at the origin
    """
    if len(query) != 2:
        raise ValueError(f"Input vector must be 2-dimensional: {len(query)}")
    k = 3**.5
    query = vec(np.abs(query[0]) - 1.0, query[1] + 1.0/k)
    
    if query[0] + k*query[1] > 0.:
        query = vec(query[0] - k*query[1], -k*query[0]-query[1])/2.
    query[0] -= np.clip(query[0], -2., 2.)
    return - query.norm()*np.sign(query[1])
Example #10
0
 def __init__(self,
              pos=None,
              norm=None,
              amb=None,
              dif=None,
              spe=None,
              shine=None):
     self.pos = pos or vector.vec(0, 0, 0)
     self.norm = norm or 0
     self.amb = amb or vector.vec(0, 0, 0)
     self.dif = dif or vector.vec(0, 0, 0)
     self.spe = spe or vector.vec(0, 0, 0)
     self.shine = shine or 0
     self.bounce = 0
Example #11
0
def light_reader(properties):
    global lights
    light = Light()
    for prop in properties:
        prop = prop.strip()
        props = prop.split(' ')
        if props[0] == 'pos:':
            light.position = vector.vec(float(props[1]), float(props[2]),
                                        -float(props[3]))
            continue
        if props[0] == 'col:':
            light.colour = vector.vec(float(props[1]), float(props[2]),
                                      float(props[3]))
    return light
Example #12
0
def test_iteration_small():
    N = 31
    a = vec(range(N))
    b = 0
    for i in a:
        b += i
    assert b == N * (N - 1) / 2
Example #13
0
 def __init__(self, game):
     self._layer = PLAYER_LAYER
     self.groups = game.all_sprites
     pg.sprite.Sprite.__init__(self, self.groups)
     self.game = game
     self.walking = False
     self.jumping = False
     self.current_frame = 0
     self.last_update = 0
     self.load_images()
     self.image = self.standing_frames[0]
     self.rect = self.image.get_rect()
     self.rect.center = (40, HEIGHT - 100)
     self.pos = vec(40, HEIGHT - 100)
     self.vel = vec(0, 0)
     self.acc = vec(0, 0)
Example #14
0
def test_count():
    ll = [1, 2, 2, 3, 3, 3]
    shuffle(ll)
    a = vec(ll)
    assert a.count(1) == ll.count(1)
    assert a.count(2) == ll.count(2)
    assert a.count(3) == ll.count(3)
    assert a.count('a') == ll.count('a')
Example #15
0
def test_cons():
    # Like list.append, except returns new vector w/ structural sharing.
    v0 = vec()
    assert len(v0) == 0
    v1 = v0.cons(1)
    assert len(v0) == 0
    assert len(v1) == 1
    assert v1[0] == 1
Example #16
0
def test_cons_128():
    N = 128
    v = vec()
    for i in range(N):
        v = v.cons(i)
    assert len(v) == N
    for i in range(N):
        assert v[i] == i
Example #17
0
def test_cons_1048576():
    N = 1048576
    v = vec()
    for i in xrange(N):
        v = v.cons(i)
    assert len(v) == N
    for i in xrange(N):
        assert v[i] == i
Example #18
0
def test_index():
    ll = range(20)
    shuffle(ll)
    v = vec(ll)
    for i in ll:
        assert ll.index(i) == v.index(i)
    with pytest.raises(ValueError):
        v.index(30)
Example #19
0
	def __mul__(self, other):
		if type(other) == type(self):
			return quat((self.s*other.s)-(self.v*other.v),
						(self.s*other.v)+(self.v*other.s)+(self.v^other.v))
		if type(other) == type(vec(0,0,0)):
			return self*quat(0,other)
		else:
			return quat(other*self.s, other*self.v)
Example #20
0
def eval_sdf(xs, ys, sdFunc):
    zz = np.empty( (len(ys), len(xs)) )
    
    for j in range(len(ys)):
        for i in range(len(xs)):
            q = vec(xs[i],ys[j])
            zz[j,i] = sdFunc(q)
    return zz
Example #21
0
 def generate_speed(
         self,
         direction):  # Генерация скорости движения на основе направления
     if isinstance(direction, str):  # Проверяем что направление - строка
         vel = vec(0, 0)  # Заготовка вектора скорости
         if direction == "up":
             vel = vec(0, -SAW_SPEED)
         elif direction == "down":
             vel = vec(0, SAW_SPEED)
         elif direction == "left":
             vel = vec(-SAW_SPEED, 0)
         elif direction == "right":
             vel = vec(SAW_SPEED, 0)
         else:  # Если направление не одно и четырёх, оно неверное; ValueError
             raise ValueError("Invalid direction")
         return vel  # Возвращаем полученную скорость
     else:  # Иначе TypeError
         raise TypeError("Direction must be str")
Example #22
0
 def check_collision(self, target):
     lowest_ticks = 99999
     lowest_ticks_rotation = 0
     if target is not None:
         for rotation, missile_orbit in self.own_missile_orbits.items():
             for tick in range(len(missile_orbit)):
                 if self.target_orbit[target][tick] == vec(
                         0, 0) or missile_orbit[tick] == vec(0, 0):
                     continue
                 if (self.target_orbit[target][tick] -
                         missile_orbit[tick]).t_length() <= 0.1:
                     ticks = tick + math.ceil(abs(rotation) / 10)
                     if ticks < lowest_ticks:
                         lowest_ticks = ticks
                         lowest_ticks_rotation = rotation
     if lowest_ticks != 99999:
         return lowest_ticks, lowest_ticks_rotation
     else:
         return None, None
Example #23
0
def test_assoc():
    # TODO: FIXME: test with a big vector, bigger than 32, 32**2, 32**3, etc...
    a = vec(range(31))
    b = a.assoc(0, 10)
    assert a[0] == 0
    assert b[0] == 10
    assert a[1] == b[1]
    assert a[2] == b[2]
    c = b.assoc(1, 5)
    assert c[1] == 5
Example #24
0
def test_slice():
    ll = range(20)
    l2 = ll[5:10]
    v = vec(ll)
    v2 = v[5:10]
    assert len(l2) == len(v2)
    for a, b in zip(l2, v2):
        assert a == b
    with pytest.raises(NotImplementedError):
        v[::2]
Example #25
0
def sdStar(query, radius, n, m):
    """
    Args:
    - query (vec)
    - radius (float)
    - n (int)
    - m (float)
    """
    # Next 4 lines can be precomputed for a given shape
    an = np.pi/float(n)
    en = 2*np.pi/m
    acs = vec(np.cos(an), np.sin(an))
    ecs = vec(np.cos(en), np.sin(en))
    
    bn = np.mod(np.arctan2(*query.values), 2.0*an) - an
    query = query.norm() * vec(np.cos(bn), np.abs(np.sin(bn)))
    query = query - radius*acs
    query = query + ecs * np.clip(- query.inner(ecs), 0.0, radius*acs[1]/ecs[1])
    return query.norm() * np.sign(query[0])
Example #26
0
    def get_movement(self, number_of_ticks):

        positions = []
        # Initial conditions
        pos = self.position
        vel = self.velocity
        energy = self.energy
        is_dead = False
        for t in range(number_of_ticks):
            if energy <= 0 or is_dead:
                positions.append(vec(0, 0))
                continue

            angle = pos.atan2()

            if pos.length() < 0.1:
                is_dead = True
                positions.append(vec(0,0))
                continue

            force = pos.length() / energy
            vel.x -= cos(angle) * force
            vel.y -= sin(angle) * force

            if vel.x > 0.05: vel.x = 0.05
            if vel.y > 0.05: vel.y = 0.05
            if vel.x < -0.05: vel.x = -0.05
            if vel.y < -0.05: vel.y = -0.05

            pos += vel
            energy -= 1

            if pos.x > 1.0: pos.x = -1.0
            elif pos.x < -1.0: pos.x = 1.0
            if pos.y > 1.0: pos.y = -1.0
            elif pos.y < -1.0: pos.y = 1.0

            positions.append(pos)

        return positions
Example #27
0
    def update(self):
        # Задание ускорения вначале такта
        self.acc = vec(0, PLAYER_GRAVITY
                       )  # По оси Y воздействует ускорение свободного падения

        self.control_processing()

        self.physical_calculations()
        self.collide_processing()
        self.rect.center = self.pos  # Перемещение изображения в местоположение игрока

        self.wall_processing()
        self.animate()
Example #28
0
 def check_collision(self, target):
     lowest_ticks = 99999
     lowest_ticks_rotation = 0
     if target is not None:
         for rotation, missile_orbit in self.own_missile_orbits.items():
             for tick in range(len(missile_orbit)):
                 if self.target_orbit[target][tick] == vec(0, 0) or missile_orbit[tick] == vec(0,0):
                     continue
                 if (self.target_orbit[target][tick] - missile_orbit[tick]).t_length() <= 0.1:
                     ticks = tick + math.ceil(abs(rotation) / 10)
                     if ticks < lowest_ticks:
                         lowest_ticks = ticks
                         lowest_ticks_rotation = rotation
     if lowest_ticks != 99999:
         return lowest_ticks, lowest_ticks_rotation
     else:
         return None, None
Example #29
0
    def move(self, label):
        self.acc = vec(0, 0)
        if label == pygame.K_LEFT:
            self.acc.x = -BASKET_ACC
        if label == pygame.K_RIGHT:
            self.acc.x = BASKET_ACC

        self.acc += self.vel * (-BASKET_FRICTION)
        self.vel += self.acc
        self.pos += (self.vel + 0.5 * self.acc)
        # print(self.acc, self.vel, self.pos)

        screenSize = self.surface.get_size()
        if self.pos.x < self.rect.width / 2: self.pos.x = self.rect.width / 2
        if self.pos.x > screenSize[0] - self.rect.width / 2:
            self.pos.x = screenSize[0] - self.rect.width / 2

        self.rect.center = self.pos
Example #30
0
def camera_reader(properties):
    camera = Camera()
    for prop in properties:
        prop = prop.strip()
        props = prop.split(' ')
        if props[0] == 'pos:':
            camera.pos = vector.vec(float(props[1]), float(props[2]),
                                    (float(props[3])) - 1)
            continue
        if props[0] == 'f:':
            camera.focal_length = (float(props[1]))
            continue
        if props[0] == 'fov:':
            camera.fov = (2 * numpy.pi / 360 * float(props[1])
                          )  # values[0] == fov
            continue
        if props[0] == 'a:':
            camera.ratio = (float(props[1]))  # values[1] == aspect ratio
    return camera
Example #31
0
    def update(self):
        self.animate()
        self.acc = vec(0, PLAYER_GRAV)
        keys = pg.key.get_pressed()
        if keys[pg.K_LEFT]:
            self.acc.x = -PLAYER_ACC
        if keys[pg.K_RIGHT]:
            self.acc.x = PLAYER_ACC

        # apply friction
        self.acc.x += self.vel.x * PLAYER_FRICTION
        # equations of motion
        self.vel += self.acc
        if abs(self.vel.x) < 0.1:
            self.vel.x = 0
        self.pos += self.vel + 0.5 * self.acc
        # wrap around the sides of the screen
        if self.pos.x > WIDTH + self.rect.width / 2:
            self.pos.x = 0 - self.rect.width / 2
        if self.pos.x < 0 - self.rect.width / 2:
            self.pos.x = WIDTH + self.rect.width / 2

        self.rect.midbottom = self.pos
Example #32
0
def test_sdLine():
    q = vec(1.,0.)
    a = vec(0., 0.)
    b = vec(1.0, 0.)
    
    assert np.isclose([sdLine(q,a,b)], [0])
Example #33
0
def test_indexing_pos():
    v = vec([1, 2, 3])
    assert v[0] == 1
    assert v[1] == 2
    assert v[2] == 3
Example #34
0
    def get_movement(self, number_of_ticks):

        positions = []
        # Initial conditions
        pos = self.position
        vel = self.velocity
        energy = self.energy
        rotation = self.rotation
        is_dead = False
        for t in range(number_of_ticks):
            if is_dead:
                positions.append(vec(0, 0))
                continue
            elif pos.length() < 0.1:
                is_dead = True
                positions.append(vec(0, 0))
                continue

            if vel.length() > MISSILE_MAX_SPEED:
                velocityAngle = vel.atan2()
                vel.x = cos(velocityAngle) * MISSILE_MAX_SPEED
                vel.y = sin(velocityAngle) * MISSILE_MAX_SPEED

            # Force only depends on distance from the sun
            force = pos.length() / 1000
            angle = pos.atan2()
            vel.x -= cos(angle) * force
            vel.y -= sin(angle) * force

            pos += vel

            if pos.x > 1.0: pos.x = -1.0
            elif pos.x < -1.0: pos.x = 1.0
            if pos.y > 1.0: pos.y = -1.0
            elif pos.y < -1.0: pos.y = 1.0

            positions.append(pos)

            # Always point in the right direction
            if self.type == "NORMAL":
                rotation = vel.atan2()

            # Might be a bug. Logically, this should be before pos+=vel
            if energy < 10:
                vel /= 1.01
                continue

            if self.type == "MINE":
                vel.x += cos(rotation) * 0.0005
                vel.y += sin(rotation) * 0.0005
                energy -= 1
                continue

            energy -= 50

            if self.type == "NORMAL":
                vel.x += cos(rotation) * (energy / 1000000.0)
                vel.y += sin(rotation) * (energy / 1000000.0)
            elif self.type == "SEEKING":
                vel.x += cos(rotation) * (energy / 100000.0)
                vel.y += sin(rotation) * (energy / 100000.0)

        return positions
Example #35
0
def test_sdCircle():
    q = vec(1.,0.)
    r = 1
    assert np.isclose([sdCircle(q,r)], [0])
Example #36
0
 def update(self, data):
     self.position = vec(data['x'], data['y'])
     self.velocity = vec(data['velocityX'], data['velocityY'])
     self.rotation = data['rotation']
     self.energy = data['energy']
Example #37
0
def test_creation_empty():
    v = vec()
    assert len(v) == 0
    w = vec([])
    assert len(w) == 0
Example #38
0
def test_creation_non_empty():
    v = vec([1, 2, 3])
    assert len(v) == 3
Example #39
0
def test_iteration_empty():
    a = vec()
    for i in a:
        assert False
Example #40
0
def test_containment():
    N = 20
    a = vec(range(N))
    for i in range(N):
        assert i in a
    assert 100 not in a
Example #41
0
 def __init__(self, position=None, colour=None):
     self.position = position or vector.vec(0, 0, 0)
     self.colour = colour or vector.vec(0, 0, 0)
Example #42
0
def test_sdTriangle():
    q = vec(0.,-1.)
    v0, v1, v2 = vec(0,0), vec(1,0), vec(0.5, 0.5)
    assert np.isclose( [sdTriangle(q, v0, v1, v2)], [-1.])
Example #43
0
 def __init__(self, focal_length=None, fov=None, pos=None, ratio=None):
     self.focal_length = focal_length or 1000
     self.fov = fov or 60
     self.pos = pos or vector.vec(0, 0, -1)
     self.ratio = ratio or 1
Example #44
0
 def __getitem__(self, item):
     return vector.vec(self.data[item])
Example #45
0
scene = list()
camera = Camera()
scene = scene_reader('scene5.txt')
infinity = 1.30e59
(WIDTH,
 HEIGHT) = (2 * camera.focal_length * numpy.tan(camera.fov / 2) * camera.ratio,
            (2 * camera.focal_length * numpy.tan(camera.fov / 2)))
print(lights)
lightlen = len(lights)
for light in lights:
    light.areaLight()
    if len(lights) == 3 * lightlen:
        break
#lights.append(Light(vector.vec(1,0,1), vector.vec(0.9, 0., .2)))
# Screen coordinates: x0, y0, x1, y1.
S = (-camera.ratio * numpy.tan(camera.fov / 2),
     numpy.tan(camera.fov / 2) + 0.25,
     camera.ratio * numpy.tan(camera.fov / 2),
     -numpy.tan(camera.fov / 2) + 0.25)
x = numpy.tile(numpy.linspace(S[0], S[2], int(WIDTH)), int(HEIGHT))
y = numpy.repeat(numpy.linspace(S[1], S[3], int(HEIGHT)), int(WIDTH))

Q = vector.vec(x, y, 0.)
color = raytrace(camera.pos, (Q - camera.pos).normal(), 0, scene)

rgb = [
    Image.fromarray((255 * numpy.clip(c, 0, 1).reshape(
        (int(HEIGHT), int(WIDTH)))).astype(numpy.uint8), "L")
    for c in color.components()
]
Image.merge("RGB", rgb).save("fig.bmp")