def _detect_collisions(self):
"""
Collision detector:
- detects future collisions between self and other cars
- creates new Collision objects and sends them to the main queue
"""
while not self._kill:
if len(self.frames) == 0:
continue
curr_frame = self.frames[-1]
my_vals = curr_frame[self.name]
# don't waste time on old frames
if self._last_frame_number >= my_vals[-1]:
continue
self._last_frame_number = my_vals[-1]
# +1 makes loop inclusive
for dt in xrange(utils.FRAME_STEP, utils.FRAME_LOOKAHEAD + 1,
utils.FRAME_STEP):
my_future_pos = (my_vals[0] + my_vals[3] * dt,
my_vals[1] + my_vals[4] * dt)
for car_name, vals in curr_frame.iteritems():
if car_name == self.name:
continue
dx = vals[3] * dt
dy = vals[4] * dt
future_pos = (vals[0] + dx, vals[1] + dy)
if not utils.SAFE_DISTANCE(my_future_pos, future_pos):
if car_name not in self._collisions:
print "NEW COLLISION"
if dt > utils.COLLISION_CRITICAL:
self._collisions[car_name] = Collision(
car_name, self._last_frame_number + dt,
utils.CENTER_POINT(my_future_pos,
future_pos))
else:
self._collisions[car_name] = Collision(
car_name,
self._last_frame_number + dt,
utils.CENTER_POINT(my_future_pos,
future_pos),
critical=True)
else:
# print "REPEAT"
if dt <= utils.COLLISION_CRITICAL:
# print "START CRITICAL"
self._collisions[car_name].lock.acquire()
self._collisions[car_name].critical = True
self._collisions[car_name].lock.release()
print "DETECTED CRITICAL COLLISION", car_name
time.sleep(utils.THREAD_SLEEP)
def __init__(self, level, speed, tileset, **kwargs):
super().__init__(dirRule=lambda: {
-1: Direction.Left,
0: None,
1: Direction.Right
}[self.move.getDir(x=True)],
**kwargs)
self.collision = Collision(self, level)
self.move = Move(self, speed, collision=self.collision)
self._gravity = GravityLine(self, 2, h=level.map.h // 2)
self.jumping = Jumping(self.move, self._gravity, 2)
self._input = Input(inputStream=self.getInputStream())
self.applyInputSettings()
self._damageTimer = MinTimeEventStream(duration=2)
self._damageTimer.subscribe("self", self._takeDmg, autoInit=False)
def _isMoving():
return self.move.getSpeed(x=True) != 0
def _hDir():
return self.move.getDir(x=True)
def _vDir():
return {False: -1, True: 1}[self._gravity.positiveDir()]
image = Files.loadImage(tileset)
self._display = Display(image, self,
Animation(image, 11, _isMoving, _hDir, _vDir),
True)
self._weapon = Weapon(level,
anchor=self,
offsetFunc=lambda: ((5 * self.getIntDir()), 0),
inputStream=self.getInputStream())
def __init__(self):
self.d0 = 0
self.v0 = 0
self.d = 0
self.v = 0
self.a = 0
self.F = 0
self.t = 0
self.dt = 0.001
self.m = 0.1
self.B = 0.1
self.d_array = []
self.v_array = []
self.a_array = []
self.f_array = []
self.t_array = []
self.fext_array = []
self._m_store_trajectory = False
self._f_array_set = False
self._compute_collision = False
self.Col_obj = Collision()
self._sim_finished = False
def __init__(self, rect, speed, tileset, level, maxHealth, **kwargs):
super().__init__(rect=rect,
dirRule=lambda: {
-1: Direction.Left,
0: None,
1: Direction.Right,
}[self.move.getDir(x=True)],
idName="enemy",
baseHealth=maxHealth,
**kwargs)
self.collision = Collision(self, level, "enemy")
self.move = Move(self, speed, self.collision)
self.gravity = GravityLine(self, 2, h=level.map.h // 2)
self._ai = AI(self)
def _isMoving():
return self.move.getSpeed(x=True) != 0
def _hDir():
return self.move.getDir(x=True)
def _vDir():
return {False: -1, True: 1}[self.gravity.positiveDir()]
image = Files.loadImage(tileset)
self._display = Display(image, self,
Animation(image, 11, _isMoving, _hDir, _vDir),
True)
def get_matrix_contribution(self,
grid_points,
frequency_step=1.0,
sigmas=[0.1],
is_adaptive_sigma=False,
filename=None):
mc = Collision(self._interaction,
sigmas=sigmas,
is_adaptive_sigma=is_adaptive_sigma,
frequencies=self._frequencies,
degeneracy=self._degeneracy,
write=write_scr,
read=read_scr,
cutoff_frequency=self._cutfr,
cutoff_lifetime=self._cutlt)
is_sum = False
if grid_points == None:
is_sum = True
if self._is_nosym: # All grid points
grid_points = np.arange(np.product(self._mesh))
else: # Automatic sampling
(grid_points, grid_weights,
grid_address) = get_ir_grid_points(self._mesh,
self._primitive)
matrix_contributions = []
for gp in grid_points:
print "# grid %d" % gp
mc.set_grid_point(gp)
mc.run_interaction()
matrix_contributions_temp = []
for sigma in sigmas:
mc.set_sigma(sigma)
max_freq = (np.amax(self._interaction.get_phonons()[0]) * 2 +
sigma * 4)
fpoints = np.arange(0, max_freq + frequency_step / 2,
frequency_step)
mc.set_fpoints(fpoints)
mc.run()
matrix_contribution = mc.get_imag_self_energy()
matrix_contributions_temp.append(matrix_contribution)
if not is_sum:
write_matrix_contribution(gp,
self._mesh,
fpoints,
matrix_contribution,
sigma=sigma,
filename=filename)
matrix_contributions.append(matrix_contributions_temp)
matrix_contributions = np.array(matrix_contributions)
if is_sum:
for i, sigma in enumerate(sigmas):
write_matrix_contribution(None,
self._mesh,
fpoints,
np.sum(matrix_contributions[:, i],
axis=0),
sigma=sigma,
filename=filename)
def loadEntities(self):
startingPoint = (100, 0, 10)
self.AIworld = AIWorld(render)
self.collision = Collision(Monster.monster)
#terrain, initialPos, slimeModelPath, floorPos, scale, lifePoint, volumicMass, movingSpeed, dt
self.slime = Slime(self.terrain, startingPoint, "assets/models/slime.egg", 10, 10, 100, 0.01, 5, self.dt, "slime", self.collision)
self.spawn = Spawn([self.slime]+Monster.monster, self.terrain, self.AIworld, self.collision)
self.spawn.spawn()
def run():
collision_obj = Collision()
force_obj = ForceArray()
eom_obj.set_force_array(force_obj)
eom_obj.set_collision_check(True)
eom_obj.store_trajectory(True)
tspan = [t0, tf]
dt = (tspan[1] - tspan[0]) / 500
for i in range(1, itrs):
[d, v] = eom_obj.update(dt)
SysTime.sleep(dt)
eom_obj.set_sim_finished(True)
def __init__(self,
size,
topSpeed,
tileset,
collide,
*strategies,
altname=None):
super().__init__(rect=size, idName=altname)
self._display = Display(tileset, self)
if collide:
self.collision = Collision(self, collide, False)
self.move = Move(self, topSpeed, self.collision)
self._strategies = strategies
def __init__(self, lan):
pygame.init()
self.gravity = 0
self.rotated = 0
self.next_figure = self.get_random_figure()
self.figure = self.get_random_figure()
self.stage = Stage()
self.menu = Menu(self.stage, self.next_figure)
self.collision = Collision(self.stage)
self.move_x = 0
self.move_y = 0
if lan is None:
self.second_player = NoPlayer()
else:
self.second_player = LanSecondPlayer(self.menu, lan)
def __init__(self, window_x, window_y):
self.window_x = window_x
self.window_y = window_y
self.WINDOW_WIDTH = 800
self.WINDOW_HEIGHT = 600
self.backgroundColor = (255, 255, 255)
self.textColor = (0, 0, 0)
self.is_running = True
pygame.init()
self.fps_controller = fps_limiter(
) # IMPORTANT - FPS Controller must be started AFTER the call to
# pygame.init(). The timer in pygame gets the time in milliseconds
self.up_pressed = False # from the call to pygame.init().
self.down_pressed = False
self.left_pressed = False
self.right_pressed = False
self.pressed = None # Empty object to store output from pygame.key.get_pressed()
self.up = pygame.K_UP # Key constants redefined for easier typing
self.down = pygame.K_DOWN
self.left = pygame.K_LEFT
self.right = pygame.K_RIGHT
self.space = pygame.K_SPACE
# Setup for the screen, background, and player objects
self.screen = pygame.display.set_mode(
(self.WINDOW_WIDTH, self.WINDOW_HEIGHT))
self.background = pygame.Surface(
(self.WINDOW_WIDTH, self.WINDOW_HEIGHT))
self.background.fill(self.backgroundColor, None)
self.player = Player("Gjiorgisborgen")
self.player.setup_entity(400, 400, 30, 30)
# Font initialization
pygame.font.init()
self.text_font = pygame.font.SysFont(pygame.font.get_default_font(),
20)
# Text Surface initial render
self.player_info = self.text_font.render(self.player.__str__(), True,
(0, 0, 0))
# Collision detection object
self.collision_checker = Collision(self.player)
def checkForCollision(self):
self.__collisionPoints.clear()
self.__collisions.clear()
# for enemy in self.__enemies:
# if enemy.getRect().colliderect(self.__tank.getRect()):
# print(f"Enemy {enemy.getEnemyId()} brought your tank down")
# enemy.setActive(False)
# self.__scoreCard.loseLife()
for missile in self.__missiles:
if missile.getRect().top <= 5:
missile.setActive(False)
print(f"Missile {missile.getMissileId()} missed")
for enemy in self.__enemies:
if enemy.getRect().bottom >= (self.__graphics.getFieldSize()[1] -
5):
enemy.setActive(False)
print(f"Enemy {enemy.getEnemyId()} attached your fort")
self.__scoreCard.loseLife()
for missile in self.__missiles:
if missile.isActive():
for enemy in self.__enemies:
if enemy.isActive():
if missile.getRect().colliderect(enemy.getRect()):
# print(f"Missile {missile.getMissileId()} at {missile.getRect()} collides with Enemy "
# f"{enemy.getEnemyId()} at {enemy.getRect()}")
# print(missile.getRect())
# print(enemy.getRect())
missile.setActive(False)
enemy.setActive(False)
# print("Collision")
# collisionPosition = (missile.getRect()[0], missile.getRect()[1])
collisionPoint = ((int(enemy.getRect().left +
missile.getRect().left) /
2),
(int(enemy.getRect().bottom +
missile.getRect().top) / 2))
self.__missiles.remove(missile)
self.__enemies.remove(enemy)
collision = Collision()
collision.setCollisionPoint(collisionPoint)
self.__collisionPoints.append(collisionPoint)
self.__collisions.append(collision)
def update(self, key='LEFT') -> str:
"""Update World next state (Snake, Food)
according current state and keystrokes.
Keyword Arguments:
key (str): keystroke signal (default: 'LEFT')
Returns:
str: World state signal ('QUIT', 'DONE', 'CONT')
"""
if key == 'LEFT':
self.wd.snake_.move_left()
elif key == 'RIGHT':
self.wd.snake_.move_right()
elif key == 'UP':
self.wd.snake_.move_up()
elif key == 'DOWN':
self.wd.snake_.move_down()
elif key == 'EXIT': # quit game
return 'QUIT'
else:
pass
coll = Collision(self.wd) # init Collision object
head_collide = coll.check_snake_head() # check snake head collision
if head_collide[0]: # eat tails
return 'DONE'
if head_collide[1]: # eat food
self.wd.snake_.eat() # update snake state after eating
self.wd.food_.spawn_new() # spawn a new food
while any(coll.check_new_food()): # spawn new food w/t collision
self.wd.food_.spawn_new()
if head_collide[2]: # hit wall
return 'DONE'
return 'CONT' # continue game
def __init__(self):
# Config
# tps = ticks per second
self.tps_max = 50.0
self.screen_width = 800
self.screen_height = 600
# Initialization
pygame.init()
self.screen = pygame.display.set_mode((self.screen_width, self.screen_height))
pygame.display.set_caption('Snake by Max')
self.tps_clock = pygame.time.Clock()
self.tps_delta = 0.0
self.player = Player(3)
self.apple = Apple(5,5)
self.collision = Collision()
while True:
# Handle events
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit(0)
elif event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
sys.exit(0)
# Ticking
self.tps_delta += self.tps_clock.tick() / 1000.0
while self.tps_delta > 1 / self.tps_max:
self.tick()
self.tps_delta -= 1 / self.tps_max
# Drawing
self.screen.fill((0, 0, 0))
self.player.draw(self.screen)
self.apple.draw(self.screen)
pygame.display.flip()
def on_init(self):
# Initialize level. Level class contains walls, points and superpoints
self.level = level.Map()
self.level.make_level_variables()
# Initialize Draw class
self.draw = Draw()
# Get player and ghost variables from level class
self.playerPos = self.level.playerPos
self.ghostPos = self.level.ghosts
self._running = True
# Initialize player class
self.player = Player(self.playerPos, self.level.walls)
# Initialize Ghost class
self.ghost1 = Ghost(self.ghostPos[0], self.level.walls)
# Initialize Collision class
self.collision = Collision()
def __init__(self):
self.ui = UI()
self.col = Collision(self.ui)
self.act = Action(self.ui, self.col)
self.act.start()
def __init__(self):
# Configuracja
self.max_tps = 100.0
self.res = (1080, 720)
# Inicjalizacja
self.screen = pg.display.set_mode((0, 0), pg.FULLSCREEN)
#self.screen = pg.display.set_mode((1000,750))
pg.init()
pg.display.set_caption("Game")
self.tps_clock = pg.time.Clock()
self.tps_delta = 0.0
self.bulletsList = list()
self.enemyList = list()
img_dir = path.join(path.dirname(__file__), "img/")
eeg_dir = path.join(path.dirname(__file__), "img/eeg/")
sound_dir = path.join(path.dirname(__file__), "sound/")
diff = open("diff.txt", "r")
self.diff = diff.read()
diff.close()
self.tomekr = pg.image.load(eeg_dir + "TTr.png")
self.tomekl = pg.image.load(eeg_dir + "TTl.png")
self.eship = pg.image.load(img_dir + "eship.png")
self.pship = pg.image.load(img_dir + "pship.png")
self.bullimg = pg.image.load(img_dir + "bullet.png")
self.background = pg.image.load(img_dir + "background2.jpg")
self.jeden = pg.image.load(eeg_dir + "1ka.png")
self.eeglist = [
pg.image.load(eeg_dir + "en1.png"),
pg.image.load(eeg_dir + "en2.png"),
pg.image.load(eeg_dir + "en3.png"),
pg.image.load(eeg_dir + "en4.png"),
pg.image.load(eeg_dir + "en5.png"),
pg.image.load(eeg_dir + "en6.png"),
pg.image.load(eeg_dir + "en7.png"),
pg.image.load(eeg_dir + "en8.png"),
pg.image.load(eeg_dir + "en9.png"),
pg.image.load(eeg_dir + "en10.png")
]
self.explist = [
pg.image.load(img_dir + "expl1.png"),
pg.image.load(img_dir + "expl2.png"),
pg.image.load(img_dir + "expl3.png"),
pg.image.load(img_dir + "expl4.png"),
pg.image.load(img_dir + "expl5.png"),
pg.image.load(img_dir + "expl6.png"),
pg.image.load(img_dir + "expl7.png"),
pg.image.load(img_dir + "expl8.png")
]
self.expsound = pg.mixer.Sound(sound_dir + "bum.wav")
self.shootsound = pg.mixer.Sound(sound_dir + "shoot.wav")
self.rocketexpsound = pg.mixer.Sound(sound_dir + "rocketbum.wav")
self.lbsb = pg.mixer.Sound(eeg_dir + "lbsb.wav")
pg.mixer.music.load(sound_dir + "soundtrack.mp3")
pg.mixer.music.play(-1)
self.green = (80, 180, 30)
self.orange = (230, 70, 10)
self.white = (255, 255, 255)
self.tom = 0
self.player = Rocket(self)
self.bullet = Bullet(self, self.player)
self.enemy = Enemy(self, self.player, self.bullet)
self.collision = Collision(self, self.player, self.bullet, self.enemy)
while True:
# Obsluga zdarzen
for event in pg.event.get():
if event.type == pg.QUIT:
sys.exit(0)
elif event.type == pg.KEYDOWN and event.key == pg.K_ESCAPE:
sys.exit(0)
elif event.type == pg.KEYDOWN and event.key == pg.K_r:
system("Start.exe")
sys.exit(0)
elif event.type == pg.KEYDOWN and event.key == pg.K_SPACE:
in_bullet = Bullet(self, self.player)
in_bullet.shoot()
self.bulletsList.append(in_bullet)
elif event.type == pg.KEYDOWN and event.key == pg.K_q:
in_enemy = Enemy(self, self.player, self.bullet)
in_enemy.enemymake()
self.enemyList.append(in_enemy)
if self.diff == "Easy":
self.enemies = 5 + int(time.process_time() / 9)
elif self.diff == "Medium":
self.enemies = 7 + int(time.process_time() / 6.5)
elif self.diff == "Hard":
self.enemies = 9 + int(time.process_time() / 5)
# Taktowanie
self.tps_delta += self.tps_clock.tick() / 1000.0
while self.tps_delta > 1 / self.max_tps:
self.tick()
self.tps_delta -= 1 / self.max_tps
# Renderowanie
if self.tom == 1:
self.screen.fill((0, 0, 0))
elif self.tom == 0:
self.screen.fill((0, 0, 0))
#self.screen.blit(self.background,(0,0))
self.draw()
pg.display.flip()
def tick(self):
self.player.tick()
self.enemies.tick()
Collision(self.player.bullets, self.enemies)
def gen_tiles(self):
tiles = [[Collision(True) for x in range(self.width)] for y in
range(self.height)]
return tiles
RIGHT2 = 37
# Sound Sensor
TRIG = 16
ECHO = 18
# Trigger distance
TRIG_D = 40
motor = Motor(LEFT1, LEFT2, RIGHT1, RIGHT2)
sensor = soundsensor.Sensor(TRIG_D, TRIG, ECHO, LED_G, LED_R)
motor.setup_GPIO()
sensor.setup_GPIO()
sensor.set_HUD = False
collision = Collision(sensor, motor)
try:
toggle_green()
toggle_red()
toggle_green()
toggle_red()
toggle_green()
toggle_red()
app.run(host='0.0.0.0', port=3000)
toggle_green()
sleep(0.5)
toggle_green()
pusher_client.trigger("api-status", "Online")
except KeyboardInterrupt:
def _process_messages(self):
"""
Message Processor:
- processes incoming messages from CarTalker
- creates collision objects and adds them to collisions
"""
while not self._kill:
message = self._talker.get_message()
if message is None:
time.sleep(utils.THREAD_SLEEP)
continue
if message.other_name not in self._collisions:
if message.type != Message.ROW:
print "ERROR: Got response for nonexistant collision"
else:
print "NEW MESSAGE RECEIVED"
message.my_name = self.name
c = Collision(message.other_name,
message.frame_num,
message.location,
message=message)
c.state = CollisionState.RECEIVED_MESSAGE
self._collisions[message.other_name] = c
else:
collision = self._collisions[message.other_name]
collision.lock.acquire()
if message.type == Message.ROW:
if collision.state == CollisionState.WAITING:
# we are already waiting, so just send a confirmation that other has ROW
print "ALREADY WAITING"
self._talker.send_message(
Message(Message.GO, self.name, message.other_name,
collision.location, collision.frame_num))
elif collision.state == CollisionState.RESOLVED:
# we are already going, so send a stay message
print "ALREADY RESOLVED"
self._talker.send_message(
Message(Message.STAY, self.name,
message.other_name, collision.location,
collision.frame_num))
elif collision.state == CollisionState.NEW:
# if we haven't already sent a message, set collision to received in interim
collision.state = CollisionState.RECEIVED_MESSAGE
message.my_name = self.name
collision.message = message
print "Got message about unprocessed collision"
elif collision.state == CollisionState.SENT_MESSAGE:
# if collision.message.type == Message.ROW:
print "ALREADY SENT ROW... RESOLVING CONFLICT"
# compare the ROW we sent and the one we received
if collision.priority_val > message.priority_val:
# we win
self._talker.send_message(
Message(Message.STAY, self.name,
message.other_name, collision.location,
collision.frame_num))
collision.state = CollisionState.RESOLVED
print "RESOLVED DUPLICATED ROW... WE GO"
elif collision.priority_val < message.priority_val:
# we lose
self._talker.send_message(
Message(Message.GO, self.name,
message.other_name, collision.location,
collision.frame_num))
collision.state = CollisionState.WAITING
print "RESOLVED DUPLICATED ROW... WE WAIT"
else:
# tie, restart process by sending ROW
self._talker.send_message(
Message(Message.ROW, self.name,
message.other_name, collision.location,
collision.frame_num))
collision.state = CollisionState.SENT_MESSAGE
print "TIED DUPLICATED ROW... RESEND"
collision.message = None
else:
if collision.state == CollisionState.SENT_MESSAGE:
if message.type == Message.STAY:
collision.state = CollisionState.WAITING
collision.message = None
print "WE STAY"
else:
collision.state = CollisionState.RESOLVED
collision.message = None
print "RESOLVED... WE GO"
else:
print "ERROR: got response without having sent a message"
collision.lock.release()
time.sleep(utils.THREAD_SLEEP)
from collision import Collision c = Collision(256) msg1, msg2 = c.exploit(6) print(msg1) print(msg2)
def __init__(self):
# Settings
pygame.mixer.init()
pygame.mixer.music.load('latenight.ogg')
pygame.mixer.music.play(0)
self.WIDTH = 640
self.HEIGHT = 360
# Config
self.tps_max = 100
# Initialization
pygame.init()
font = pygame.font.SysFont("Arial", 18)
self.resolution = (self.screen_width,
self.screen_height) = (self.WIDTH, self.HEIGHT)
self.screen = pygame.display.set_mode(self.resolution,
pygame.RESIZABLE)
self.tps_clock = pygame.time.Clock()
self.tps_delta = 0.0
self.scroll = Vector2(0, 0)
self.map = Map(self)
self.player = Player(
self
) # przy inicjalizacji przekazuje playerowi wszystko Player(self)
self.enemy = Enemy(self)
self.weapon = Weapon(self)
self.fire = Fire(self)
self.physics = Physics(self)
self.platforms = Platforms(self)
self.collision = Collision(self)
self.sprite = Sprite(self)
self.menu = Menu(self)
self.file_loader = FileLoader(self)
self.sprite.load_images()
def create_fonts(font_sizes_list):
"Creates different fonts with one list"
fonts = []
for size in font_sizes_list:
fonts.append(pygame.font.SysFont("Arial", size))
return fonts
def render(fnt, what, color, where):
"Renders the fonts as passed from display_fps"
text_to_show = fnt.render(what, 0, pygame.Color(color))
self.screen.blit(text_to_show, where)
def display_fps():
"Data that will be rendered and blitted in _display"
render(fonts[0],
what=str(int(self.tps_clock.get_fps())),
color="white",
where=(0, 0))
fonts = create_fonts([32, 16, 14, 8])
while True:
# Events
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit(0)
elif event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE: ############# klik i cos sie dzieje raz
sys.exit(0)
# Ticking
self.tps_delta += self.tps_clock.tick(
) / 1000.0 # zamieniam MS na sekundy
while self.tps_delta > 1 / self.tps_max:
self.tick()
self.tps_delta -= 1 / self.tps_max
# Rendering/Drawing
self.screen.fill((0, 0, 0))
self.draw()
display_fps()
pygame.display.flip()
