scale(np.random.rand(), [0, 1], [tolerance, borders[0] - tolerance]),
scale(np.random.rand(), [0, 1], [tolerance, borders[1] - tolerance]))
def random_velocity(magnitude):
angle = scale(np.random.rand(), [0, 1], [0, 360])
vec = pg.Vector2()
vec.from_polar((magnitude, angle))
return vec
def scale(value, old, new):
return ((value - old[0]) / (old[1] - old[0])) * (new[1] - new[0]) + new[0]
X_AXIS_VEC = pg.Vector2(1, 0)
Y_AXIS_VEC = pg.Vector2(0, 1)
DEBUG_POSITION_COLOR = pg.Color('green')
SCREEN_WIDTH, SCREEN_HEIGHT = cfg.environment()['dim']
class Agent:
def __init__(self, sprite: pg.Surface, position: pg.Vector2,
velocity: pg.Vector2, reaction_radius: float):
self.original_sprite = sprite
self.showable_sprite = None
self.hitbox = None
self.position = position
self.velocity = velocity
self.acceleration = pg.Vector2(0, 0)
self.alive = True
def __init__(self, pos, images, mission, dry = False):
self.dry = dry
self.pos = pos
self.images = images
self.speed = 1 # Acceleration multiplier
self.acceleration = 1
self.fire_per_sec = 4.5
self.completeness = 1
self.title = "Alien Zapper 1"
self.name = "zapper"
self.time_passed = 0
self.lasers = []
self.size = (64, 64)
self.boom_size = (200, 200)
self.rect = self.get_rect()
self.health = 1
self.shield = 0
self.max_health = 1
self.max_shield = 1
self.hover_alt = 0
self.min_alt = 0
self.target_alt = 0
self.standard_alt = 0
self.alt_change_speed = 5
self.hitBy = []
self.items = []
self.current_items = {}
self.fireObject = Laser
self.dead = False
self.kill = False
self.frame = 1
self.frame_rate = 1 / 25
self.frame_time = 0
self.friction = 1
self.velocity = pygame.Vector2((0, 0))
self.max_velocity = 6
self.target_x_velocity = 0
self.mission = mission
self.mass = 1.5 # Mass in kilograms
self.death_frames = 25
self.max_temp = 300 # Works up to 300 deg. F
self.canFire = True
self.fire_from = "center"
self.beam = False
self.rotation = 0
self.rotation_speed = 90
self.max_rotation = 60
self.add_temp = 0
self.rotate = False
self.whimp = False
self.regen = False
self.hover = False
self.extra_dip = 0
self.send_to_ground()
self.regen_time = 0
self.just_fired = False
self.death_sound = None
self.weapon_power = 1
self.always_beam = False
self.general_acc = 20
self.im_back = False
def Draw(self, clock):
self.surf.fill((0, 0, 0))
if len(self.units) == 1:
self.gameOver = True
for gravity in self.gravities:
pygame.draw.circle(
self.surf,
gravity.color,
gravity.center,
gravity.strength / 2,
)
for booster in self.boosters:
if booster.done is True:
self.boosters.remove(booster)
self.AddRandomBooster()
else:
booster.Draw(self.surf)
for unit in self.units:
for booster in self.boosters:
offset = (unit.centerx - booster.centerx + booster.width * 2,
unit.centery - booster.centery + booster.width * 2)
if unit.mask.overlap(booster.mask, offset):
booster.Activate(unit)
break
if math.fabs(unit.angularVelocity < 90) and not self.gameOver:
print('unit', unit.name, 'is dead')
self.units.remove(unit)
explodeColor = pygame.transform.average_color(unit.imgBase)
for i in range(500 - len(self.particles)):
intensity = random.randint(10, 300)
if intensity > 250:
intensity *= 3
self.AddParticle(
unit.position,
intensity=intensity,
color=pygame.Color((
max(
0,
min(255, explodeColor[0] +
random.randint(-25, 25))),
max(
0,
min(255, explodeColor[1] +
random.randint(-25, 25))),
max(
0,
min(255, explodeColor[2] +
random.randint(-25, 25))),
)),
)
# self.AddRandomUnit()
continue # this unit is dead
totalGravity = pygame.Vector2(0, 0)
for gravity in self.gravities:
distance = pygame.Vector2(gravity.center) - pygame.Vector2(
unit.center)
if distance.magnitude():
gravityVector = distance.normalize() * gravity.strength
totalGravity += gravityVector
unit.acceleration = totalGravity
unit.Draw(clock)
self.UnitsBounceOffEachOther()
for particle in self.particles:
if particle.lifespan <= 0:
self.particles.remove(particle)
particle.Update(clock)
pygame.draw.circle(
self.surf,
particle.color,
particle.position,
particle.size,
)
if self.sidebarWidth:
self.DrawSideBar()
def update_p(self, dt):
self.old_p = pygame.Vector2(self.p)
self.p += self.v * dt
def __init__(self, x1, y1, x2, y2, color, width=1):
self.a = pygame.Vector2(x1, y1)
self.b = pygame.Vector2(x2, y2)
self.color = color
self.width = width
def get_desired_velocity(self):
return sum((self._get_escape_velocity(creature)
for creature in self.creature.other_creatures
if type(creature) in self.get_threatening_creatures()),
pygame.Vector2())
def main():
global globl_draw_boxes
pygame.init()
screen = pygame.display.set_mode(SIZE)
clock = pygame.time.Clock()
curr_chunk = Chunk(800)
mage = Character("Dude", scale=4)
mage.pos.xy = (WIDTH/2 - mage.size[0]), (HEIGHT/2 - mage.size[1]/2)
companion = Companion("little friend", scale=2)
companion.pos.xy = (WIDTH/2), (HEIGHT/2)
#TODO add all elements to the chunk model
entities = []
for i in range(6):
entities.append(Entity("./img/trees/tree_0.png", pygame.Vector2(random.randint(0, curr_chunk.size), random.randint(0, curr_chunk.size)), scale=6))
entities.append(Entity("./img/trees/pine_0.png", pygame.Vector2(random.randint(0, curr_chunk.size), random.randint(0, curr_chunk.size)), scale=6))
entities.append(Entity("./img/rocks/rock_0.png", pygame.Vector2(random.randint(0, curr_chunk.size), random.randint(0, curr_chunk.size)), scale=3))
# sort entities by y pos for correct placement
entities = sorted(entities, key=operator.attrgetter('pos.y'))
collision_boxes = []
border_boxes = []
for entity in entities:
collision_boxes.append(entity.coll_box)
border_boxes.append(entity.bord_box)
# add entities to current chunk
for entity in entities:
curr_chunk.add_entity(entity)
c = 0
while True:
c += 1
# get collisions
collisions = pygame.Rect.collidelistall(mage.coll_box, collision_boxes)
layer_collisions = pygame.Rect.collidelistall(mage.coll_box, border_boxes)
pre_collisions = pygame.Rect.collidelistall(mage.pre_coll_box, collision_boxes)
# get companion collisions
comp_collisions = pygame.Rect.collidelistall(companion.coll_box, collision_boxes)
comp_layer_collisions = pygame.Rect.collidelistall(companion.coll_box, border_boxes)
comp_pre_collisions = pygame.Rect.collidelistall(companion.pre_coll_box, collision_boxes)
# get objects of collisions
collision_objects = []
for collision in pre_collisions:
collision_objects.append(entities[i])
# get objects of companion collisions
comp_collision_objects = []
for collision in comp_pre_collisions:
comp_collision_objects.append(entities[i])
# get pressed keyboard keys
keys = pygame.key.get_pressed()
if keys[pygame.K_b]:
globl_draw_boxes = not globl_draw_boxes
# move player and companion
mage.interaction(collision_objects, keys=keys)
companion.interaction(mage.pos, comp_collision_objects, keys=keys)
# draw the background
screen.fill(pygame.Color(78, 86, 82))
# # draw entities
# for entity in entities:
# screen.blit(entity.image, entity.get_pos())
# draw entities from current chunk
for entity in curr_chunk.entities:
screen.blit(entity.image, entity.get_pos())
# draw mage & companion
# player companion collision
if pygame.Rect.colliderect(mage.pre_coll_box, companion.pre_coll_box):
if mage.pre_coll_box.center[1] > companion.pre_coll_box.center[1]:
companion.update(screen)
mage.update(screen)
else:
mage.update(screen)
companion.update(screen)
else:
companion.update(screen)
mage.update(screen)
# draw collision and borderboxes
if globl_draw_boxes:
# entity boxes
for i in range(len(entities)):
if len(collisions) > 0:
if i in collisions:
pygame.draw.rect(screen, (255, 0, 0), entities[i].coll_box, 1)
else:
pygame.draw.rect(screen, (255, 255, 0), entities[i].coll_box, 1)
else:
pygame.draw.rect(screen, (255, 255, 0), entities[i].coll_box, 1)
pygame.draw.rect(screen, (0, 255, 0), entities[i].bord_box, 1)
# mage box
pygame.draw.rect(screen, (0, 255, 0), mage.bord_box, 1)
if len(collisions) > 0:
pygame.draw.rect(screen, (255, 0, 0), mage.coll_box, 1)
pygame.draw.rect(screen, (255, 0, 0), mage.pre_coll_box, 1)
else:
pygame.draw.rect(screen, (255, 255, 0), mage.coll_box, 1)
pygame.draw.rect(screen, (255, 255, 0), mage.pre_coll_box, 1)
pygame.draw.rect(screen, (255, 255, 0), companion.coll_box, 1)
pygame.draw.rect(screen, (255, 255, 0), companion.pre_coll_box, 1)
# draw entities infront of player if necessary
if len(layer_collisions) > 0:
for i in layer_collisions:
screen.blit(entities[i].image, entities[i].get_pos())
# draw entities infront of companion if necessary
if len(comp_layer_collisions) > 0:
for i in comp_layer_collisions:
screen.blit(entities[i].image, entities[i].get_pos())
# update loop
pygame.display.update()
clock.tick(100)
# check for quit
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
quit()
def __init__(self, position, velocity):
self.pos = PG.Vector2(position)
self.vel = PG.Vector2(velocity)
import time
import random
import numpy as np
import pygame as pg
from pygame.sprite import collide_rect
from src.sprites.spritesheet import SpriteStripAnim
from src.utils import assets
GRAVITY = pg.Vector2((0, 3.8))
class ActiveEntity(pg.sprite.Sprite):
"""
Class to implement moving sprites
:param container: Application container
:param entity: Enemy map DTO
:param character: Character DTO
"""
def __init__(self, container, entity, character, *groups):
super().__init__(*groups)
sheet_path = assets.path_to("characters", character.name,
character.sheet)
sheet = container.image_from_path(sheet_path)
sheet = SpriteStripAnim(sheet,
(0, 0, character.height, character.width),
character.rows,
rows=4,
scale=(character.rescale_x,
def __init__( self, x1:int, y1:int, x2:int, y2:int ):
self.p1 = pygame.Vector2(x1, y1)
self.p2 = pygame.Vector2(x2, y2)
def Contains(self, pos, TIMESTEP, translate, zoom):
# Constains function for mouse inputs
thisPos = PG.Vector2(self.GetStepPos(TIMESTEP, translate))
if ((thisPos - pos).magnitude() <= self.size / zoom): return True
def random_position():
borders = cfg.borders()
tolerance = cfg.environment()['border_tolerance']
return pg.Vector2(
scale(np.random.rand(), [0, 1], [tolerance, borders[0] - tolerance]),
scale(np.random.rand(), [0, 1], [tolerance, borders[1] - tolerance]))
def steer_to_center(self):
to_center = pg.Vector2(SCREEN_WIDTH / 2,
SCREEN_HEIGHT / 2) - self.position
self.velocity = self.velocity.lerp(to_center, 0.03)
def random_velocity(magnitude):
angle = scale(np.random.rand(), [0, 1], [0, 360])
vec = pg.Vector2()
vec.from_polar((magnitude, angle))
return vec
#! /usr/bin/python
import pygame
from pygame import *
SCREEN_SIZE = pygame.Rect((0, 0, 800, 640))
TILE_SIZE = 64
GRAVITY = pygame.Vector2((0, 0.1))
class CameraAwareLayeredUpdates(pygame.sprite.LayeredUpdates):
def __init__(self, target, world_size):
super().__init__()
self.target = target
self.cam = pygame.Vector2(0, 0)
self.world_size = world_size
if self.target:
self.add(target)
def update(self, *args):
super().update(*args)
if self.target:
x = -self.target.rect.center[0] + SCREEN_SIZE.width / 2
y = -self.target.rect.center[1] + SCREEN_SIZE.height / 2
self.cam += (pygame.Vector2((x, y)) - self.cam) * 0.05
self.cam.x = max(-(self.world_size.width - SCREEN_SIZE.width),
min(0, self.cam.x))
self.cam.y = max(-(self.world_size.height - SCREEN_SIZE.height),
min(0, self.cam.y))
def draw(self, surface):
def __init__(self, coordinates, radius):
self.position = pygame.Vector2(coordinates)
self.radius = radius
triangulation = [triangle for triangle in triangulation if not onSuper(triangle)]
return triangulation
pygame.init()
window = pygame.display.set_mode((500, 500))
background = 20, 40, 100
white = 255, 255, 255
points = []
for i in range(100):
x = random.randint(20, window.get_width()-40)
y = random.randint(20, window.get_height()-40)
points.append(pygame.Vector2(x, y))
delaunay = DelaunayTriangulation(points, *window.get_size())
run = True
while run:
for event in pygame.event.get():
if event.type == pygame.QUIT:
run = False
window.fill(background)
for triangle in delaunay:
triangle.Show(window, white)
pygame.display.flip()
pygame.quit()
def __init__(self, coordinates, width, height):
self.position = pygame.Vector2(coordinates)
self.width = width
self.height = height
def interaction(self, poi, collisions, keys=[]):
self.poi = poi
# hover animation
if keys[pygame.K_j]:
self.hover = not self.hover
time.sleep(0.2)
# set speed via shift-key
if keys[pygame.K_LSHIFT]:
self.speed = 2
elif keys[pygame.K_LCTRL]:
self.speed = 0.5
else:
self.speed = 1
# get blocked directions
blocked_directions = []
for obj in collisions:
blocked_directions.append(pygame.Vector2(self.pre_coll_box.center[0] - obj.coll_box.center[0], self.pre_coll_box.center[1] - obj.coll_box.center[1]))
distance = poi - self.pos
self.poi_rad = 200
if distance.length() >= self.poi_rad - 10 or random.randint(0,1000) > 995:
self.new_pos = poi + 0.5*self.poi_rad*pygame.Vector2(random.randint(-1,1), random.randint(-1, 1))
if not pygame.Vector2(self.new_pos - self.pos).length() < 10:
# move
self.move_dir -= (self.pos - self.new_pos).normalize() / self.acceleration
#print(self.move_dir)
# # move
# if keys[pygame.K_RIGHT] or keys[pygame.K_LEFT] or keys[pygame.K_DOWN] or keys[pygame.K_UP]:
# # parse keyboard inputs
# if keys[pygame.K_RIGHT]:
# self.move_dir[0] += self.speed / self.acceleration
# if keys[pygame.K_LEFT]:
# self.move_dir[0] -= self.speed / self.acceleration
# if keys[pygame.K_DOWN]:
# self.move_dir[1] += self.speed / self.acceleration
# if keys[pygame.K_UP]:
# self.move_dir[1] -= self.speed / self.acceleration
# set speed to self.speed independent to direction (possible with vec.scale_to_length)
if self.move_dir.length() > self.speed:
self.move_dir = self.move_dir.normalize() * self.speed
# state machine for collisions
blocked = False
#TODO fix algorithm
for vec in blocked_directions:
res = vec + self.move_dir*0.8
#print(res, vec)
if res.length() < vec.length():
#blocked = True
if math.sqrt(vec[0]*vec[0] + self.move_dir[0]*self.move_dir[0]) > math.sqrt(vec[1]*vec[1] + self.move_dir[1]*self.move_dir[1]):
self.move_dir[0] = 0.0
if math.sqrt(vec[1]*vec[1] + self.move_dir[1]*self.move_dir[1]) > math.sqrt(vec[0]*vec[0] + self.move_dir[0]*self.move_dir[0]):
self.move_dir[1] = 0.0
# add vectors
if not blocked:
self.pos += self.move_dir
#set facing direction
if self.move_dir[0] >= 0:
self.group = pygame.sprite.Group(self.animation_walk_right)
else:
self.group = pygame.sprite.Group(self.animation_walk_left)
else:
self.move_dir /= self.acceleration
self.idle()
def make_vector(point):
vec = pygame.Vector2()
vec.xy = point[0], point[1]
return vec
def __init__(self, item_id, position, item_radius, drag):
self.item_id = item_id
self.position = position
self.item_radius = item_radius
self.velocity = pg.Vector2(0, 0)
self.drag = drag
def get_stick_head(self):
stick_ball_offset = pygame.Vector2(settings.ball_radius, 0)
offset_rotated = stick_ball_offset.rotate(-self.angle)
ball_pos = self.get_ball_pos()
return Rect(ball_pos[0] + offset_rotated[0], ball_pos[1] + offset_rotated[1], settings.stick_head_width, settings.stick_head_height, self.angle)
def __init__(self, flock):
velocity = pygame.Vector2(0, 0)
velocity.from_polar((1, 0))
super().__init__(flock, pygame.Vector2(1000, 500), velocity)
self.weight = 10
continue
tile = map.Tile(tile_id, [col, row])
world.append(tile)
clocks = pygame.time.Clock()
size = width, height = 1920, 1024
black = 0, 0, 0
can_jump = False
screen = pygame.display.set_mode(size)
ball = pygame.image.load("64x64.png")
player = p.Player()
v_input = pygame.Vector2()
def get_playerinput(event):
for event in pygame.event.get():
if event.type == pygame.QUIT: sys.exit()
if event.type == pygame.KEYDOWN and event.key == pygame.K_w:
v_input.y = v_input.y + 1
if event.type == pygame.KEYUP and event.key == pygame.K_w:
v_input.y = v_input.y - 1
if event.type == pygame.KEYDOWN and event.key == pygame.K_a:
v_input.x = v_input.x - 1
if event.type == pygame.KEYUP and event.key == pygame.K_a:
v_input.x = v_input.x + 1
if event.type == pygame.KEYDOWN and event.key == pygame.K_s:
def __init__(self):
self.current_speed = 10
self.position = pygame.Vector2()
self.look_vector = pygame.Vector2()
self.rect = pygame.Rect(0, 0, 0, 0)
import pygame
from pygame import *
import random
import leveldata
from leveldata import *
#Global Variables - includes custom user events and songs list information
SCREEN_SIZE = pygame.Rect((0, 0, 1200, 800))
TILE_SIZE = 64
GRAVITY = pygame.Vector2((0, 0.475))
_songs = ["Media\\Music\\DownUnder.mp3","Media\\Music\\HorseNoName.mp3",
"Media\\Music\\dreaming.mp3","Media\\Music\\Buffalo.mp3"]
_currently_playing_song = None
LEVEL = pygame.USEREVENT + 2
RETURNLEVEL = pygame.USEREVENT + 5
COLLISIONSOUND = pygame.USEREVENT + 7
SPIKEDEATH = pygame.USEREVENT + 6
LIFECOUNT = 3
#effect_lev0intro = pygame.mixer.Sound('')
#effect_lev1intro = pygame.mixer.Sound('')
#effect_lev2intro = pygame.mixer.Sound('')
#effect_lev3intro = pygame.mixer.Sound('')
#randomly picks next song from list to play during game
def play_a_different_song():
global _currently_playing_song, _songs
next_song = random.choice(_songs)
while next_song == _currently_playing_song:
next_song = random.choice(_songs)
_currently_playing_song = next_song
# Define width and height of screen here
screen_width = 1000
screen_height = 700
# Put together some reference rects and create the screen
game_rect = pygame.Rect(80, 0, screen_width - 80, screen_height)
sidebar_rect = pygame.Rect(0, 0, 80, screen_height)
screen = pygame.display.set_mode((screen_width, screen_height))
pygame.draw.rect(screen, (50, 50, 50), sidebar_rect)
# Calculate some useful constants
hex_radius = 7
hex_height = 2 * hex_radius
hex_width = 2 * hex_radius * sin60
cell_parameter = hex_width
half_hex = pygame.Vector2(hex_width / 2, hex_height / 2)
grid_origin = game_rect.center - Vex(grid_a - 1,
grid_b - 1).Vector2() / 2 * cell_parameter
# Pre-load vertices for a unit hexagon that is frequently used
center = pygame.Vector2(hex_width / 2, hex_height / 2)
unit_hex = [None] * 6
unit_hex[0] = pygame.Vector2(-hex_width / 2, -hex_radius / 2)
unit_hex[1] = pygame.Vector2(-hex_width / 2, hex_radius / 2)
unit_hex[2] = pygame.Vector2(0, hex_height / 2)
unit_hex[3] = pygame.Vector2(hex_width / 2, hex_radius / 2)
unit_hex[4] = pygame.Vector2(hex_width / 2, -hex_radius / 2)
unit_hex[5] = pygame.Vector2(0, -hex_height / 2)
# Utility class - maps a numerical scale to corresponding interpolations between two colors
def get_desired_velocity(self):
sum_steering = sum(
(creature.velocity for creature in self.creature.flock.creatures),
pygame.Vector2())
sum_steering /= len(self.creature.flock.creatures)
return sum_steering.normalize() * self.creature.max_speed
def __init__(self, x, y, width, height):
self.position = pygame.Vector2(x, y)
self.velocity = pygame.Vector2(0, 0)
self.width = width
self.height = height
def __init__(self, position):
self.position = pygame.Vector2(position)
self.is_alive = True
