def spawn_asteroid():
if player is None:
return
screen_center = Vector2(screen_size[0] / 2, screen_size[0] / 2)
spawn_radius = max(screen_center.x, screen_center.y)
spawn_x = uniform(-1, 1)
spawn_y = uniform(-1, 1)
spawn_direction = Vector2(spawn_x, spawn_y)
spawn_direction.normalize()
spawn_point = screen_center + spawn_direction * spawn_radius
a = Asteroid(player, 250)
a.position = spawn_point
a.color = (0, 0, 255)
size = randint(8, 20)
a.graphicsBounds.radius = size
a.collider.radius = size
a.max_speed = 280
asteroids.append(a)
def update(self) -> None:
bs = self.brickHandler.getBricks()
for power in self.powerUps:
power.update(self.paddle, self.balls)
for ball in self.balls:
ball.move(bs, self.paddle)
for bk in bs:
if not bk.active:
if randint(0, 5) == 1:
self.powerUps.append(
spawnRandom((bk.position + bk.size / 2)))
self.balls = [bl for bl in self.balls if bl.active]
self.score += self.brickHandler.update()
self.powerUps = [power for power in self.powerUps if power.active]
if (len(self.balls) <= 0):
self.lives -= 1
if self.lives < 1:
self.over()
else:
self.start()
if (len(bs) <= 0):
self.over()
if self.inputHandler.getKey('q'):
self.over()
elif self.inputHandler.getKey('a'):
self.paddle.move(Vector2(-2, 0), self.balls)
elif self.inputHandler.getKey('d'):
self.paddle.move(Vector2(2, 0), self.balls)
elif self.inputHandler.getKey(' '):
self.paddle.release(self.balls)
elif self.inputHandler.getKey('x'):
self.over()
def __init__(self,
windowSize=Vector2(1280, 720),
initSize=Vector2(12800, 7200),
initPos=Vector2(0, 0)):
self.pos = initPos
self.size = initSize
self.windowSize = windowSize
def relative_side(self, entity):
"""Return what side of an entity we are on, to be used with collision"""
# THIS IS VERY BROKEN PLZ FIX
wall = hasattr(entity, 'side')
sides = [
'top', 'right', 'bottom', 'left'
] # 45:'top right', 135:'bottom right', 225:'bottom left', 315:'top left'}
sloc = self.location
eloc = entity.location
rect = entity.get_col_rect()
vec = Vector2.from_points(sloc, eloc)
if not wall:
final = [i * 90 for i in range(4)]
first = [i * 45 for i in range(8)]
rsides = [rect.midtop, rect.midright, rect.midbottom, rect.midleft]
#rsides = [Vector2(x, y) for x, y in rsides]
#side_deg = [atan2(v.y, v.x) for v in rsides]
side_deg = [
round((heading_to_degrees(
Vector2.from_points(entity.location, Vector2(
x, y)).get_normalized()) + 360) % 360)
for x, y in rsides
]
deg = 360 - round((heading_to_degrees(vec.get_normalized())) % 360)
if deg <= 45:
deg = 0
sdeg = closest(round(deg), side_deg)
num = side_deg.index(sdeg)
return sides[num]
elif wall:
return entity.side
return None
def __init__(self, world, name, image, **kwargs):
self.world = world
self.name = name
self.image = image
self.base_image = image
self.location = Vector2()
self.destination = Vector2()
self.speed = 0
self.scan = 100
if not self.image is None:
self.scan = int(get_surf_len(self.image) / 2) + 2
self.showhitbox = False
self.show = True
self.doprocess = True
keys = list(kwargs.keys())
if 'location' in keys:
self.location = Vector2(*kwargs['location'])
if 'destination' in keys:
self.location = Vector2(*kwargs['destination'])
if 'speed' in keys:
self.speed = kwargs['speed']
if 'hitbox' in keys:
self.showhitbox = bool(kwargs['hitbox'])
if 'scan' in keys:
self.scan = int(kwargs['scan'])
if 'show' in keys:
self.show = bool(kwargs['show'])
self.brain = StateMachine()
self.id = 0
def checkBallCollisions(self):
ball1 = self.whiteBall
ball2 = self.redBall
dist = self.whiteBall.pos.dist(self.redBall.pos)
if dist <= self.whiteBall.radius + self.redBall.radius:
power = (abs(ball1.vel.x) + abs(ball1.vel.y)) + (abs(ball2.vel.x) +
abs(ball2.vel.y))
power = power * 0.00482
opposite = ball1.pos.y - ball2.pos.y
adjacent = ball1.pos.x - ball2.pos.x
rotation = math.atan2(opposite, adjacent)
# ball1.moving = True
# ball2.moving = True
velocity2 = Vector2(90 * math.cos(rotation + math.pi) * power,
90 * math.sin(rotation + math.pi) * power, 0.0)
ball2.addForce(velocity2)
ball2.acc.mult(0.97, 0.97, 0.97)
velocity1 = Vector2(90 * math.cos(rotation) * power,
90 * math.sin(rotation) * power, 0.0)
ball1.addForce(velocity1)
ball1.acc.mult(0.97, 0.97, 0.97)
self.que.ballsHit = True
def __init__(self,
pos: Vector2 = Vector2(),
velocity: Vector2 = Vector2(),
material=-1,
intensity=1.0,
nextEncounter=math.inf,
obstacle_number=0,
vertice_number=0,
left=None,
right=None,
invalid=0,
virtual_neighbors_left=np.array([]),
virtual_neighbors_right=np.array([])):
conf = 'res/config.json'
with open(conf) as jf:
configuration = json.load(jf)
self.VISIBILITY_THRESHOLD = configuration["Constants"][
"VISIBILITY_THRESHOLD"]
self.SENSORS = configuration["Constants"]["SENSORS"]
self.X = configuration["Constants"]["X"]
self.Y = configuration["Constants"]["Y"]
self.MINLEN = configuration["Constants"]["MINLEN"]
self.DETERIORATION = configuration["Constants"]["DETERIORATION"]
self.pos = pos
self.velocity = velocity
self.material = material
self.intensity = intensity
self.nextEncounter = nextEncounter
self.obstacle_number = obstacle_number
self.vertice_number = vertice_number
self.left = left
self.right = right
self.invalid = invalid
self.virtual_neighbors_left = virtual_neighbors_left
self.virtual_neighbors_right = virtual_neighbors_right
def unit_test():
'''unit test'''
vec2a = Vector2([1, 2])
vec2b = Vector2([3, 4])
print "\nAddition"
add = vec2a.add(vec2b)
add.print_info()
print "\nSubtraction"
sub = vec2a.subtract(vec2b)
sub.print_info()
print "\nScalar Multiplication"
mult = vec2a.scalarmult(5)
mult.print_info()
print "\nMagnitude"
print vec2a.magnitude()
print "\nNormalize"
norm = vec2a.normalize()
norm.print_info()
print "\nDot Product"
print vec2a.dotproduct(vec2b)
def eat(self):
headPosition = self.getLast().pos
headDirection = self.getLast().direction
newDirection = headDirection.multiply(30)
newPosition = headPosition.sub(newDirection)
self.bodyParts.append(
SnakePart(self.scene, Vector2(0, 0), Vector2(0, 0), newPosition,
self.size, self.color))
def start():
self.winScene.objects["titleDisplay"] = Text(
self.winScene, Vector2(180, 70), Vector2(67, 200),
pygame.Color(255, 255, 0), "Assets/Recreativos.otf", "You Won")
self.winScene.objects["pressStartDisplay"] = Text(
self.winScene, Vector2(170, 300), Vector2(42, 200),
pygame.Color(255, 255, 255), "Assets/Recreativos.otf",
"PRESS SPACE BAR")
def __init__(self, particle_count, max_life):
self.particles = list()
for i in xrange(0, particle_count):
self.particles.append(Particle(1, Vector2(0, 0), Vector2(0, 0)))
self.life = max_life
def draw(self, graphics):
v = Vector2(self.x, self.y, 0)
w = Vector2.fromAngle(self.angle - math.pi / 2, 1)
w.setMag(15 + (20 if self.force > 0 else 0))
p1 = Vector2.subv(v, w)
w.setMag(100)
p2 = Vector2.subv(v, w)
graphics.line(p1.x, p1.y, p2.x, p2.y, 8, (150, 75, 0))
def start():
self.gameOverScene.objects["titleDisplay"] = Text(
self.homeScene, Vector2(180, 70), Vector2(67, 200),
pygame.Color(255, 0, 0), "Assets/Recreativos.otf", "Game Over")
# self.gameOverScene.objects["killDisplay"] = Text(self.homeScene, Vector2(180, 500), Vector2(67, 200), pygame.Color(255, 0, 0), "Assets/Recreativos.otf","Player waskilled by" + self.mainScene.objects.gameObject.getType())
self.gameOverScene.objects["pressStartDisplay"] = Text(
self.homeScene, Vector2(170, 300), Vector2(42, 200),
pygame.Color(255, 255, 255), "Assets/Recreativos.otf",
"PRESS SPACE BAR")
def start(self) -> None:
self.score = 0
self.balls = []
self.powerUps = []
self.paddle = Paddle(Vector2(BOARD_WIDTH // 2, BOARD_HEIGHT - 3), 10)
self.balls.append(
Ball(Vector2(BOARD_WIDTH // 2 + 1, BOARD_HEIGHT - 4),
Vector2(-1, 1)))
self.brickHandler = BrickHandler(self.board)
def __init__(self,
resolution,
background=None,
logo=None,
playerMenuItems=None):
super().__init__(resolution, background, logo)
self.PlayerMenuItems = playerMenuItems if playerMenuItems is not None \
else [TwoPlayers(Vector2(0, 0)), ThreePlayers(Vector2(0, 70)), FourPlayers(Vector2(0, 140))]
def __init__(self, life, position, velocity):
super(Particle, self).__init__()
self.life = life
self.position = Vector2(position.x, position.y)
self.velocity = Vector2(velocity.x, velocity.y)
self.active = False
def __init__(self, name, world, image):
self.world = world
self.name = name
self.image = image
self.speed = 0
self.location = Vector2(0, 0)
self.destination = Vector2(0, 0)
self.brain = StateMachine()
self.id = 0
self.main_tower = None
def start():
# breakpoint()
self.homeScene.objects["titleDisplay"] = Text(
self.homeScene, Vector2(6, 70), Vector2(67, 200),
pygame.Color(255, 255, 255), "Assets/Recreativos.otf",
"Snake Adventures")
self.homeScene.objects["pressStartDisplay"] = Text(
self.homeScene, Vector2(170, 300), Vector2(42, 200),
pygame.Color(255, 255, 255), "Assets/Recreativos.otf",
"PRESS SPACE BAR")
def __init__(self,
resolution: Vector2,
background=None,
logo=None,
winner=''):
super().__init__(resolution, background, logo)
self.ExitButton = ExitGame(Vector2(0, 210))
self.StartMenuButton = StartMenuButton(Vector2(0, 100))
self.Winner = winner
def buildObstacles(graph): # Random Obstacles for i in range(Constants.NBR_RANDOM_OBSTACLES): start = Vector2(randrange(0, Constants.WORLD_WIDTH), randrange(0, Constants.WORLD_HEIGHT)) graph.placeObstacle(start, (0, 0, 0)) for j in range(randrange(Constants.NBR_RANDOM_OBSTACLES)): start += Vector2((randrange(3) - 1) * Constants.GRID_SIZE, (randrange(3) - 1) * Constants.GRID_SIZE) while(start.x >= Constants.WORLD_WIDTH - Constants.GRID_SIZE or start.y >= Constants.WORLD_HEIGHT - Constants.GRID_SIZE): start += Vector2((randrange(3) - 1) * Constants.GRID_SIZE, (randrange(3) - 1) * Constants.GRID_SIZE) graph.placeObstacle(start, (0, 0, 0))
def __init__(self, x, y, r, white): self.pos = Vector2(x, y, 0) self.radius = r self.isWhite = white self.vel = Vector2(0, 0, 0) self.acc = Vector2(0, 0, 0) self.friction = 0.007 self.mass = 1.0 self.startx = x self.starty = y
def __init__(self,
resolution: Vector2,
background=None,
logo=None,
startMenuItems=None):
super().__init__(resolution, background, logo)
self.StartMenuItems = startMenuItems if startMenuItems is not None \
else [StartGame(Vector2(0, 0)), Settings(Vector2(0, 70)), Rules(Vector2(0, 140)), LoadGame(Vector2(0, 210)),
ExitGame(Vector2(0, 280))]
def __init__(self, game, playerInfoLabels=None):
self.Size = Vector2(
(game.Settings.Resolution.X - game.Settings.GetMapSize().X) // 2,
game.Settings.Resolution.Y)
self.Position = Vector2(
(game.Settings.Resolution.X - game.Settings.GetMapSize().X) // 2 +
game.Settings.GetMapSize().X, 0)
self.PlayerInfoLabels = playerInfoLabels if playerInfoLabels is not None \
else [PlayerName(), PlayerMoney(), PlayerTotalUnits(), PlayerNextTurnIncome(), PlayerRemainingMoves()]
def __init__(self, inputPos, inputSpeed, inputSize):
# Set boundingRect BEFORE the parent calls CalculateCenter so it doesn't ask where tf the variable is
self.boundingRect = None
self.position = inputPos
self.size = inputSize
self.maxSpeed = inputSpeed
self.velocity = Vector2(0, 0)
self.center = Vector2(0, 0)
self.CalculateCenter()
self.myRect = None
self.hasDrawn = False
def getRefracted(self, obstacle: Obstacle) -> Ray:
vel, intensity = Vector2().getRefracted(
A=obstacle.getPos(self.vertice_number),
B=obstacle.getPos(self.vertice_number + 1),
velocity=self.velocity,
relativeSpeed=obstacle.getRelativeSpeed(),
intensity=self.intensity)
return Ray(
Vector2(self.pos.getX() + (1.00015 * self.velocity.getX()),
self.pos.getY() + (1.00015 * self.velocity.getY())), vel,
intensity)
def virtualHandler(self, ray: Ray, isRightNeighbor: bool) -> None:
if (ray.getMaterial() == self.getMaterial()
and Vector2().scalar(ray.getVelocity(), self.getVelocity()) > 0
and Vector2().length(ray.getPos(),
self.getPos()) < 5 * self.MINLEN):
if self.getLeft() and isRightNeighbor:
ray.setRight(self)
self.setLeft(ray)
elif not self.getRight() and not isRightNeighbor:
ray.setLeft(self)
self.setRight(ray)
self.setNextEncounter(math.inf)
def exitRoot(self, ctx: LecParser.RootContext):
area = self.packer.pack(self.objects)
area.expand(Vector2(2 * self.packer.padding))
self.engine.set_size(int(area.width), int(area.height))
# TODO use composite object
for obj in self.objects:
obj.translate(Vector2(self.packer.padding))
obj.draw()
self.engine.show()
class Camera:
follows = None
size = Vector2(GameData.window_size[0], GameData.window_size[1])
position = Vector2(0, 0)
@staticmethod
def update():
if Camera.follows is not None:
Camera.position = (Camera.follows.position - Camera.size / 2).to_int()
@staticmethod
def set_follows(comp):
Camera.follows = comp
def __init__(self, x, y, width, height, sprite):
CompContainer.__init__(self)
self.x = x
self.y = y
self.width = width
self.height = height
self.rect = pygame.Rect(x, y, width, height)
self.sprite = sprite
self.position = Vector2(x, y)
self.velocity = Vector2()
self.destination = None
self.add_component(self.sprite)
def __init__(self, range, position, velocity):
# Construct parent so we have all of the Entities properties
# like position, velocity...
super(Bullet, self).__init__()
# How far the bullet travels
self.range = range
self.position = Vector2(position.x, position.y)
self.velocity = Vector2(velocity.x, velocity.y)
# The time needed to travel a certain range
self.life = range / self.velocity.magnitude()
def calculateAllAccels(self):
for i in range(len(self._object)):
accel = Vector2(0, 0)
for j in range(len(self._object)):
if i == j:
continue
delta = Vector2.getDelta(self._objects[i].getCoords(), self._objects[j].getCoords())
accel.add(GravitationController.calculateAccel(delta, self._objects[j].getMass()))
self._objects[i].addAccel(accel)
def shoot(self):
# Direction to target
dirToTarget = Vector2.get_normal(self.target.position - self.position)
# Create a bullet
bullet = Particle()
bullet.tag = "enemy bullet"
bullet.position.x = self.position.x
bullet.position.y = self.position.y
bullet.velocity = dirToTarget * self.firing_speed
bullet.boundingBox = Rect(self.position.to_tuple(), (5, 5))
bullet.color = (0, 255, 0)
bullet.set_life(2.0)
self.all_game_objects.append(bullet)
def fire_bullet():
# Direction to mouse
mouseX, mouseY = pygame.mouse.get_pos()
mousePos = Vector2(mouseX + camera.boundingBox.x, mouseY+camera.boundingBox.y)
dirToMouse = Vector2.get_normal(mousePos - player.position)
# Create a bullet
bullet = Particle()
bullet.tag = "player bullet"
bullet.position.x = player.position.x
bullet.position.y = player.position.y
bullet.velocity = dirToMouse * 800.0
bullet.boundingBox = Rect(player.position.to_tuple(), (5, 5))
bullet.color = (255, 150, 255)
bullet.set_life(1.3)
all_game_objects.append(bullet)
channel = mixer.find_channel(True)
channel.queue(laser_shot_sfx)
