def preproc(self, world, game): print 'world %d x %d' % (world.width, world.height) pprint(map(list, zip(*world.tiles_x_y))) print world.waypoints print '=====================' self.navigator = Navigator(world) self.physics = Physics(world, game)
def __init__(self, screen, imgPath=None, name=None, highlight=False): self.screen = screen self.name = name or f'Name {random.randint(1111, 9999)}' self.highlight = highlight Physics.__init__( self, rect=(0, 0, 100, 100), initAngularVelocity=3000, friction=0, # acceleration in per second angularFriction=100, # acceleration in degrees per second ) if isinstance(imgPath, str): self.imgBase = pygame.image.load(imgPath or r'parts\1.png') else: self.imgBase = imgPath self.imgBase = self.imgBase.convert_alpha() self.imgBase = pygame.transform.scale(self.imgBase, self.size) self.image = self.imgBase self.edgeFriction = 100 self._mask = None self.angVelocityLimit = 500 self._UpdateMask() self.font = pygame.font.Font( None, 16) if not self.highlight else pygame.font.Font(None, 32) self.fontColor = pygame.color.Color( 'white') if not self.highlight else pygame.color.Color('cyan') avgColor = pygame.transform.average_color(self.imgBase) font = pygame.font.Font(None, int(self.height / 3)) self.surfTitle = font.render(self.name, True, avgColor)
def __init__(self, screen): self.screen = screen self.physics = Physics( (0, 0, 1, 1), friction=5000, ) self.imgSize = int(self.screen.get_width() / 4) self.images = [ pygame.transform.scale(pygame.image.load(IMG_DIR + '/' + path), (self.imgSize, self.imgSize)) for path in os.listdir(IMG_DIR) ] # self.currentSelection = int(len(self.images) / 2) self.currentSelection = random.choice(list(range(len(self.images)))) self.surfName = None self.stats = ['attack', 'defense', 'spin'] self.statSurf = pygame.Surface(( int(self.screen.get_width()), int((self.screen.get_height() - self.imgSize) / 2), )) self.startGameWith = None self.UpdateTextSurfaces() self.startTime = time.time()
def __init__(self, init_eta=None, init_upsilon=None, runtime=None, results_interval=300, random_eta_limits=None, random_upsilon_limits=None): '''Initialize parameters Params ====== init_position: 1D numpy array, initial position in x-y-z coordinates (w.r.t. inertial frame) init_orientation: 1D numpy array, initial orientation in phi-theta-psi angles (Z-Y-X Tait-Bryan angles) init_vel: 1D numpy array, initial velocities in x-y-z components (w.r.t. body frame) init_ang_vel: 1D numpy array, initial angle velocities in x-y-z components (w.r.t. body frame) runtime: float, limit simulation time in seconds results_interval: int, iterations between saving results random_position_limits: float list, limits of random position generator random_state_limits: float list, limits of random state generator (orientation, vel and ang_vel) ''' self.labels = [ 'time', 'x', 'y', 'psi', 'x_velocity', 'y_velocity', 'z_angular_velocity', 'Tport', 'Tstbd' ] self.physics = Physics(init_eta, init_upsilon, runtime) self.results_interval = results_interval self.random_eta_limits = [[-2.5, 2.5], [-2.5, 2.5], [ -np.pi, np.pi ]] if random_eta_limits is None else random_eta_limits self.random_upsilon_limits = [[0.0, 0.0], [0.0, 0.0], [ 0.0, 0.0 ]] if random_upsilon_limits is None else random_upsilon_limits self.reset()
def __init__(self, _main): self.main = _main ## PHYSICS HANDLER ## self.physics = Physics(self) ## LEVEL LOADER ## self.currentLevelName = None self.levelloader = LevelLoader(self) self.currentLevelName = "startLevel2-extra" ## INPUT HANDLER self.input = Input(self) self.movementOption = '1' ## HANDLE PLAYER ## self.isPlayerActive = False self.player = {} self.activePlayerName = "player2" ## Start GuI ## self.gui = Gui(self) self.accept("doStart", self.startGame) ## GAME STATE VARIABLES ## self.isMoving = False self.isFloating = False
def __init__(self, screen_rect): self.wall_group = list() rect = pygame.rect.Rect((0, 0), (10, screen_rect.h)) rect.topright = screen_rect.topright self.wall_group.append(Wall(rect)) rect = pygame.rect.Rect((0, 0), (screen_rect.w, 10)) rect.bottomleft = screen_rect.bottomleft self.wall_group.append(Wall(rect)) rect = pygame.rect.Rect((0, 0), (10, screen_rect.h)) rect.topleft = screen_rect.topleft self.wall_group.append(Wall(rect)) rect = pygame.rect.Rect((0, 0), (screen_rect.w, 10)) rect.topleft = screen_rect.topleft self.wall_group.append(Wall(rect)) self.ball_group = list() for i in range(50): b = Ball((random.randint(0, screen_rect.w), random.randint(0, screen_rect.h))) if not any(Physics.is_circle_collision(b, ball) for ball in self.ball_group): self.ball_group.append(b) self.physics = Physics() self.physics.solids.extend(self.wall_group) self.physics.mobiles.extend(self.ball_group)
def __init__(self, pars, is_kinetic=False, acc=0, ang_acc=0, fr=0, lives=0, life=0): self.image = pars["image"] self.image_center = pars["info"].get_center() self.image_size = pars["info"].get_size() radius = pars["info"].get_radius() self.up_key_down = False self.left_key_down = False self.right_key_down = False self.missile_image = pars["missile_image"] self.missile_info = pars["missile_info"] self.missile_sound = pars["missile_sound"] self.ship_thrust_sound = pars["ship_thrust_sound"] self.missile_group = set([]) self.lives = lives self.life = life self.score = 0 if is_kinetic: self.physics = Physics(radius, pars["WIDTH"], pars["HEIGHT"], None, is_kinetic, fr) self.physics.set_ang_acc(ang_acc) self.physics.set_acc(acc) else: self.physics = Physics(radius, WIDTH, HEIGHT) self.physics.set_pos(pars["pos"]) self.physics.set_vel(pars["vel"]) self.physics.set_ang(pars["ang"]) self.physics.set_ang_vel(pars["ang_vel"])
def test_straight_movement(self): me, world, game = load_objects() phys = Physics(world, game) me.speed_x = me.speed_y = 0.0 me.x = 6800.0 me.y = 7834.0 car_state = CarState.from_car(me) car_state.brake = False car_state.engine_power = 1.0 car_state.wheel_turn = 0.0 car_state_350 = CarState( 3.1415926535897931, np.array([-23.8683149170807631, 0.0000000000000029]), 0.0, np.array([4351.0112134403343589, 7834.0000000000000000])) car_state_474 = CarState( 3.1415926535897931, np.array([-29.4477720000775669, 0.0000000000000036]), 0.0, np.array([992.6379800312042789, 7834.0000000000000000])) for i in xrange(181, 475): car_state = phys.calc(car_state) car_state.update_car(car_state) if i == 350: self.assertEqual(car_state, car_state_350) elif i == 474: self.assertEqual(car_state, car_state_474)
def __init__(self, file_root, physics=None, smoothing=0.0, degree=3, SET_GLOBAL_EVOL=True): if physics is None: self.__phys = Physics() else: self.__phys = physics self.__f_data = np.loadtxt(file_root + '_devolution.dat') self.__delta_data = np.loadtxt(file_root + '_evolution.dat') a_data = np.loadtxt(file_root + '_a_vals.dat') self.__a_vals = a_data[:, 0] assert (a_data[-1, 0] == 1.0) self.__k_vals = np.loadtxt(file_root + '_matterpower_out.dat')[:, 0] * self.__phys.h if SET_GLOBAL_EVOL: physics.read_in_H(self.__a_vals, a_data[:, 1] / a_data[-1, 1]) normalized_dataset = self.__delta_data / np.meshgrid( self.__a_vals, self.__delta_data[:, -1])[1] G_interpolation = RectBivariateSpline(np.log10(self.__k_vals), np.log10(self.__a_vals), normalized_dataset, bbox=[ min(np.log10(self.__k_vals)), max(np.log10(self.__k_vals)), min(np.log10(self.__a_vals)), max(np.log10(self.__a_vals)) ], kx=degree, ky=degree, s=smoothing) self.__G_func = lambda a, k: np.squeeze( G_interpolation.ev(np.log10(k), np.log10(a))) f_interpolation = RectBivariateSpline(np.log10(self.__k_vals), np.log10(self.__a_vals), self.__f_data, bbox=[ min(np.log10(self.__k_vals)), max(np.log10(self.__k_vals)), min(np.log10(self.__a_vals)), max(np.log10(self.__a_vals)) ], kx=degree, ky=degree, s=smoothing) self.__f_func = lambda a, k: np.squeeze( f_interpolation.ev(np.log10(k), np.log10(a))) self.__dG_dt = lambda a, k: self.__phys.da_over_a( (1 - a) / a) * np.squeeze( f_interpolation.ev(np.log10(a), np.log10(k))) * self.__G_func( a, k)
def __init__(self, _id, pos=[0, 0], color='#27ae60'): # essentials super(Angel, self).__init__() # import settings self.settings = Settings() # set id self.id = _id # surface and rect self.image = pygame.Surface((200, 200)) pygame.draw.circle(self.image, color, (100, 100), 99) self.image = pygame.transform.scale(self.image, (30, 30)) self.image.fill(color) self.rect = self.image.get_rect() self.rect.x, self.rect.y = pos self.image.set_colorkey('#000000') # movement self.controls = controls[0] self.physics = Physics(self.rect, 1) self.last_state = None self.jumping = False self.air_timer = 0 self.colliding = { 'top': False, 'bottom': False, 'left': False, 'right': False } self.wall = False # additional features self.lives = 3 self.stamina = 10.0 self.capJump = 12
def __init__(self, simVars, delta=50, tick=0): self.delta = delta self.simVars = simVars self.map = Map(simVars) self.spawner = Spawner(self) self.tick = tick self.physics = Physics()
def update(self): Physics.instance().update() if not self.is_updating: pass index = 0 self._update_list_game_object() for game_object in self._game_objects.values(): if not game_object.is_updating: continue try: game_object.update() except: errorutils.handle_exception() index += 1
def step(self): if not self.ant.settled: try: self.ant.move() except Error as e: raise e else: if self.ant.y > self.maxHeight: self.maxHeight = self.ant.y if self.checkBridge(): return False self.addJoints(self.ant) self.antId = self.antId + 1 self.numAnts += 1 if G.DeterministicAnts: self.ant = Pyramid(self.antId) self.oldy = self.y self.y = self.ant.y if self.y != self.oldy: Physics.resetPhysics() Physics.checkPhysics() else: self.ant = Ant(self.antId) Physics.resetPhysics() Physics.checkPhysics() self.updateShaking() return True
class Element(object): __metaclass__ = ABCMeta color = "" ORIGINAL_WIDTH = 0 width = 0 ORIGINAL_HEIGHT = 0 height = 0 ORIGINAL_X = 0 startX = 0 ORIGINAL_Y = 0 startY = 0 canvasItem = None physics = None def resetElementForNewGame(self): self.physics = Physics(self.startX, self.startY) self.drawShip() def scale(self, horizontalScale, verticalScale): self.physics.scale(horizontalScale, verticalScale) self.width = self.ORIGINAL_WIDTH * horizontalScale self.height = self.ORIGINAL_HEIGHT * verticalScale self.startX = self.ORIGINAL_X * horizontalScale self.startY = self.ORIGINAL_Y * verticalScale self.drawElement() def executeAction(self, requestedActions): newLocationBasedOnActions = self.calculateNewLocationBasedOnActions(requestedActions) self.physics.updateForNewLocation(newLocationBasedOnActions) self.drawElement() def calculateNewLocationBasedOnActions(self, requestedActions): newLocationBasedOnActions = self.physics.location.getCopy() if requestedActions[Actions.UP]: newLocationBasedOnActions.y -= self.physics.maxSpeed.y if requestedActions[Actions.DOWN]: newLocationBasedOnActions.y += self.physics.maxSpeed.y if requestedActions[Actions.LEFT]: newLocationBasedOnActions.x -= self.physics.maxSpeed.x if requestedActions[Actions.RIGHT]: newLocationBasedOnActions.x += self.physics.maxSpeed.x return newLocationBasedOnActions def drawElement(self): pass
def __init__(self, _main): self.main = _main # Physics self.physics = Physics(self) # Level self.levelloader = LevelLoader(self) # Input # Player self.player = Player(self) # GUI # STATE self.isFloating = False
def update_objects(self): for i in self.objects: force = Vector(0, 0, 0) for j in self.objects: if i != j: force.add(Physics.Force(i, j)) if i.get_location().distance(j.get_location()) <= i.get_diameter()/2 + j.get_diameter()/2: self.collision = True self.dt = 0 acceleration = Physics.acc(i, force) i.update(acceleration, self.dt)
def build_level(self, level_file='lvl/level1.lvl'): lvl = Level(level_file) w, h = 100., 100. self.physics = Physics(w, h) # build units hero = self.add_hero(*lvl.units['h'][0]) ball = self.add_ball(*lvl.units['b'][0]) goal = self.add_goal(*lvl.units['g'][0]) units = [hero, ball, goal] self.hero, self.ball, self.goal = hero, ball, goal for sym, target, anim in [('h', hero, 'type1'), ('b', ball, 'type2'), ('g', goal, 'type3')]: for (x, y) in lvl.units['e%s' % sym]: u = self.add_enemy_following_target(x, y, target) u.set_animation(anim) units.append(u) self.units = units # build physics space self.physics.space.add_collision_handler( 3, # goal 4, # ball post_solve=self.game_rules.collision_ball_border, ) # Bind events to actions def on_double_tap(dt, pos): if not self.is_paused: self.add_explosion(hero.get_position()) def on_key_down(dt, key): actions = { 'w': self.hero.move_up, 's': self.hero.move_down, 'a': self.hero.move_left, 'd': self.hero.move_right, 'o': lambda _: self.add_explosion(hero.get_position()), } if key in actions: actions[key](dt) self.event_manager.register_action('double tap', on_double_tap) self.event_manager.register_action('swipe', self.hero.move) self.event_manager.register_action('key down', on_key_down)
class Simulation: def __init__(self, screen_rect): self.wall_group = list() rect = pygame.rect.Rect((0, 0), (10, screen_rect.h)) rect.topright = screen_rect.topright self.wall_group.append(Wall(rect)) rect = pygame.rect.Rect((0, 0), (screen_rect.w, 10)) rect.bottomleft = screen_rect.bottomleft self.wall_group.append(Wall(rect)) rect = pygame.rect.Rect((0, 0), (10, screen_rect.h)) rect.topleft = screen_rect.topleft self.wall_group.append(Wall(rect)) rect = pygame.rect.Rect((0, 0), (screen_rect.w, 10)) rect.topleft = screen_rect.topleft self.wall_group.append(Wall(rect)) self.ball_group = list() for i in range(50): b = Ball((random.randint(0, screen_rect.w), random.randint(0, screen_rect.h))) if not any(Physics.is_circle_collision(b, ball) for ball in self.ball_group): self.ball_group.append(b) self.physics = Physics() self.physics.solids.extend(self.wall_group) self.physics.mobiles.extend(self.ball_group) def compute(self, delta_time): for ball in self.ball_group: ball.compute(delta_time) self.physics.compute() def render(self, surface): surface.fill(color.WHITE) for wall in self.wall_group: wall.render(surface) for ball in self.ball_group: ball.render(surface)
def __init__(self,pos_x,pos_y,width = 100,height=20): super().__init__() self.settings = Settings() self.image = pygame.Surface((width,height)) self.image.fill('orange') self.rect = self.image.get_rect() self.rect.x, self.rect.y = pos_x, pos_y self.physics = Physics(self.rect,1000)
def selfControlFunction(physics: Physics, logging: Logging, regulator: Regulator, coeffs: dict, target: dict): nst = new_state_vector = physics.getStatus() fst = full_state_vector = logging.last() dt = fst["dt"] = nst["t"] - fst[ "t"] #ибо используем много, а каждый раз прописывать лень fst["tetaL1"] = (nst["tetaL"] - fst["tetaL"]) / dt fst["tetaR1"] = (nst["tetaR"] - fst["tetaR"]) / dt new_teta = (nst["tetaL"] + nst["tetaR"]) / 2 fst["teta1"] = (new_teta - fst["teta"]) / dt fst["teta"] = new_teta dxl = fst["teta1"] * coeffs["r"] fst["xl"] += dxl fst["xl1"] = dxl / dt beta1 = coeffs["r"] / coeffs["B"] * (fst["tetaR1"] - fst["tetaL1"]) fst["beta"] += beta1 * dt x1 = math.cos(fst["beta"]) * fst["xl1"] y1 = math.sin(fst["beta"]) * fst["xl1"] fst["x"] += x1 * dt fst["y"] += y1 * dt ex = target["xT"] - fst["x"] ey = target["yT"] - fst["y"] fst["gamma"] = math.atan2(ey, ex) fst["alpha"] = fst["gamma"] - fst["beta"] # угол ошибки if (abs(fst["alpha"]) > math.pi ): # не забываем про выход за границы множества углов [-pi; pi) fst["alpha"] = fst["alpha"] - math.copysign(1, fst["alpha"]) * 2 * math.pi fst["ro"] = math.sqrt(ey**2 + ex**2) fst["tetaT"] = fst["teta"] + fst["ro"] * math.cos( fst["alpha"]) / coeffs["r"] #обновляем все остальные базовые характеристики full_state_vector.update(new_state_vector) logging.add(full_state_vector) power_vector = regulator.regulate(full_state_vector) physics.setRegulation(power_vector)
class Entity: def __init__(self, sceneManager, name, mesh = "", pos = ogre.Vector3(0,0,0), vel = ogre.Vector3(0,0,0), heading = 0, speed = 0, desiredSpeed = 0, desiredHeading = 0, turningRate = 0): self.name = name self.mesh = mesh self.pos = pos self.vel = vel self.heading = heading self.speed = speed self.desiredSpeed = desiredSpeed self.desiredHeading = desiredHeading self.turningRate = turningRate self.sceneManager = sceneManager self.physics = Physics(self) self.renderable = Renderable(self, self.sceneManager) def tick(self, time): self.physics.tick(time) self.renderable.tick()
def test_calc_brake_distance(self): me, world, game = load_objects() phys = Physics(world, game) car_state = CarState.from_car(me) car_state.wheel_turn = 0.0 car_state.speed = np.array([-27.0311463976256405, 0.0]) speed_limit = 1.8195814109630735 ticks, brake_dist, car_state = phys.calc_brake_distance( car_state, speed_limit) self.assertEqual(ticks, 72) self.assertAlmostEquals(brake_dist, 958.2923150089691262, delta=TestPhysics.EPSILON) self.assertTrue( np.allclose(car_state.speed, np.array([-1.8195814109630735, 0.0]), rtol=0, atol=TestPhysics.EPSILON))
def __init__(self, location, speed): """ The location is an (x,y) coordinate pair, and speed is the player's speed in pixels per frame. Speed should be an integer. """ Physics.__init__(self) pg.sprite.Sprite.__init__(self) self.image = pg.Surface((30, 55)).convert() self.image.fill(pg.Color("red")) self.rect = self.image.get_rect(topleft=location) self.speed = speed self.jump_power = -9.0 self.jump_cut_magnitude = -3.0 self.on_moving = False self.collide_below = False self.weapons = { 1: MachineGun(), } self.weapon = self.weapons[1]
def add_type(self, name, drawn_type=None, res_asset_path=None, full_asset_path=None, meta_path=None): # make asset path safe if res_asset_path is not None: res_asset_path = res_asset_path.replace('\\', '/') add_type = DrawnType(name, start_ext_id=self.curr_ext_resource_id, start_sub_id=self.curr_sub_resource_id) # break out for specific node types if drawn_type is not None and drawn_type in self.TYPES: if drawn_type == 'sprite': add_type = Sprite(name, res_asset_path, meta_path=meta_path, start_ext_id=self.curr_ext_resource_id, start_sub_id=self.curr_sub_resource_id) elif drawn_type == 'static': add_type = Static(name, res_asset_path, full_asset_path, self.curr_ext_resource_id, self.curr_sub_resource_id, meta_path=meta_path) elif drawn_type == 'platforms': add_type = Static(name, res_asset_path, full_asset_path, self.curr_ext_resource_id, self.curr_sub_resource_id, meta_path=meta_path, one_way=True) elif drawn_type == 'physics' or drawn_type == 'items': add_type = Physics(name, res_asset_path, meta_path, self.curr_ext_resource_id, self.curr_sub_resource_id) elif res_asset_path is not None: # use sprites, if asset path exists add_type = Sprite(name, res_asset_path, meta_path=meta_path, start_ext_id=self.curr_ext_resource_id, start_sub_id=self.curr_sub_resource_id) # add node, external, sub content self.nodes += add_type.get_node_string() + '\n' self.ext_resources += add_type.get_ext_resources_string() self.sub_resources += add_type.get_sub_resources_string() # update id's self.curr_ext_resource_id = add_type.get_last_ext_id() self.curr_sub_resource_id = add_type.get_last_sub_id()
def __init__(self, config_file=None): """ Method to initialize the Engine class. """ pygame.init() self.running = True self.icon = pygame.image.load("assets/icon.png") self.background = pygame.image.load("assets/background.png") self.score_value = 0 self.screen_text = pygame.font.Font('freesansbold.ttf', 32) self.screen = pygame.display.set_mode((800, 600)) pygame.display.set_caption("Space Invaders") pygame.display.set_icon(self.icon) self.player = Player() self.enemy_fleet = EnemyFleet(16) self.enemy_fleet.create_fleet() self.game_physics = Physics()
def __init__(self): Physics.__init__(self) pg.sprite.Sprite.__init__(self) self.width = con.RUNNER_WIDTH self.height = con.RUNNER_HEIGHT self.right_image = setup.GFX['knightsprite_right'] self.right_image = pg.transform.scale(self.right_image, (80, 80)).convert_alpha() self.left_image = setup.GFX['knightsprite_left'] self.left_image = pg.transform.scale(self.left_image, (80, 80)).convert_alpha() self.image = self.right_image self.rect = self.image.get_rect() self.rect.width *= .75 self.name = con.RUNNER_NAME self.speed = con.RUNNER_SPEED self.jump_power = con.JUMP_POWER self.moving_right = True self.ok_to_jump = True self.dead = False self.on_mover = False self.mover = None
def __init__(self, period=0.05): """Setup the world, physics and viewer for the simulation.""" # bind the world step rate # - seconds, passed to gui loop self.period = period # - ideal step length, but procees time will vary self.current_dt_target = period # setup the size of the world self.width = DEFAULT_WORLD_M_W self.height = DEFAULT_WORLD_M_H # initialize physics engine self.physics = Physics(self) # create the map manager self.map_manager = MapManager(self) # create the GUI self.viewer = Viewer(self, self.period, DEFAULT_ZOOM, RANDOM) self.viewer.initialise_viewer()
def velocity(self): """ updates velocity """ for i, body in enumerate(self._body_list): v = Physics.velocity(body.get_velocity(), self.dt, self.a_matrix[:, i]) body.set_position(v, self.dt) if i == 1: self._velocity_analytics.add_data(self._t, la.norm(v)) self._t += self.dt self.render()
def __init__( self, surface ): self.surface = surface self.points = 8 self.segments = 20 # self.world = Physics() self.world.set_world( self.surface.get_size() ) self.world.set_repulsive_threshold( 100.0 ) self.world.set_viscosity( 0.85 ) # vertex_ring = create_initial_ring( self.surface, self.points, 10 ) self.colour = ColourGen() self.polygon_chain = PolygonShapeChain( self.segments, vertex_ring, self.colour.current(), GlowingBallShape )
class Game(): def __init__(self, _main): self.main = _main # Physics self.physics = Physics(self) # Level self.levelloader = LevelLoader(self) # Input # Player self.player = Player(self) # GUI # STATE self.isFloating = False def start_game(self): self.physics.start() def stop_game(self): self.physics.stop()
def __init__(self, name='untiled', pos=MyVector(0, 0, 0), vel=MyVector(0, 0, 0), mesh='untiled.mesh', yaw=0): self.name = name self.pos = pos self.vel = vel self.mesh = mesh self.yaw = yaw self.aspectTypes = ['Physics'] self.aspects = [Physics(self)]
def run_game(): pygame.init() screen_size = (600, 385) screen = pygame.display.set_mode(screen_size) mario = Mario(screen) background = Background(screen, './mario_pics/full_background_no_sky.png', mario) question_block = Block(screen, 300) physics = Physics() # first_goomba = Goomba(screen) enemies = Group() game_on = True tick = 0 background_color = (93, 148, 251) # r = randint(0, 255) # g = randint(0,255) # b = randint(0,255) while game_on == True: # tick += 1 # background_color = (r, g, b) # if tick % 5 == 0: # r += 10 # g += 15 # b += 16 # if r > 230: # r -= 150 # if g > 230: # g -= 150 # if b > 230: # b -= 150 # print tick for i in background.goomba_spawn_points: if background.x == i: enemies.add(Goomba(screen)) check_events(background, mario, question_block, screen) screen.fill(background_color) background.draw_background(mario) mario.draw_mario(physics, background) question_block.draw_block(mario) print enemies for enemy in enemies: enemy.draw_goomba(mario, physics, background) mario.check_mario_is_alive(background, enemy) # first_goomba.draw_goomba(mario) pygame.display.flip()
def __init__(self, pos, vel, angle, angle_vel, image, info, WIDTH, HEIGHT, sound=None, is_kinetic=False, acc=0, ang_acc=0, fr=0): self.pos = [pos[0], pos[1]] self.vel = [vel[0], vel[1]] self.angle = angle self.angle_vel = angle_vel self.image = image self.image_center = info.get_center() self.image_size = info.get_size() radius = info.get_radius() self.lifespan = info.get_lifespan() self.animated = info.get_animated() #self.age = 0 if sound: sound.rewind() sound.play() if is_kinetic: if self.lifespan == None: self.physics = Physics(radius, WIDTH, HEIGHT, None, is_kinetic, fr) else: self.physics = Physics(radius, WIDTH, HEIGHT, self.lifespan, is_kinetic, fr) self.physics.set_ang_acc(ang_acc) self.physics.set_acc(acc) else: if self.lifespan == None: self.physics = Physics(radius, WIDTH, HEIGHT) else: self.physics = Physics(radius, WIDTH, HEIGHT, self.lifespan) self.physics.set_pos(pos) self.physics.set_vel(vel) self.physics.set_ang(angle) self.physics.set_ang_vel(angle_vel)
class Game(): physics = Physics() def __init__(self): self.artifact_manager = ArtifactManager() self.hero_manager = HeroManager() def connect_new_gamer(self, id, name): self.hero_manager.add(id, name) return self.hero_manager.get(id) def disconnect_gamer(self, id): self.hero_manager.delete(id) def get_all_artifacts(self): all = [] for a in self.artifact_manager.get_all(): a = a.__dict__ all.append(a) return all def get_all_heroes(self): all = [] for a in self.hero_manager.get_all(): a = a.__dict__ all.append(a) return all def move(self, id, direction): self.hero_manager.move(id, direction) hero = self.hero_manager.get(id) r = {'x': hero.x, 'y': hero.y, 'diameter': hero.diameter, 'eat': None} for artifact in self.artifact_manager.get_all(): if self.physics.object_on_object(hero, artifact): self.hero_manager.eat_artifact(id, artifact) self.artifact_manager.delete(artifact.id) r['eat'] = artifact for another_hero in self.hero_manager.get_all(): if self.physics.object_on_object( hero, another_hero) and another_hero.id != hero.id: self.hero_manager.eat_hero(id, another_hero) self.hero_manager.delete(another_hero.id) r['eat'] = another_hero return r
def run(self): # Initialise variables self.physics = False self.physics_engine = Physics(self) self.raw_blocks = None self.running = True self.unflooding = False self.finite_water = False self.queued_blocks = {} # Blocks which need to be flushed into the file. self.create_raw_blocks() # Start physics engine self.physics_engine.start() # Main eval loop while self.running: try: # Pop something off the queue task = self.in_queue.get() # If we've been asked to flush, do so, and say we did. if task[0] is TASK_FLUSH: self.flush() self.out_queue.put([TASK_FLUSH]) # New block? elif task[0] is TASK_BLOCKSET: try: self[task[1]] = task[2] except AssertionError: logging.log("Tried to set a block at %s in %s!" % (task[1], self.blocks_path), logging.WARN) # Asking for a block? elif task[0] is TASK_BLOCKGET: self.out_queue.put([TASK_BLOCKGET, task[1], self[task[1]]]) # Perhaps physics was enabled? elif task[0] is TASK_PHYSICSOFF: logging.log(logging.DEBUG, "Disabling physics on '%s'..." % self.blocks_path) self.disable_physics() # Or disabled? elif task[0] is TASK_PHYSICSON: logging.log(logging.DEBUG, "Enabling physics on '%s'..." % self.blocks_path) self.enable_physics() # I can haz finite water tiem? elif task[0] is TASK_FWATERON: logging.log(logging.DEBUG, "Enabling finite water on '%s'..." % self.blocks_path) self.finite_water = True # Noes, no more finite water. elif task[0] is TASK_FWATEROFF: logging.log(logging.DEBUG, "Disabling finite water on '%s'..." % self.blocks_path) self.finite_water = False # Do they need to do a Moses? elif task[0] is TASK_UNFLOOD: logging.log(logging.DEBUG, "Unflood started on '%s'..." % self.blocks_path) self.unflooding = True # Perhaps that's it, and we need to stop? elif task[0] is TASK_STOP: logging.log(logging.DEBUG, "Stopping block store '%s'..." % self.blocks_path) self.physics_engine.stop() self.flush() logging.log(logging.DEBUG, "Stopped block store '%s'." % self.blocks_path) return # ??? else: raise ValueError("Unknown BlockStore task: %s" % task) except (KeyboardInterrupt, IOError): pass
class BlockStore(Thread): """ A class which deals with storing the block worlds, flushing them, etc. """ def __init__(self, blocks_path, sx, sy, sz): Thread.__init__(self) self.x, self.y, self.z = sx, sy, sz self.blocks_path = blocks_path self.in_queue = Queue() self.out_queue = Queue() self.saving = False def run(self): # Initialise variables self.physics = False self.physics_engine = Physics(self) self.raw_blocks = None self.running = True self.unflooding = False self.finite_water = False self.queued_blocks = {} # Blocks which need to be flushed into the file. self.create_raw_blocks() # Start physics engine self.physics_engine.start() # Main eval loop while self.running: try: # Pop something off the queue task = self.in_queue.get() # If we've been asked to flush, do so, and say we did. if task[0] is TASK_FLUSH: self.flush() self.out_queue.put([TASK_FLUSH]) # New block? elif task[0] is TASK_BLOCKSET: try: self[task[1]] = task[2] except AssertionError: logging.log("Tried to set a block at %s in %s!" % (task[1], self.blocks_path), logging.WARN) # Asking for a block? elif task[0] is TASK_BLOCKGET: self.out_queue.put([TASK_BLOCKGET, task[1], self[task[1]]]) # Perhaps physics was enabled? elif task[0] is TASK_PHYSICSOFF: logging.log(logging.DEBUG, "Disabling physics on '%s'..." % self.blocks_path) self.disable_physics() # Or disabled? elif task[0] is TASK_PHYSICSON: logging.log(logging.DEBUG, "Enabling physics on '%s'..." % self.blocks_path) self.enable_physics() # I can haz finite water tiem? elif task[0] is TASK_FWATERON: logging.log(logging.DEBUG, "Enabling finite water on '%s'..." % self.blocks_path) self.finite_water = True # Noes, no more finite water. elif task[0] is TASK_FWATEROFF: logging.log(logging.DEBUG, "Disabling finite water on '%s'..." % self.blocks_path) self.finite_water = False # Do they need to do a Moses? elif task[0] is TASK_UNFLOOD: logging.log(logging.DEBUG, "Unflood started on '%s'..." % self.blocks_path) self.unflooding = True # Perhaps that's it, and we need to stop? elif task[0] is TASK_STOP: logging.log(logging.DEBUG, "Stopping block store '%s'..." % self.blocks_path) self.physics_engine.stop() self.flush() logging.log(logging.DEBUG, "Stopped block store '%s'." % self.blocks_path) return # ??? else: raise ValueError("Unknown BlockStore task: %s" % task) except (KeyboardInterrupt, IOError): pass def enable_physics(self): "Turns on physics" self.flush() self.physics = True def disable_physics(self): "Disables physics, and clears the in-memory store." self.physics = False def create_raw_blocks(self): "Reads in the gzipped data into a raw array" # Open the blocks file fh = gzip.GzipFile(self.blocks_path) self.raw_blocks = array('c') # Read off the size header fh.read(4) # Copy into the array in chunks chunk = fh.read(2048) while chunk: self.raw_blocks.extend(chunk) chunk = fh.read(2048) fh.close() def get_offset(self, x, y, z): "Turns block coordinates into a data offset" assert 0 <= x < self.x assert 0 <= y < self.y assert 0 <= z < self.z return y*(self.x*self.z) + z*(self.x) + x def get_coords(self, offset): "Turns a data offset into coordinates" x = offset % self.x z = (offset // self.x) % self.z y = offset // (self.x * self.z) return x, y, z def world_message(self, message): "Sends a message out to users about this World." self.out_queue.put([TASK_WORLDMESSAGE, message]) def admin_message(self, message): "Sends a message out to admins about this World." self.out_queue.put([TASK_ADMINMESSAGE, message]) def send_block(self, x, y, z): "Tells the server to update the given block for clients." self.out_queue.put([TASK_BLOCKSET, (x, y, z, self[x, y, z])]) def __setitem__(self, (x, y, z), block): "Set a block in this level to the given value." assert isinstance(block, str) and len(block) == 1 # Save to queued blocks offset = self.get_offset(x, y, z) self.queued_blocks[offset] = block # And directly to raw blocks, if we must if self.raw_blocks: self.raw_blocks[offset] = block # Ask the physics engine if they'd like a look at that self.physics_engine.handle_change(offset, block)
def resetElementForNewGame(self): self.physics = Physics(self.startX, self.startY) self.drawShip()
def game(): screen.fill(black) running = True keyboard = Keyboard() world = World(32, 32) off = ((WIDTH - world.get_render_width()) / 2, (HEIGHT - world.get_render_height()) / 2) world.offX = off[0] world.offY = off[1] ply = Player(0, 0, world) ply.x = random.randint(0, WIDTH - ply.w) ply.y = random.randint(0, HEIGHT - ply.h) while world.entity_hitpos(ply): ply.x = random.randint(0, WIDTH - ply.w) ply.y = random.randint(0, HEIGHT - ply.h) physics = Physics(world, (WIDTH, HEIGHT)) physics.watch(ply) clock = pygame.time.Clock() last = pygame.time.get_ticks() ticks = 0 plydeathtimer = 0 lastrect = pygame.Rect(0, 0, 0, 0) while running: ticks += 1 clock.tick(0) for ev in pygame.event.get(): if ev.type == QUIT: running = False break elif ev.type == FRAMECOUNTER: print clock.get_fps() elif ev.type == WORLDREGEN: world.regen_once() elif ev.type == ENTITYGEN: x = random.randint(0, WIDTH) y = random.randint(0, HEIGHT) physics.watch(Enemy(x, y, world, physics)) elif ev.type == MOUSEBUTTONDOWN: if ev.button == 0 and plydeathtimer == 0: mpos = ev.pos center = ply.get_center() a = mpos[0] - center[0] b = mpos[1] - center[1] # tan(ang) = b / a ang = math.atan2(b, a) # Calculate bullet pos pos = [math.cos(ang) * ply.w + center[0], math.sin(ang) * ply.h + center[1]] bull = Bullet(pos[0], pos[1], world) speed = 2 bull.vx = speed * math.cos(ang) bull.vy = speed * math.sin(ang) physics.watch(bull) shootsound.play() elif ev.type == KEYDOWN: keyboard.keydown(ev.key) elif ev.type == KEYUP: keyboard.keyup(ev.key) # Handle movement if plydeathtimer == 0: if keyboard.is_down(K_w): ply.vy = -1 elif keyboard.is_down(K_s): ply.vy = 1 else: ply.vy = 0 if keyboard.is_down(K_a): ply.vx = -1 elif keyboard.is_down(K_d): ply.vx = 1 else: ply.vx = 0 # Shooting repeat if ticks % 10 == 0 and pygame.mouse.get_pressed()[0]: mpos = pygame.mouse.get_pos() center = ply.get_center() a = mpos[0] - center[0] b = mpos[1] - center[1] # tan(ang) = b / a ang = math.atan2(b, a) # Calculate bullet pos pos = [math.cos(ang) * ply.w + center[0], math.sin(ang) * ply.h + center[1]] bull = Bullet(pos[0], pos[1], world) speed = 2 bull.vx = speed * math.cos(ang) bull.vy = speed * math.sin(ang) physics.watch(bull) shootsound.play() for ent in physics.entities: if isinstance(ent, Enemy): ent.think(ply) if world.win(): win() running = False if ply.lives == 0: lose() running = False elif ply.removeme: ply.removeme = False plydeathtimer = 180 if plydeathtimer > 0: if plydeathtimer == 1: ply.x = random.randint(0, WIDTH - ply.w) ply.y = random.randint(0, HEIGHT - ply.h) while world.entity_hitpos(ply): ply.x = random.randint(0, WIDTH - ply.w) ply.y = random.randint(0, HEIGHT - ply.h) physics.watch(ply) plydeathtimer -= 1 # Clear previous font screen.fill(black, lastrect) # Render physics.renderclear(screen) world.render(screen) physics.tick() physics.render(screen) # Display health msg = "Lives: %d | Health: %d" % (ply.lives, ply.health) text = bigfont.render(msg, 1, white) lastrect = pygame.Rect(0, 0, text.get_width(), text.get_height()) screen.blit(text, (0, 0)) pygame.display.flip() dt = pygame.time.get_ticks() - last if dt < (1000 / 60): pygame.time.delay((1000 / 60) - dt) last = pygame.time.get_ticks()
gingerbreadIntelligenceThread objects.append(gingerbreadMonster) elif object[0] == "some other monster": pass if __name__ == '__main__': Network.Listen('0.0.0.0', 30000) startTime = time.time() objdata = [] players = [] physics = Physics(objects) physics.isClient = False spawnMonsters() physics.updateObjects(objects) try: lastSend = 0 while True: objects = physics.update() sendObjdata = False read_sockets, write_sockets, error_sockets = \ select.select(
class Game(DirectObject): def __init__(self, _main): self.main = _main ## PHYSICS HANDLER ## self.physics = Physics(self) ## LEVEL LOADER ## self.currentLevelName = None self.levelloader = LevelLoader(self) self.currentLevelName = "startLevel2-extra" ## INPUT HANDLER self.input = Input(self) self.movementOption = '1' ## HANDLE PLAYER ## self.isPlayerActive = False self.player = {} self.activePlayerName = "player2" ## Start GuI ## self.gui = Gui(self) self.accept("doStart", self.startGame) ## GAME STATE VARIABLES ## self.isMoving = False self.isFloating = False def startGame(self): self.gui.hideMenu() self.levelloader.newLevel(self.currentLevelName) self.createPlayer(self.activePlayerName) self.gui.showGameGui() self.levelloader.startCounter() ## HANDLE CAMERA ## self.camera = Camera(self) ## START PHYSICS ## self.physics.start() def stopGame(self): self.gui.hideGameGui() for object in self.levelloader.levelObjects: object.remove() for stateCoin in self.levelloader.levelStateCoins.keys(): self.levelloader.levelStateCoins["exit"].exitModel.remove() self.levelloader.levelStateCoins["exit"] = None for coin in self.levelloader.levelCoins.keys(): self.levelloader.levelCoins[coin].coinModel.remove() self.levelloader.levelCoins[coin] = None for node in self.physics.World.getRigidBodies(): self.physics.World.removeRigidBody(node) for node in self.physics.World.getGhosts(): self.physics.World.removeGhost(node) #self.levelloader.level = None self.levelloader.stopCounter() self.player[self.activePlayerName].removePlayer() self.player = None self.camera.stopCamTask() # Reset Cursor winProps = WindowProperties() winProps.setCursorHidden(False) base.win.requestProperties(winProps) self.camera = None self.physics.stop() self.gui.showMenu() def createPlayer(self, name): self.player = {} self.player[name] = Player(self, name)
class GameLogic(State): time = 0 def __init__(self): self.game_ended = False self.stop_when_unpaused = False self.explosions_left = 3 self.game_rules = GameRules(self) self.i = 0 def build_widget(self): self.game_interface = GameInterface() return self.game_interface def update(self, dt): # continue animation when the game has ended if self.is_paused and not self.stop_when_unpaused: return True self.time += dt self.game_interface.score = self.game_state.score self.game_interface.time = self.time self.game_interface.explosions_left = self.explosions_left if self.i % 100 == 0: self.game_interface.fps = int((self.i/self.time + 9/dt)/10) self.i += 1 self.physics.update(dt) for u in self.units: u.update(dt) if self.is_paused: return True if self.stop_when_unpaused: self.stop() return super(GameLogic, self).update(dt=dt) def build_level(self, level_file='lvl/level1.lvl'): lvl = Level(level_file) w, h = 100., 100. self.physics = Physics(w, h) # build units hero = self.add_hero(*lvl.units['h'][0]) ball = self.add_ball(*lvl.units['b'][0]) goal = self.add_goal(*lvl.units['g'][0]) units = [hero, ball, goal] self.hero, self.ball, self.goal = hero, ball, goal for sym, target, anim in [('h', hero, 'type1'), ('b', ball, 'type2'), ('g', goal, 'type3')]: for (x, y) in lvl.units['e%s' % sym]: u = self.add_enemy_following_target(x, y, target) u.set_animation(anim) units.append(u) self.units = units # build physics space self.physics.space.add_collision_handler( 3, # goal 4, # ball post_solve=self.game_rules.collision_ball_border, ) # Bind events to actions def on_double_tap(dt, pos): if not self.is_paused: self.add_explosion(hero.get_position()) def on_key_down(dt, key): actions = { 'w': self.hero.move_up, 's': self.hero.move_down, 'a': self.hero.move_left, 'd': self.hero.move_right, 'o': lambda _: self.add_explosion(hero.get_position()), } if key in actions: actions[key](dt) self.event_manager.register_action('double tap', on_double_tap) self.event_manager.register_action('swipe', self.hero.move) self.event_manager.register_action('key down', on_key_down) def on_game_end(self, player_won): self.game_ended = True if player_won: self.game_state.score += 1 else: self.game_state.score -= 1 self.game_state.player_won = player_won self.goal.set_animation('happy', 2) def stop(self): self.on_quit() super(GameLogic, self).stop() # function for building units def add_unit(self, unit_factory, x, y): size = config.get_sprite_size() u = unit_factory(size) u.set_position(x, y) self.physics.add_body(u) self.game_interface.add_widget(u.gfx) return u def add_hero(self, x, y): return self.add_unit(Hero, x, y) def add_ball(self, x, y): return self.add_unit(Brick, x, y) def add_goal(self, x, y): return self.add_unit(Goal, x, y) def add_enemy_following_target(self, x, y, hero): enemy = self.add_unit(Enemy, x, y) ai = EnemyFollowingTargetAi(hero) enemy.add_ai(ai) return enemy # Actions def add_explosion(self, center): if self.explosions_left <= 0: return self.explosions_left -= 1 for u in self.units: r = 2e-2 * max(1, (u.get_position() - center).length()) u.apply_force((u.get_position() - center).normalize() / r) self.game_interface.activate_shader_effect(center) self.hero.set_animation('special', 3) self.goal.set_animation('unhappy', 2) def move_hero(self, dt, direction): self.hero.move(dt, directly)
def test_displacement(self): object = Physics() self.assertEqual(6.890165, object.displacement(1, 1, 1))
class World(object): """Sets up a world in the simulation with robots, obstacles and a goal. Attributes: period -> float current_dt_target -> float width -> int height -> int physics -> Physics object map_manger -> MapManger object viewer -> Viewer object world_time -> float prev_absolute_time -> float supervisors -> list robots -> list obstacles -> list world_view -> WorldView object Methods: __init__(period=0.05) initialise_world(random=False, loading=False) draw_world() step() add_robot(robot) add_obstacle(obstacle) colliders() solids() stop_robots() """ def __init__(self, period=0.05): """Setup the world, physics and viewer for the simulation.""" # bind the world step rate # - seconds, passed to gui loop self.period = period # - ideal step length, but procees time will vary self.current_dt_target = period # setup the size of the world self.width = DEFAULT_WORLD_M_W self.height = DEFAULT_WORLD_M_H # initialize physics engine self.physics = Physics(self) # create the map manager self.map_manager = MapManager(self) # create the GUI self.viewer = Viewer(self, self.period, DEFAULT_ZOOM, RANDOM) self.viewer.initialise_viewer() def initialise_world(self, random=False, loading=False): """Generate the world in the simulation gui. This function sets up (or resets) the robots, their supervisors, the obstacles and goal and draws this to the gui.""" # initialize world time self.world_time = 0.0 # seconds self.prev_absolute_time = time() # initialize lists of world objects self.supervisors = [] self.robots = [] self.obstacles = [] # create the robot robot_1 = Robot(1, self.viewer, -0.5, -0.5, 270) #robot_2 = Robot(2, self.viewer, -1.0, 0.5, 270) self.add_robot(robot_1) #self.add_robot(robot_2) # generate a random environment if random: self.map_manager.random_map() print("Random Map") elif loading: self.map_manager.apply_to_world() print("Loading Map") else: self.map_manager.custom_map() print("Custom Map") # create the world view self.world_view = WorldView(self, self.viewer) # render the initial world self.draw_world() def reset_world(self): # initialize world time self.world_time = 0.0 # seconds self.prev_absolute_time = time() # initialize lists of world objects for robot in self.robots: robot.setup_robot(robot.x, robot.y, robot.deg) # render the initial world self.draw_world() def draw_world(self): """Refreshes the gui with the newly setup world.""" self.viewer.new_frame() # start a fresh frame self.world_view.draw_world_to_frame() # draw the world onto the frame self.viewer.draw_frame() # render the frame # step the simulation through one time interval def step(self): """Main step function of simulation, to step through time in world. This function first checks if the simulation is lagging or not by comparing the time passed since last called to the ideal time that should be taken between steps. An alarm is printed if lag occurs. The robot is first stepped in time to it's new position. Then physics are applied to these new robot positions to check for collisions and if obstacles are in range of the proximity sensors. The supervisors are then updated with the results of the physics test so controllers can be updated accordingly """ # calculate time since last step iteration time_now = time() self.current_dt = time_now - self.prev_absolute_time # update world_time to the current time self.prev_absolute_time = time_now # increment world time self.world_time += self.current_dt self.viewer._label_world_time.set_text('{0:.2f}'.format( self.world_time)) # Flag if current_dt is lagging by more than 5% if (self.current_dt > (self.current_dt_target * 1.05) or self.current_dt < (self.current_dt_target * 0.95)): print("Simulation lagging: {:.4f}").format(self.current_dt - self.current_dt_target) # read sensor values from all the robots for robot in self.robots: # read encoder values robot.read_encoders() # calculate the appropriate wheel velocities and control state for supervisor in self.supervisors: supervisor.step(self.current_dt) # step all the robots with the wheel velocities received from their # supervisors for robot in self.robots: # step robot motion robot.step_motion(self.current_dt) # check for interactions of robot with obstacles self.physics.apply_physics() def add_robot(self, robot): """Adds new robot to the robot list.""" self.robots.append(robot) self.supervisors.append(robot.supervisor) def add_obstacle(self, obstacle): """Adds new obstacle to the obstacle list.""" self.obstacles.append(obstacle) # return all objects in the world that might collide with other objects # in the world during simulation def colliders(self): """Returns a list of any moving objects in the simulation.""" # moving objects only return self.robots # as obstacles are static we should not test them # against each other # return all solids in the world def solids(self): """Returns a list of any solid objects in the world.""" return self.robots + self.obstacles def stop_robots(self): """Sends command to robot object to cease any motion. This is for sending a stop command to any connected physical robots. """ # stop all the robots for robot in self.robots: # stop robot motion robot.stop_motion()