def update(self, data):
c_pl1 = vector2(int(data["Player1"]["X"]), int(data["Player1"]["Y"]))
c_pl2 = vector2(int(data["Player2"]["X"]), int(data["Player2"]["Y"]))
c_ball = vector2(int(data["Ball"]["X"]), int(data["Ball"]["Y"]))
pl1_w = int(data["Player1_wins"])
pl2_w = int(data["Player2_wins"])
self.r_update(c_pl1, c_pl2, c_ball, pl1_w, pl2_w)
def r_update(self, player1, player2, ball, player1_wins, player2_wins):
self._player1 = vector2(player1.GetX() * D_X, player1.GetY() * D_Y)
self._player2 = vector2(player2.GetX() * D_X, player2.GetY() * D_Y)
self._ball = vector2(ball.GetX() * D_X, ball.GetY() / D_Y)
self._player1_wins = player1_wins
self._player2_wins = player2_wins
pass
def __init__(self):
middle_possition_y = SIZE_GAME_PLACE_Y / 2
middle_possition_x = SIZE_GAME_PLACE_X / 2
half_racket_y = SIZE_RACKET_Y / 2
padding = 10
self._player1_wins = 0
self._player2_wins = 0
self._player1 = vector2(padding, middle_possition_y - half_racket_y)
self._player2 = vector2(SIZE_GAME_PLACE_X - padding - SIZE_RACKET_X,
middle_possition_y - half_racket_y)
self._ball = vector2(middle_possition_x, middle_possition_y)
def diameter(p):
n = len(p)
#우선 가장 왼쪽에 있는 점과 오른쪽에 있는 점을 찾는다.
left = p.index(min(p))
right = p.index(max(p))
#p[left]와 pright]에 각각 수직선을 붙인다. 두 수직선은 서로 반대방향을 가리키므로, A의 방향만을 표현하면 된다.
calipersA = vector2(0, 1)
ret = (p[right] - p[left]).norm()
#toNext[i] = p[i]에서 다음 점까지의 방향을 나타내는 단위 벡터
toNext = [None for _ in range(n)]
for i in range(n):
toNext[i] = (p[(i + 1) % n] - p[i]).normalize()
#a와 b는 각각 두 선분이 어디에 붙은 채로 회전하고 있는지를 나타낸다.
a, b = left, right
#반 바퀴 돌아서 두 선분이 서로 위치를 바꿀 때까지 계속한다.
while a != right or b != left:
#a에서 다음 점까지의 각도와 b에서 다음 점까지의 각도 중 어느 쪽이 작은지 확인
cosThetaA = calipersA.dot(toNext[a])
cosThetaB = -calipersA.dot(toNext[b])
if cosThetaA > cosThetaB: # thetaA < thetaB
calipersA = toNext[a]
a = (a + 1) % n
else:
calipersA = toNext[b] * -1
b = (b + 1) % n
ret = max(ret, (p[a] - p[b]).norm())
return ret
def seek(self, food):
"""
This function calculates the velocity by the formulars of
steering behaviour (look at daniel shiffmans youtube account for
more informations)
"""
desired = vector2(0, 0)
if food is None:
# If the object is not seekin any food slow down until full stop
desired = vector2.mul(self.velocity, -1)
else:
desired = vector2.sub(food.position, self.position)
desired = vector2.set_magnitude(desired, self.max_speed)
steering = vector2.sub(desired, self.velocity)
steering = vector2.limit(steering, self.max_steering)
self.velocity = vector2.add(self.velocity, steering)
self.velocity = vector2.limit(self.velocity, self.max_speed)
def __init__(self, position, dna, health=1):
self.position = position
self.velocity = vector2(0, 0)
self.health = health
self.dna = dna
self.size = dna[0]
self.health_threshold = dna[1]
self.max_speed = calculate_max_speed(self.size)
self.max_steering = calculate_max_steering(self.size)
# Health decrease over time
self.hdot = calculate_hdot(self.size)
# Health decrease by movement
self.hdbm = calculate_hdbm(self.size)
# Blobs become adults after eating the first food
self.is_adult = False
# A surface to render the health on
self.health_surface = FONT.render(str(self.health), False, (255, 255, 255))
def neighbor_sampling(self, v):
return [vector2(v.x - NEIGHBOR_SAMPLING_DISTANCE, v.y), vector2(v.x + NEIGHBOR_SAMPLING_DISTANCE, v.y),
vector2(v.x, v.y - NEIGHBOR_SAMPLING_DISTANCE), vector2(v.x, v.y + NEIGHBOR_SAMPLING_DISTANCE)]
right = p.index(max(p))
#p[left]와 pright]에 각각 수직선을 붙인다. 두 수직선은 서로 반대방향을 가리키므로, A의 방향만을 표현하면 된다.
calipersA = vector2(0, 1)
ret = (p[right] - p[left]).norm()
#toNext[i] = p[i]에서 다음 점까지의 방향을 나타내는 단위 벡터
toNext = [None for _ in range(n)]
for i in range(n):
toNext[i] = (p[(i + 1) % n] - p[i]).normalize()
#a와 b는 각각 두 선분이 어디에 붙은 채로 회전하고 있는지를 나타낸다.
a, b = left, right
#반 바퀴 돌아서 두 선분이 서로 위치를 바꿀 때까지 계속한다.
while a != right or b != left:
#a에서 다음 점까지의 각도와 b에서 다음 점까지의 각도 중 어느 쪽이 작은지 확인
cosThetaA = calipersA.dot(toNext[a])
cosThetaB = -calipersA.dot(toNext[b])
if cosThetaA > cosThetaB: # thetaA < thetaB
calipersA = toNext[a]
a = (a + 1) % n
else:
calipersA = toNext[b] * -1
b = (b + 1) % n
ret = max(ret, (p[a] - p[b]).norm())
return ret
polygon = [vector2(1, 1), vector2(2, 1), vector2(2, 2), vector2(1, 2)]
print(diameter(polygon))
def __init__(self):
self.v = [vector2(), vector2()] #why not use self.m???
def create_blob(blobs):
posx = random.randint(0, maxX)
posy = random.randint(0, maxY)
size = random.randint(BLOB_MIN_SIZE, BLOB_MAX_SIZE)
threshold = random.random()
blobs.append(blob(vector2(posx, posy), [size, threshold]))
#시작점으로 돌아왔으면 종료한다.
if next == pivot: break
#next를 볼록 껍질에 포함시킨다.
hull.append(next)
return hull
#두 블록 다각형의 교차 여부를 확인하는 polygonIntersects() 함수의 구현 O(AB)
#두 다각형이 서로 닿거나 겹치는지 여부를 반환한다.
#한 점이라도 겹친다면 True를 반환한다.
def polygonIntersects(p, q):
n = len(p)
m = len(q)
#우선 한 다각형이 다른 다각형에 포함되어 있는 경우를 확인하자.
if isInside(p[0], q) or isInside(q[0], p): return True
#이 외의 경우, 두 다각형이 서로 겹친다면 서로 닿는 두 변이 반드시 존재한다.
for i in range(n):
for j in range(m):
if segmentIntersects(p[i], p[(i + n) % n], q[j], q[(j + 1) % m]):
return True
return False
points1 = [vector2(2, 3), vector2(3, 4), vector2(4, 5), vector2(2, 5)]
points2 = [vector2(4, 1), vector2(5, 5), vector2(3, 3), vector2(4, 4)]
polygon1 = giftWrap(points1)
polygon2 = giftWrap(points2)
print(polygonIntersects(polygon1, polygon2))
def idealScreenPos(x, y):
return vector2(x,y) * screenSize / idealScreenSize
def feetSecondSqrd(f):
return feet(f)
def degreesSecond(f):
return degrees(f)
def pitchYawRoll(p, y, r):
m = mat3()
m.FromEulerAnglesXYZ(degrees(p), degrees(y), degrees(r))
q = quat()
q.FromRotationMatrix(m)
return q
idealScreenSize = vector2(1024,800)
screenSize = vector2(800,600)
def idealScreenPos(x, y):
return vector2(x,y) * screenSize / idealScreenSize
"""These are already in game units so just pass through
"""
def gameUnit(f):
return f
meters = gameUnit
seconds = gameUnit
metersSecondSqrd = gameUnit
radiansPerSecond = gameUnit
radiansPerSecondSquared = gameUnit
def generate_gradient(self, v):
return vector2(self.random_values[int(v.x % 1000)],
self.random_values[int(v.y % 1000)]).normalisedCopy()
def mulVector2(self, v):
r = vector2()
r.x = v.dot2(self.v[0].x, self.v[1].x)
r.y = v.dot2(self.v[0].y, self.v[1].y)
return r
def get_containing_block_coordinates(self, v):
return vector2(floor(v.x), floor(v.y))
def create_food(foods):
posx = random.randint(0, maxX)
posy = random.randint(0, maxY)
size = FOOD_MAX_SIZE * E**(-random.random() * 2)
# size = 10
foods.append(food(vector2(posx, posy), size))