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 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 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 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, 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 __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 __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 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 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,
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 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,
winner=''):
super().__init__(resolution, background, logo)
self.ExitButton = ExitGame(Vector2(0, 210))
self.StartMenuButton = StartMenuButton(Vector2(0, 100))
self.Winner = winner
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, 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()
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)
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, 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 __init__(self, inputPos, inputSpeed, inputSize):
super().__init__(inputPos, inputSpeed, inputSize)
self.velocity = Vector2(random.random() - 0.5,
random.random() - 0.5).Normalized()
self.angle = math.atan2(-self.velocity.y, self.velocity.x)
self.angle = math.degrees(self.angle)
self.currentSpeed = 0
self.linearAcceleration = 0
self.angularVelocity = 0
self.color = Constants.ENEMY_COLOR
self.originalArtSurface = pygame.image.load("sheep.png")
self.myNeighborsList = []
self.dogForce = Vector2(0, 0)
self.linesToDrawList = []
def pursuit(self):
if self.target == None:
return Vector2(0, 0)
directionAux = Vector2(0, 0)
if self.pos.x < self.target.pos.x:
directionAux.x = 1
elif self.pos.x > self.target.pos.x:
directionAux.x = -1
if self.pos.y < self.target.pos.y:
directionAux.y = 1
elif self.pos.y > self.target.pos.y:
directionAux.y = -1
return directionAux
