def get_platform(self, platform_id): """Get a platform :param platform_id: The uuid of a platform :returns: an object of type platform containing the requested platform """ mongo_result = self.__db.platforms.find_one({"_id": ObjectId(platform_id)}) return Platform.from_mongo_result(mongo_result)
def __init__(self, player): # Call the parent constructor Level.__init__(self, player) self.level_limit = -1000 # Array with the width, height, x, and y of platform platforms = 4 width = [] width.append(random.randrange(Global_vars.SCREEN_WIDTH - 200, Global_vars.SCREEN_WIDTH + 400)) height = Global_vars.SCREEN_HEIGHT - 200 platform_level = [[width[0], height, 0, 450]] i = 0 while platforms > 0: if platforms > 0: width.append(random.randrange(Global_vars.SCREEN_WIDTH - 200, Global_vars.SCREEN_WIDTH + 400)) gap = random.randrange(120, Global_vars.player_jump_length) if len(width) > 2: x += width[i] + gap else: x = width[i] + gap y = random.randrange(height, height + 50) if x <= width[i]: x += Global_vars.player_jump_length platform_level.append([width[-1], height, x, y]) platforms -= 1 i += 1 # Go through the array above and add playforms for platform in platform_level: block = Platform(platform[0], platform[1]) block.rect.x = platform[2] block.rect.y = platform[3] block.player = self.player self.platform_list.add(block)
def test_from_mongo_result_performs_mapping(self): """Initialise the mapper :param mongo_result: A MongoDB result. The following fields can currently be mapped: * _id * _Platform__name * _Platform__description """ d = {"_id": "id", "_Platform__name": "name", "_Platform__description": "description"} p = Platform.from_mongo_result(d) self.assertEqual(d["_id"], p.id) self.assertEqual(d["_Platform__name"], p.name) self.assertEqual(d["_Platform__description"], p.description)
def __init__(self): Map.__init__(self, 2400, 1200) ''' Locations and sizes of platforms (width, height, x y) ''' map = [[200, 30, 270, 220], [200, 30, 300, 420], [200, 30, 600, 110], [200, 30, 1000, 800], [200, 30, 1400, 900], [200, 30, 1850, 1000], [200, 30, 10, 1150], [200, 30, 600, 1100], [200, 30, 2100, 1100]] for platform in map: block = Platform(platform[0], platform[1], platform[2], platform[3]) self.platform_list.add(block)
def __init__(self, parent=None): QtWidgets.QMainWindow.__init__(self, parent=parent) self.setupUi(self) backgroundPixmap = QtGui.QPixmap("Resource/BG4.jpeg") self.platformImage = Platform(168, 321) backgroundCanvas = QtGui.QPixmap(self.screenWidth, self.screenHeight) painter = QtGui.QPainter(backgroundCanvas) painter.drawPixmap(0, 0, self.screenWidth, self.screenHeight, backgroundPixmap) painter.drawImage(self.platformImage.xPos, self.platformImage.yPos, self.platformImage.platformPic) painter.end() self.backgroundImage = backgroundCanvas.toImage() self.StormEagle = SpriteObject.StormEagle self.StormEagleSprites = SpriteObject.StormEagleFly self.StormEagle.currentState = State.decendingIntro self.StormEagle.posX = 450 self.StormEagle.posY = 0 self.Megaman = SpriteObject.Megaman self.Megaman.currentState = State.stand self.MegamanSprite = SpriteObject.MegamanStand self.Megaman.posX = round(self.screenWidth / 2) self.Megaman.posY = self.platformImage.yPos - self.MegamanSprite.array[ self.Megaman.frameIndex].bottom + self.MegamanSprite.array[ self.Megaman.frameIndex].centerY self.megamanCollisionIsOn = True self.StormProjectile = [] self.StormProjectileSprite = SpriteObject.StormCannonProjectile self.GustProjectile = [] self.GustProjectileSprite = SpriteObject.GustProjectile self.EggBombProjectile = [] self.EggBombProjectileSprite = [] self.gravitation = 50 self.counterForRespawn = 0 self.timer = QtCore.QTimer() self.timer.timeout.connect(self.updateScreen) self.timer.start(100)
def generate_platform(self, index, score): if (score < MAX_JUMP * MAX_JUMP): change = int(math.sqrt(score)) else: change = MAX_JUMP - 1 width = 200 - randrange(change, change + 60) height = 20 y = 600 - index * 100 while True: side = bool(getrandbits(1)) if side: x = randrange(self.last_x - MAX_JUMP, self.last_x - change) else: x = randrange(self.last_x + width + change, self.last_x + MAX_JUMP + width) if x >= 0 and x <= SCREEN_WIDTH - width: break self.last_x = x return Platform(x, y, width, height)
def generate_platform(self, index, score): """Generuje platformy""" if(score < MAX_JUMP*MAX_JUMP): change = int(math.sqrt(score)) else: change = MAX_JUMP-1 width = 200 - randrange(change, change+60) #długość platformy height = 20 #wysokość y = 600 - index * 100 while True: side = bool(getrandbits(1)) # losowe 0, 1, współgra z randrange() if side: x = randrange(self.last_x-MAX_JUMP , self.last_x-change) else: x = randrange(self.last_x+width+change , self.last_x+MAX_JUMP+width) if x >= 0 and x <= SCREEN_WIDTH - width: break self.last_x = x return Platform(x, y, width, height) #tworzenie platformy
def main(): platform = Platform() recipe = Recipe() # Step 0: Preform hard reset to calibrate platform position during startup #platform.hard_Reset() # Step 1: get recipe from user either from onboard gui or android app #sampleRecipe = sys.argv[1] sampleRecipe = "1,19.3,2,19.3,3,19.3,4,19.3,5,19.3,6,19.3,7,19.3,8,19.3,true" # Step 2: split recipe string to a stack of seperate ingredients recipe.initilize_Stack(sampleRecipe) # Step 3: specify the order of the recipe if recipe.isOrdered == True: recipeOrder = recipe.recipeStack else: recipeOrder = platform.get_Shortest_Path(recipe) hbridge.turnOff() time.sleep(.3) # Step 4: interate over each ingredient then move platform for ingred in recipeOrder: print "Getting %rmL of segment %r" %(ingred.mL, ingred.segNum) #segNum is NOT 0 indexed platform.move_To_Segment(platform.segList[ingred.segNum-1].name) time.sleep(WAIT) # Step 5: once platform reached its mark, pour amount hbridge.turnOn() time.sleep(.2) Actuator.actuate(Actuator.actDict[ingred.segNum-1], float(ingred.mL)) hbridge.turnOff() time.sleep(WAIT) # Step 6: repeat step 4 till stack is empty # Step 7: Move platform back to the middle print "Final offset: %r " % Platform.offset platform.reset()
def main(argv): help_string = "Compiler.py -f <win32 | elf32 | elf64> -O <0 | 1 | 2> -o <output file> input_file" platform = Platform.elf32 input_file = '' output_file = '' optimization = 0 asm_file = '' obj_file = '' try: opts, args = getopt.getopt(argv, "hf:o:O:") for opt, arg in opts: if opt == '-h': print(help_string) sys.exit() elif opt == "-f": platform = Platform.by_name(arg) elif opt == "-o": output_file = arg elif opt == "-O": optimization = int(arg) input_file = args[0] asm_file = os.path.splitext(input_file)[0] + ".asm" obj_file = os.path.splitext(input_file)[0] + (".obj" if platform == Platform.win32 else ".o") if output_file == '': output_file = os.path.splitext(input_file)[0] + "." + platform.output_file_extension() except getopt.GetoptError: print(help_string) sys.exit(2) try: run_compile(platform, input_file, asm_file, optimization) link_executable_file(platform, asm_file, obj_file, output_file) except SyntaxError as e: print("Syntax error:", e.msg, file=sys.stderr) except ValueError as e: print("Value error:", e, file=sys.stderr) except NameError as e: print("Name error:", e, file=sys.stderr)
def __init__(self, main_instance): AbstractRole.__init__(self, main_instance) self.dialog = Dialog(self) Logger._instance.close() self.sessions = {} self.locked_sessions = [] self.sessions_spooler = MPQueue.Queue() self.sessions_spooler2 = MPQueue.Queue() self.sessions_sync = MPQueue.Queue() self.logging_queue = MPQueue.Queue() self.manager = Manager(self.main_instance.smRequestManager) self.threads = [] self.applications = {} self.applications_id_SM = {} self.applications_mutex = threading.Lock() self.has_run = False self.static_apps = RolePlatform.ApplicationsStatic( self.main_instance.smRequestManager) self.static_apps_must_synced = False self.static_apps_lock = threading.Lock()
def req_icon(self, app_id): if self.role_instance.applications is None: return self.req_unauthorized() self.role_instance.applications_mutex.acquire() if not self.role_instance.applications_id_SM.has_key(app_id): self.role_instance.applications_mutex.release() return self.req_unauthorized() app = self.role_instance.applications_id_SM[app_id] self.role_instance.applications_mutex.release() appsdetect = Platform.ApplicationsDetection() data = appsdetect.getIcon(app["filename"]) if data is None: return self.req_not_found() response = {} response["code"] = httplib.OK response["Content-Type"] = "image/png" response["data"] = data return response
def draw_ground(difficulty): platform_y = [490, 520, 550] prev_generated = False if difficulty == "easy": spawn_rate = 0.2 elif difficulty == "medium": spawn_rate = 0.3 elif difficulty == "hard": spawn_rate = 0.5 for i in range(0, 65000, 128): if (rand.random() > spawn_rate or i <= 512): ground = Platform(i, screen_height - 128) platforms.add(ground) game_objects.add(ground) sprites.add(ground) prev_generated = True else: if not(prev_generated): draw_platform(rand.choice([i, i - 128]), rand.randrange(1, 2), rand.choice(platform_y)) prev_generated = False return spawn_rate
def gameloop(): platform = Platform(colorrandom, 330, 550, 150, 30, 800) ball = Ball(WHITE, random_start_pos, 500, 15, 15) blocks = BlockHandler() score = 0 while True: for event in pygame.event.get(): if event.type == pygame.QUIT: exit(0) platform.update() ball.update() window.fill((0x00, ) * 3) window.blit(score_caption, (0, 0)) ball.show(window) platform.show(window) for i in range(len(blocks.blocks)): blocks.blocks[i].show(window) collisionIndex = ball.rect.collidelist(blocks.blocks) if collisionIndex != -1: ball.reverseY() blocks.blocks.pop(collisionIndex) score += 1 if ball.lives <= 0: return True if len(blocks.blocks) == 0: return False score_render = font.render(str(score), True, WHITE) window.blit(score_render, (100, 0)) pygame.display.update() clock.tick(60)
def __init__(self, screen_wdith, screen_height) : # Call the parent constructor. super().__init__() # The borders of the level. self.left_edge = 0 self.right_edge = 4590 self.top_edge = -500 self.bottom_edge = 1000 # Where the camera stops moving on this level. self.shift_left_bound = self.left_edge + (screen_wdith/2) self.shift_right_bound = self.right_edge - (screen_wdith/2) self.shift_up_bound = self.top_edge + (screen_height/2) self.shift_down_bound = self.bottom_edge - (screen_height/2) # Where the player starts on this level. self.starting_x = 20 self.starting_y = 212 self.starting_right = True # The portal to the next level. self.portal = Portal(4480, -60) self.portal_list.add(self.portal) # Music for this level. self.music = "Assets/Music/Level_1.mp3" # 2D array, containing the x and y coordinates and type for each platform. platforms = [ [0, 288, 0], [70, 288, 1], [140, 288, 1], [210, 288, 1], [280, 288, 1], [350, 288, 1], [420, 288, 1], [490, 288, 1], [560, 288, 1], [630, 288, 1], [700, 288, 1], [770, 288, 2], [980, 168, 0], [1050, 168, 2], [1340, 168, 0], [1410, 168, 2], [1650, 168, 0], [1720, 168, 1], [1790, 168, 1], [1860, 168, 1], [1930, 168, 1], [2000, 168, 1], [2070, 168, 1], [2140, 168, 2], [2470, 330, 0], [2540, 330, 2], [2770, 350, 0], [2840, 350, 1], [2910, 350, 1], [2980, 350, 1], [3050, 350, 1], [3120, 350, 1], [3190, 350, 2], [3400, 230, 0], [3470, 230, 2], [3680, 110, 0], [3750, 110, 1], [3820, 110, 1], [3890, 110, 1], [3960, 110, 1], [4030, 110, 1], [4100, 110, 1], [4170, 110, 1], [4240, 110, 1], [4310, 110, 1], [4380, 110, 1], [4450, 110, 1], [4520, 110, 2] ] # Go through the array above and create the platforms. for temp in platforms: platform = Platform(temp[0], temp[1], temp[2]) self.platform_list.add(platform) # A 2D array containing the min-x, max-x, and y coordinates and color of each enemy. enemies = [ [1650, 2210, 138, True], [2770, 3260, 320, False], [3680, 4310, 80, True], ] # Go through the array above and create the enemies. for temp in enemies : enemy = Enemy(temp[0], temp[1], temp[2], temp[3]) self.enemy_list.add(enemy)
class Simulator: OFFSET = 10 DEBUGSCREENSIZE = (350, 200) MASS = 1 MOMENT = 500 def __init__(self, ai_type, fullscreen): self.ai_type = ai_type # Screen self.running = True self.screen = Screen(fullscreen) self.width, self.height = pygame.display.Info( ).current_w, pygame.display.Info().current_h self.startPoistion = (self.width / 2, self.height / 2) # FpsController self.fpsController = FpsController() self.fpsCounter = 0 self.setFps(60) # Physics self.physics = Physics() # Drone self.drone = self.createDrone() self.camera = Camera(self.drone.body.position) # Platform self.platform = Platform() # Add element to space self.physics.addToSpace(self.platform.getShapes()) self.physics.addToSpace(self.drone.getShapes()) # Create Debug Screen DebugScreen.getInstance().setSize(self.DEBUGSCREENSIZE) DebugScreen.getInstance().setPosition( (self.width - self.DEBUGSCREENSIZE[0] - 10, 10)) def createDrone(self) -> Drone: if self.ai_type == AIType.fuzzyLogic: return Drone(self.MASS, self.MOMENT, self.physics.getGravity(), self.startPoistion, FuzzyLogicAI()) elif self.ai_type == AIType.neuronNetwork: return Drone(self.MASS, self.MOMENT, self.physics.getGravity(), self.startPoistion, NeuralNetworkAI()) elif self.ai_type == AIType.simpleAI: return Drone(self.MASS, self.MOMENT, self.physics.getGravity(), self.startPoistion, SimpleAI()) elif self.ai_type == AIType.manualAI: return Drone(self.MASS, self.MOMENT, self.physics.getGravity(), self.startPoistion, ManualAI()) raise RuntimeError("Invalid ai type") def setFps(self, numberOfFps): # Example of changes fps, default 60 self.fpsController.setFps(numberOfFps) def checkEvents(self): for event in pygame.event.get(): if event.type == QUIT or event.type == KEYDOWN and ( event.key in [K_ESCAPE, K_q]): self.running = False elif event.type == KEYDOWN and event.key == K_r: # Remove all Drone elements from the screen self.physics.removeObject(self.drone.getShapes()) # Create new Drone and add to space self.drone = self.createDrone() self.physics.addToSpace(self.drone.getShapes()) keys = pygame.key.get_pressed() # Engines take values of <0, 1> # For physics testing they were introduced permanently leftPower = 0.0 rightPower = 0.0 if keys[K_UP]: leftPower += 0.2 rightPower += 0.2 self.drone.leftEngine.setForce(leftPower) self.drone.rightEngine.setForce(rightPower) def startSimulation(self): # Each iteration of this loop will last (at least) 1/(number of FPS | default 60) of a second. while self.running: self.checkEvents() self.drone.update() self.camera.update(self.drone.body.position) self.draw() self.physics.updatePhysics() self.fpsController.waitForReady() self.fpsController.nextFrame() def draw(self): self.screen.clear() DebugScreen.getInstance().addInfo( "x", "{:.2f}".format(self.drone.body.position.x)) DebugScreen.getInstance().addInfo( "y", "{:.2f}".format(self.drone.body.position.y)) # Set screen offset based on camera position self.screen.setOffset(self.camera.getPosition()) # self.screen.drawPhysics(self.physics.space) self.platform.draw(self.screen) self.drone.draw(self.screen) DebugScreen.getInstance().draw(self.screen) self.screen.show()
def my_constructor( self , NET_TRANS_NODE , SCENEGRAPH , PLATFORM_SIZE , SCALE , STARTING_MATRIX , NAVIGATION_LIST , INPUT_SENSOR_TYPE , INPUT_SENSOR_NAME , NO_TRACKING_MAT , GF_SETTINGS , ANIMATE_COUPLING , MOVEMENT_TRACES , INVERT , SLOT_MANAGER , TRANSMITTER_OFFSET , DISPLAYS , AVATAR_TYPE , CONFIG_FILE , TRACKING_TARGET_NAME = None ): ## @var SCENEGRAPH # Reference to the scenegraph. self.SCENEGRAPH = SCENEGRAPH ## @var NET_TRANS_NODE # Reference to the net matrix node in the scenegraph for distribution. self.NET_TRANS_NODE = NET_TRANS_NODE ## @var coupled_navigations # List of coupled Navigation instances to which this Navigation's changes are forwarded to. self.coupled_navigations = [] ## @var input_sensor_type # String indicating the type of input device to be created, e.g. "XBoxController" or "OldSpheron" self.input_sensor_type = INPUT_SENSOR_TYPE ## @var input_sensor_name # Name of the input device sensor as chosen in daemon. self.input_sensor_name = INPUT_SENSOR_NAME if self.input_sensor_name == None: self.input_sensor_name = "keyboard" ## @var start_matrix # Initial position matrix of the platform. self.start_matrix = STARTING_MATRIX # create device ## @var device # Device instance handling relative inputs of physical device. if self.input_sensor_type == "OldSpheron": self.device = OldSpheronDevice() self.device.my_constructor(INPUT_SENSOR_NAME, TRACKING_TARGET_NAME, NO_TRACKING_MAT) elif self.input_sensor_type == "NewSpheron": self.device = NewSpheronDevice() self.device.my_constructor(INPUT_SENSOR_NAME, TRACKING_TARGET_NAME, NO_TRACKING_MAT) elif self.input_sensor_type == "XBoxController": self.device = XBoxDevice() self.device.my_constructor(INPUT_SENSOR_NAME, TRACKING_TARGET_NAME, NO_TRACKING_MAT) elif self.input_sensor_type == "KeyboardMouse": self.device = KeyboardMouseDevice() self.device.my_constructor(NO_TRACKING_MAT) elif self.input_sensor_type == "Spacemouse": self.device = SpacemouseDevice() self.device.my_constructor(INPUT_SENSOR_NAME, NO_TRACKING_MAT) elif self.input_sensor_type == "Globefish": self.device = GlobefishDevice() self.device.my_constructor(INPUT_SENSOR_NAME, NO_TRACKING_MAT) # init field connections self.sf_reset_trigger.connect_from(self.device.sf_reset_trigger) self.sf_coupling_trigger.connect_from(self.device.sf_coupling_trigger) self.sf_dof_trigger.connect_from(self.device.sf_dof_trigger) # create ground following ## @var groundfollowing # GroundFollowing instance to correct the absolute matrices with respect to gravity. self.groundfollowing = GroundFollowing() self.groundfollowing.my_constructor(self.SCENEGRAPH, self.device.sf_station_mat, float(GF_SETTINGS[1])) # create input mapping ## @var inputmapping # InputMapping instance to process and map relative device inputs to an absolute matrix. self.inputmapping = InputMapping() self.inputmapping.my_constructor(self, self.device, self.groundfollowing, STARTING_MATRIX, INVERT) self.inputmapping.set_input_factors(self.device.translation_factor, self.device.rotation_factor) self.inputmapping.sf_scale.value = SCALE # activate correct input mapping mode according to configuration file if GF_SETTINGS[0]: self.inputmapping.activate_realistic_mode() else: self.inputmapping.deactivate_realistic_mode() # create platform ## @var platform # Platform instance that is controlled by the Device. self.platform = Platform() self.platform.my_constructor( NET_TRANS_NODE = self.NET_TRANS_NODE , SCENEGRAPH = self.SCENEGRAPH , PLATFORM_SIZE = PLATFORM_SIZE , INPUT_MAPPING_INSTANCE = self.inputmapping , PLATFORM_ID = len(NAVIGATION_LIST) , TRANSMITTER_OFFSET = TRANSMITTER_OFFSET , NO_TRACKING_MAT = NO_TRACKING_MAT , DISPLAYS = DISPLAYS , AVATAR_TYPE = AVATAR_TYPE , SLOT_MANAGER = SLOT_MANAGER , CONFIG_FILE = CONFIG_FILE , AVATAR_MATERIAL = self.trace_material ) # create device avatar if AVATAR_TYPE != "None": self.device.create_device_avatar(self.platform.platform_scale_transform_node , self.platform.platform_id) ## @var NAVIGATION_LIST # Reference to a list containing all Navigation instances in the setup. self.NAVIGATION_LIST = NAVIGATION_LIST # attributes ## @var in_dofchange_animation # Boolean variable to indicate if a movement animation for a DOF change (realistic/unrealistic) is in progress. self.in_dofchange_animation = False ## @var in_coupling_animation # Boolean variable to indicate if a movement animation for coupling is in progress. self.in_coupling_animation = False ## @var timer # Instance of TimeSensor to handle the duration of animations. self.timer = avango.nodes.TimeSensor() ## @var ANIMATE_COUPLING # Boolean indicating if an animation should be done when a coupling of navigations is initiated. self.ANIMATE_COUPLING = ANIMATE_COUPLING ## @var movement_traces # Boolean indicating if the movement traces are currently visualized by line segments. self.movement_traces = MOVEMENT_TRACES ## @var movement_traces_activated # Boolean indicating if the movement traces are generally activated. self.movement_traces_activated = self.movement_traces ## @var trace # The trace class that handles the line segment updating. self.trace = None if self.movement_traces: # create trace and add 'Shadeless' to material string to have a nicer line apperance ## @var trace # Instance of Trace class to handle trace drawing of this navigation's movements. self.trace = TraceLines.Trace(self.NET_TRANS_NODE, self.platform.platform_id, 500, 20.0, STARTING_MATRIX, self.trace_material + 'Shadeless') # evaluate every frame self.always_evaluate(True)
def my_constructor(self, SCENEGRAPH, PLATFORM_SIZE, STARTING_MATRIX, NAVIGATION_LIST, INPUT_SENSOR_TYPE, INPUT_SENSOR_NAME, NO_TRACKING_MAT, GF_SETTINGS, ANIMATE_COUPLING, MOVEMENT_TRACES, TRACKING_TARGET_NAME = None): ## @var SCENEGRAPH # Reference to the scenegraph. self.SCENEGRAPH = SCENEGRAPH ## @var coupled_navigations # List of coupled Navigation instances to which this Navigation's changes are forwarded to. self.coupled_navigations = [] ## @var input_sensor_type # String indicating the type of input device to be created, e.g. "XBoxController" or "Spheron" self.input_sensor_type = INPUT_SENSOR_TYPE ## @var start_matrix # Initial position matrix of the platform. self.start_matrix = STARTING_MATRIX # create device ## @var device # Device instance handling relative inputs of physical device. if self.input_sensor_type == "Spheron": self.device = OldSpheronDevice() self.device.my_constructor(INPUT_SENSOR_NAME, TRACKING_TARGET_NAME, NO_TRACKING_MAT) elif self.input_sensor_type == "XBoxController": self.device = XBoxDevice() self.device.my_constructor(INPUT_SENSOR_NAME, TRACKING_TARGET_NAME, NO_TRACKING_MAT) elif self.input_sensor_type == "KeyboardMouse": self.device = KeyboardMouseDevice() self.device.my_constructor() elif self.input_sensor_type == "Spacemouse": self.device = SpacemouseDevice() self.device.my_constructor(INPUT_SENSOR_NAME) # create ground following ## @var groundfollowing # GroundFollowing instance to correct the absolute matrices with respect to gravity. self.groundfollowing = GroundFollowing() self.groundfollowing.my_constructor(self.SCENEGRAPH, self.device.sf_station_mat, GF_SETTINGS) # create input mapping ## @var inputmapping # InputMapping instance to process and map relative device inputs to an absolute matrix. self.inputmapping = InputMapping() self.inputmapping.my_constructor(self, self.device, self.groundfollowing, STARTING_MATRIX) self.inputmapping.set_input_factors(self.device.translation_factor, self.device.rotation_factor) # create platform ## @var platform # Platform instance that is controlled by the Device. self.platform = Platform() self.platform.my_constructor(self.SCENEGRAPH, PLATFORM_SIZE, self.inputmapping, len(NAVIGATION_LIST)) ## @var NAVIGATION_LIST # Reference to a list containing all Navigation instances in the setup. self.NAVIGATION_LIST = NAVIGATION_LIST # attributes ## @var in_dofchange_animation # Boolean variable to indicate if a movement animation for a DOF change (realistic/unrealistic) is in progress. self.in_dofchange_animation = False ## @var frames_since_last_dofchange # Framecount to make realistic/unrealistic switch on one button. Switching again is possible after x frames. self.frames_since_last_dofchange = 0 ## @var frames_since_last_coupling # Framecount since the last coupling / decoupling operation was done. Used to make functionality on one button. self.frames_since_last_coupling = 0 ## @var in_coupling_animation # Boolean variable to indicate if a movement animation for coupling is in progress. self.in_coupling_animation = False ## @var timer # Instance of TimeSensor to handle the duration of animations. self.timer = avango.nodes.TimeSensor() ## @var ANIMATE_COUPLING # Boolean indicating if an animation should be done when a coupling of navigations is initiated. self.ANIMATE_COUPLING = ANIMATE_COUPLING ## @var movement_traces # Boolean indicating if the movement traces should be visualized by line segments. self.movement_traces = MOVEMENT_TRACES ## @var trace # The trace class that handles the line segment updating. self.trace = None # evaluate every frame self.always_evaluate(True)
def loadLevel(self): levelFile = open(self.fileName, "r") jsonString = levelFile.read() parsedJson = json.loads(jsonString) player = None for instance in parsedJson["Level"]: for item in instance: if item == "Name" and instance[item] == "Player": y = instance["Y"] x = instance["X"] angle = instance["Angle"] player = Player(self.world, x, y, cursor=self.cursor) player.rotation = angle player.stableRotation = angle self.world.addEntity(player) for instance in parsedJson["Level"]: for item in instance: if item == "Room": self.world.roomHeight = instance[item]["Height"] self.world.roomWidth = instance[item]["Width"] if item == "Name": y = instance["Y"] x = instance["X"] angle = instance["Angle"] if instance[item] == "Satellite Platform": imageIndex = instance["Image Index"] platform = Platform(self.world, x, y, player=player) platform.frame = imageIndex self.levelObjects.append(platform) elif instance[item] == "Spikes": imageIndex = instance["Image Index"] sprite = None if imageIndex == 0: sprite = self.world.assetLoader.smallSpikes elif imageIndex == 2: sprite = self.world.assetLoader.bigSpikes spike = Spike(self.world, x, y, sprite=sprite, player=player) self.levelObjects.append(spike) elif instance[item] == "Checkpoint": checkpoint = Checkpoint(self.world, x, y, player=player) self.levelObjects.append(checkpoint) elif instance[item] == "Pull Orb": pass pullOrb = PullOrb(self.world, x, y, player=player, cursor=self.cursor) self.levelObjects.append(pullOrb) elif instance[item] == "Attract Tether": pass pullOrbTether = PullOrbTether(self.world, x, y, player=player) self.levelObjects.append(pullOrbTether) elif instance[item] == "End Rocket": rocket = Rocket(self.world, x, y, player=player) self.levelObjects.append(rocket) elif instance[item] == "Earth": pass elif instance[item] == "Bouncy": bouncy = Bouncy(self.world, x, y, player=player) self.levelObjects.append(bouncy) elif instance[item] == "Repel Orb": repelOrb = RepelOrb(self.world, x, y, player=player, cursor=self.cursor) self.levelObjects.append(repelOrb) return self.levelObjects
def setUp(self): self.slug = 'na' self.platform = Platform(self.slug)
def __get_stored_platforms(self): return [Platform.from_dict({"name": "1"})]
def __init__(self): Platform.__init__(self) self.platform = "huajiao" self.cache_key = cache_key() self.live_type = "" pass
if args.debug: l = logging.DEBUG if args.quiet: l = logging.CRITICAL if args.output: logging.basicConfig(filename=args.output, level=l) else: logging.basicConfig(stream=stderr, level=l) time_period = None minutes = 1 # DEFAULT - USE MINUTE BARS if args.timeframe: try: minutes = int(args.timeframe) except: logging.critical( "Please enter an integer for minutes. Exiting....") exit() if minutes < 1 or minutes > 1440: logging.critical( "Please enter a number of minutes between 1 and 1440. Exiting...." ) exit() core = Core() brain = Brain(core) platform = Platform(core, brain, minutes) platform.run()
blue = (0,0, 255) white = (255,255,255) def reinit(): global player global platform_controller global floor global camera player = Player() platform_controller = PlatformController() floor = Platform(0, SCREEN_HEIGHT-36, SCREEN_WIDTH, 36) camera = Camera(player) player = Player() platform_controller = PlatformController() floor = Platform(0, SCREEN_HEIGHT-36, SCREEN_WIDTH, 36) arrow_image = load_image("arrow.png") selected_option = 0.30 background = load_image('background.jpg') camera = Camera(player) game_state = 'Menu' game_loop = True clock = pygame.time.Clock() fps = 60 while game_loop:
global floor global camera global prev_pos players = [] for i in range(num_players): players.append(Player()) platform_controller = PlatformController() floor = Platform(0, SCREEN_HEIGHT - 36, SCREEN_WIDTH, 36, 0) camera = Camera(players[0]) players = [] for i in range(num_players): players.append(Player()) platform_controller = PlatformController() floor = Platform(0, SCREEN_HEIGHT - 36, SCREEN_WIDTH, 36, 0) arrow_image = load_image(resource_path("arrow.png")) selected_option = 0.30 background = load_image(resource_path('background.jpg')) camera = Camera(players[0]) game_state = 'Menu' game_loop = True clock = pygame.time.Clock() fps = 600 # play_mode = "Single" play_mode = "Bot"
def main(): import pygame from TitleScreen import TitleScreen from Platform import Platform from Player import Player import time import sys pygame.init() size = (1050, 650) screen = pygame.display.set_mode(size) pygame.display.set_caption("Epic Smash Siblings Omega") clock = pygame.time.Clock() # Colours black = (0, 0, 0) white = (255, 255, 255) green = (0, 255, 0) red = (255, 0, 0) blue = (0, 0, 255) yellow = (255, 255, 0) purple = (255, 0, 255) # Vars done = False def character_select(ID): p1_choose = TitleScreen(74, screen, 250, 100, "Player 1 Choose Colour.") p2_choose = TitleScreen(74, screen, 250, 100, "Player 2 Choose Colour") r = 255 g = 0 b = 0 RGB = (r, g, b) colour_rects = [ pygame.Rect(400, 200, 20, 20), pygame.Rect(450, 200, 20, 20), pygame.Rect(500, 200, 20, 20), pygame.Rect(550, 200, 20, 20), pygame.Rect(600, 200, 20, 20), pygame.Rect(500, 240, 20, 20) ] colour_list = [red, blue, green, yellow, purple, RGB] done = False while not done: if r > 0 and b == 0: r -= 5 g += 5 colour_list[5] = (r, g, b) elif g > 0 and r == 0: g -= 5 b += 5 colour_list[5] = (r, g, b) elif b > 0 and g == 0: r += 5 b -= 5 colour_list[5] = (r, g, b) if ID == 0: p1_choose.drawText() else: screen.blit(title_image, (0, 0)) p2_choose.drawText() pygame.draw.rect(screen, black, (390, 190, 240, 40)) pygame.draw.rect(screen, black, (490, 230, 40, 40)) for i in range(len(colour_rects)): if colour_rects[i].width == 40: pygame.draw.rect(screen, colour_list[i], colour_rects[i].move(-10, -10)) else: pygame.draw.rect(screen, colour_list[i], colour_rects[i]) pygame.display.update() m_pos = pygame.mouse.get_pos() for colour in colour_rects: if pygame.Rect(colour).collidepoint(m_pos[0], m_pos[1]): colour.width = 40 colour.height = 40 else: colour.width = 20 colour.height = 20 for event in pygame.event.get(): if event.type == pygame.QUIT: sys.exit() elif event.type == pygame.MOUSEBUTTONDOWN: if ID == 0: if pygame.Rect(colour_rects[0]).collidepoint( m_pos[0], m_pos[1]): players[0].colour = red click_sound.play() return elif pygame.Rect(colour_rects[1]).collidepoint( m_pos[0], m_pos[1]): players[0].colour = blue click_sound.play() return elif pygame.Rect(colour_rects[2]).collidepoint( m_pos[0], m_pos[1]): players[0].colour = green click_sound.play() return elif pygame.Rect(colour_rects[3]).collidepoint( m_pos[0], m_pos[1]): players[0].colour = yellow click_sound.play() return elif pygame.Rect(colour_rects[4]).collidepoint( m_pos[0], m_pos[1]): players[0].colour = purple click_sound.play() return elif pygame.Rect(colour_rects[5]).collidepoint( m_pos[0], m_pos[1]): players[0].is_RGB = True click_sound.play() return elif ID == 1: if pygame.Rect(colour_rects[0]).collidepoint( m_pos[0], m_pos[1]): players[1].colour = red click_sound.play() return elif pygame.Rect(colour_rects[1]).collidepoint( m_pos[0], m_pos[1]): players[1].colour = blue click_sound.play() return elif pygame.Rect(colour_rects[2]).collidepoint( m_pos[0], m_pos[1]): players[1].colour = green click_sound.play() return elif pygame.Rect(colour_rects[3]).collidepoint( m_pos[0], m_pos[1]): players[1].colour = yellow click_sound.play() return elif pygame.Rect(colour_rects[4]).collidepoint( m_pos[0], m_pos[1]): players[1].colour = purple click_sound.play() return elif pygame.Rect(colour_rects[5]).collidepoint( m_pos[0], m_pos[1]): players[1].is_RGB = True click_sound.play() return def restart(): player_1_wins = TitleScreen(74, screen, 350, 250, "Player 1 Wins!") player_2_wins = TitleScreen(74, screen, 350, 250, "Player 2 Wins!") player_1_wins.colour = (255, 0, 0) player_2_wins.colour = (255, 0, 0) screen.blit(git_gud, (0, 0)) if players[1].stock_remaining == 0: player_1_wins.drawText() elif players[0].stock_remaining == 0: player_2_wins.drawText() pygame.display.update() time.sleep(2) while True: pygame.init() screen.blit(git_gud, (0, 0)) restart_text = TitleScreen(74, screen, 350, 250, "Play again? Y/N") restart_text.drawText() pygame.display.update() for event in pygame.event.get(): if event.type == pygame.QUIT: sys.exit() elif event.type == pygame.KEYDOWN: if event.key == pygame.K_y: main() elif event.key == pygame.K_n: sys.exit() # Platforms platforms = [ Platform(screen, black, 275, 450, 500, 40), Platform(screen, black, 325, 350, 125, 10), Platform(screen, black, 465, 250, 125, 10), Platform(screen, black, 600, 350, 125, 10) ] # Main background image background_image = pygame.image.load('main_background.jpeg').convert() # Players players = [ Player(screen, red, 300, 400, 20, 40, platforms, 0), Player(screen, green, 725, 400, 20, 40, platforms, 1) ] player_1_text = TitleScreen(24, screen, 160, 600, "Player 1's stock:") player_2_text = TitleScreen(24, screen, 460, 600, "Player 2's stock:") player_1_health = TitleScreen(24, screen, 160, 550, "Player 1's Health:") player_2_health = TitleScreen(24, screen, 460, 550, "Player 2's Health:") player_info = [ player_1_text, player_1_health, player_2_text, player_2_health ] # Title screen click_sound = pygame.mixer.Sound("select_noise.wav") pygame.mixer.music.load('title_screen_theme.wav') pygame.mixer.music.play(-1, 0.0) title_image = pygame.image.load('smash_cover.jpg').convert() title_image.set_colorkey(white) play_button = TitleScreen(48, screen, 350, 575, "Press any key to play!") play_button.colour = black git_gud = pygame.image.load('git gud.png').convert() screen.fill(white) screen.blit(title_image, (0, 0)) pygame.display.update() character_select(0) character_select(1) play_button.drawText() pygame.display.update() play_button.waitForPlayerToPressKey() click_sound.play() pygame.mixer.music.stop() pygame.mixer.music.load('playing_theme.wav') pygame.mixer.music.play(-1, 0.0) # -------- Main Program Loop ----------- while not done: # --- Main event loop # --- All events are detected here for event in pygame.event.get(): if event.type == pygame.QUIT: sys.exit() if event.type == pygame.KEYDOWN: if event.key == pygame.K_a: players[0].x_speed = -3 players[0].direction = "LEFT" if event.key == pygame.K_d: players[0].x_speed = 3 players[0].direction = "RIGHT" if event.key == pygame.K_w: if players[0].jumps_available > 0: players[0].jumping = True if event.key == pygame.K_SPACE: players[0].attacking = True if event.key == pygame.K_LEFT: players[1].x_speed = -3 players[1].direction = "LEFT" if event.key == pygame.K_RIGHT: players[1].x_speed = 3 players[1].direction = "RIGHT" if event.key == pygame.K_UP: if players[1].jumps_available > 0: players[1].jumping = True if event.key == pygame.K_KP_ENTER: players[1].attacking = True if event.type == pygame.KEYUP: if event.key == pygame.K_a: players[0].x_speed = 0 if event.key == pygame.K_d: players[0].x_speed = 0 if event.key == pygame.K_SPACE: players[0].attacking = False if event.key == pygame.K_LEFT: players[1].x_speed = 0 if event.key == pygame.K_RIGHT: players[1].x_speed = 0 if event.key == pygame.K_KP_ENTER: players[1].attacking = False # --- Game logic should go here for player in players: player.Move() if player == players[0]: player.die(300) else: player.die(725) if player.stock_remaining == 0: done = True # --- Screen-clearing code goes here screen.fill(white) # --- Drawing code should go here # Background screen.blit(background_image, (0, 0)) # Platforms for platform in platforms: platform.draw_platform() # Players for player in players: player.draw() player.attack(players) # Stocks for text in player_info: text.drawText() players[0].draw_health_bar(300) players[1].draw_health_bar(600) for player in players: for i in range(player.stock_remaining): if player == players[0]: pygame.draw.rect(screen, player.colour, (300 + (30 * i), 600, 20, 20)) else: pygame.draw.rect(screen, player.colour, (600 + (30 * i), 600, 20, 20)) # --- Go ahead and update the screen with what we've drawn. pygame.display.flip() # --- Limit to 60 frames per second clock.tick(60) # Game over restart() return
def __init__(self): Platform.__init__(self) self.platform = "douyu"
def test_from_dict_performs_mappings(self): d = {"name": "name", "description": "description"} result = Platform.from_dict(d) self.assertEqual(d["name"], result.name) self.assertEqual(d["description"], result.description)
def get_platforms(self): """Get a list of platforms :returns: A list of type Platform of all stored platforms """ result = self.__db.platforms.find().sort("_Platform__name") return list(map(lambda p: Platform.from_mongo_result(p), result))
def test_from_dict_returns_platform(self): result = Platform.from_dict({"":""}) self.assertIsInstance(result, Platform)
class TestPlatform(unittest.TestCase): def setUp(self): self.slug = 'na' self.platform = Platform(self.slug) def test_count_and_has_url(self): self.assertEqual(self.platform.count, 0) self.assertFalse(self.platform.has_url()) self.platform.add_data({'url': match_url_template.format(matchid=1)}) self.assertEqual(self.platform.count, 1) self.assertTrue(self.platform.has_url()) self.platform.add_data( {'url': summoner_url_template.format(name=fake_name)}) self.assertEqual(self.platform.count, 2) self.assertTrue(self.platform.has_url()) self.platform.add_data({'url': static_champions_url}) self.assertEqual(self.platform.count, 3) self.assertTrue(self.platform.has_url()) self.platform.get() self.assertEqual(self.platform.count, 2) self.assertTrue(self.platform.has_url()) self.platform.get() self.assertEqual(self.platform.count, 1) self.assertTrue(self.platform.has_url()) self.platform.get() self.assertEqual(self.platform.count, 0) self.assertFalse(self.platform.has_url()) def test_rate_limit_ok(self): url = match_url_template.format(matchid=1) self.assertTrue(self.platform.rate_limit_ok()) self.platform.add_data({'url': match_url_template.format(matchid=1)}) self.platform.handle_response_headers(url, headers) self.assertTrue(self.platform.rate_limit_ok()) new_headers = copy.copy(headers) new_headers['X-App-Rate-Limit'] = "1:0.01" new_headers['X-App-Rate-Limit-Count'] = "1:0.01" new_headers['X-Method-Rate-Limit'] = "5:1" new_headers['X-Method-Rate-Limit-Count'] = "1:1" self.platform.handle_response_headers(url, new_headers) self.assertFalse(self.platform.rate_limit_ok()) time.sleep(0.01) self.assertTrue(self.platform.rate_limit_ok()) self.platform.get() self.assertFalse(self.platform.rate_limit_ok()) def test_handle_response_headers(self): url = match_url_template.format(matchid=1) endpoint_str = Endpoint.identify_endpoint(url) self.assertRaises(Exception, self.platform.handle_response_headers, (url, headers)) self.platform.add_data({'url': url}) self.assertEqual(self.platform.platform_limits, {}) self.platform.handle_response_headers(url, headers) self.assertEqual(len(self.platform.platform_limits), 2) self.assertEqual(self.platform.platform_limits["1"].cap, 20) self.assertEqual(self.platform.platform_limits["1"].seconds, 1) self.assertEqual(self.platform.platform_limits["1"].used, 1) self.assertEqual(self.platform.platform_limits["120"].cap, 100) self.assertEqual(self.platform.platform_limits["120"].seconds, 120) self.assertEqual(self.platform.platform_limits["120"].used, 1) self.assertEqual(len(self.platform.limited_endpoints), 1) self.assertEqual( self.platform.limited_endpoints[endpoint_str].limits["60"].cap, 270) self.assertEqual( self.platform.limited_endpoints[endpoint_str].limits["60"].seconds, 60) self.assertEqual( self.platform.limited_endpoints[endpoint_str].limits["60"].used, 1) new_headers = copy.copy(headers) new_headers['X-App-Rate-Limit'] = "1:1" new_headers['X-App-Rate-Limit-Count'] = "1:1" new_headers['X-Method-Rate-Limit'] = "5:1" new_headers['X-Method-Rate-Limit-Count'] = "1:1" self.platform.handle_response_headers(url, new_headers) self.assertEqual(len(self.platform.platform_limits), 1) self.assertEqual(self.platform.platform_limits["1"].cap, 1) self.assertEqual(self.platform.platform_limits["1"].seconds, 1) self.assertEqual(self.platform.platform_limits["1"].used, 1) self.assertEqual(len(self.platform.limited_endpoints), 1) self.assertEqual( self.platform.limited_endpoints[endpoint_str].limits["1"].cap, 5) self.assertEqual( self.platform.limited_endpoints[endpoint_str].limits["1"].seconds, 1) self.assertEqual( self.platform.limited_endpoints[endpoint_str].limits["1"].used, 1) def test_add_data_static_random(self): s1 = {'url': static_champions_url} s2 = {'url': static_summoner_spells_url} s3 = {'url': static_items_url} s = [s1, s2, s3] self.platform.add_data(s1) self.platform.add_data(s2) self.platform.add_data(s3) self.assertEqual(self.platform.static_count, 3) self.assertTrue(self.platform.get() in s) self.assertTrue(self.platform.get() in s) self.assertTrue(self.platform.get() in s) self.assertRaises(Exception, self.platform.get) def test_add_data_static_sorted(self): c1 = {'url': static_champion_url.format(id=1)} c2 = {'url': static_champion_url.format(id=2)} c3 = {'url': static_champion_url.format(id=3)} self.platform.add_data(c1) self.platform.add_data(c2) self.platform.add_data(c3) self.assertEqual(self.platform.static_count, 3) self.assertEqual(self.platform.get(), c1) self.assertEqual(self.platform.get(), c2) self.assertEqual(self.platform.get(), c3) self.assertRaises(Exception, self.platform.get) def test_add_data_static_sorted_atFront(self): c1 = {'url': static_champion_url.format(id=1)} c2 = {'url': static_champion_url.format(id=2)} c3 = {'url': static_champion_url.format(id=3)} self.platform.add_data(c1, front=True) self.platform.add_data(c2, front=True) self.platform.add_data(c3, front=True) self.assertEqual(self.platform.static_count, 3) self.assertEqual(self.platform.get(), c3) self.assertEqual(self.platform.get(), c2) self.assertEqual(self.platform.get(), c1) self.assertRaises(Exception, self.platform.get) def test_add_data_limited_alternate(self): m1 = {'url': match_url_template.format(matchid=1)} m2 = {'url': match_url_template.format(matchid=2)} m3 = {'url': match_url_template.format(matchid=3)} s1 = {'url': summoner_url_template.format(name=1)} s2 = {'url': summoner_url_template.format(name=2)} s3 = {'url': summoner_url_template.format(name=3)} self.platform.add_data(m1) self.platform.add_data(m2) self.platform.add_data(m3) self.platform.add_data(s1) self.platform.add_data(s2) self.platform.add_data(s3) self.assertEqual(self.platform.limited_count, 6) self.assertEqual(self.platform.get(), m1) self.assertEqual(self.platform.get(), s1) self.assertEqual(self.platform.get(), m2) self.assertEqual(self.platform.get(), s2) self.assertEqual(self.platform.get(), m3) self.assertEqual(self.platform.get(), s3) self.assertRaises(Exception, self.platform.get) def test_add_data_limited_sorted(self): m1 = {'url': match_url_template.format(matchid=1)} m2 = {'url': match_url_template.format(matchid=2)} m3 = {'url': match_url_template.format(matchid=3)} self.platform.add_data(m1) self.platform.add_data(m2) self.platform.add_data(m3) self.assertEqual(self.platform.limited_count, 3) self.assertEqual(self.platform.get(), m1) self.assertEqual(self.platform.get(), m2) self.assertEqual(self.platform.get(), m3) self.assertRaises(Exception, self.platform.get) def test_add_data_limited_sorted_atFront(self): m1 = {'url': match_url_template.format(matchid=1)} m2 = {'url': match_url_template.format(matchid=2)} m3 = {'url': match_url_template.format(matchid=3)} self.platform.add_data(m1, front=True) self.platform.add_data(m2, front=True) self.platform.add_data(m3, front=True) self.assertEqual(self.platform.limited_count, 3) self.assertEqual(self.platform.get(), m3) self.assertEqual(self.platform.get(), m2) self.assertEqual(self.platform.get(), m1) self.assertRaises(Exception, self.platform.get) def test_available(self): self.assertFalse(self.platform.available()) static_data_1 = {'url': static_items_url} limited_data_1 = {'url': match_url_template.format(matchid=100)} limited_data_2 = {'url': match_url_template.format(matchid=200)} self.platform.add_data(static_data_1) self.assertTrue(self.platform.available()) self.platform.get() self.assertFalse(self.platform.available()) self.platform.add_data(limited_data_1) self.assertTrue(self.platform.available()) self.platform.add_data(limited_data_2) self.platform.get() self.assertTrue(self.platform.available()) # No response headers yet new_headers = copy.copy(headers) new_headers['X-Method-Rate-Limit'] = '1:0.1' new_headers['X-Method-Rate-Limit-Count'] = '1:0.1' self.platform.handle_response_headers( match_url_template.format(matchid=100), new_headers, 200) self.assertFalse(self.platform.available()) time.sleep(0.1) self.assertTrue(self.platform.available()) def test_handle_delay(self): limited_data_1 = {'url': match_url_template.format(matchid=100)} limited_data_2 = {'url': match_url_template.format(matchid=200)} self.platform.add_data(limited_data_1) self.platform.add_data(limited_data_2) self.assertTrue(self.platform.available()) self.platform.get() new_headers = get_date_header() new_headers['X-Method-Rate-Limit'] = '2:0.1' new_headers['X-Method-Rate-Limit-Count'] = '1:0.1' self.platform.handle_response_headers( match_url_template.format(matchid=100), new_headers, 429) self.assertFalse( self.platform.available()) # Should have a default delay time.sleep(1) self.assertTrue(self.platform.available()) def test_get_usage(self): used = {'static': {}, 'limited': {}} self.assertEqual(self.platform.get_usage(), used) url = match_url_template.format(matchid=100) match_endpoint = Endpoint.identify_endpoint(url) used['limited'][match_endpoint] = 'No limits defined' self.platform.add_data({'url': url}) self.assertEqual(self.platform.get_usage(), used) self.platform.handle_response_headers(url, headers) used['limited'][match_endpoint] = '1:270' self.assertEqual(self.platform.get_usage(), used) self.platform.get() used['limited'][match_endpoint] = '2:270' self.assertEqual(self.platform.get_usage(), used) # Static tests static_endpoint = Endpoint.identify_endpoint(static_champions_url) self.platform.add_data({'url': static_champions_url}) used['static'][static_endpoint] = 'No limits defined' self.assertEqual(self.platform.get_usage(), used) self.platform.get() new_headers = copy.copy(headers) new_headers['X-Method-Rate-Limit-Count'] = '1:60,2:120' new_headers['X-Method-Rate-Limit'] = '7:60,10:120' used['static'][static_endpoint] = '1:7,2:10' self.platform.handle_response_headers(static_champions_url, new_headers)
import simpy import World as w from Perception import Event as e from Platform import Platform as plat, PlatformTask as platTask from matplotlib import pyplot as plt """create simulation objects""" env = simpy.Environment() simpleWorld = w.World(3, 3, env) simpleTask = platTask.PlatformTask('A3') platform1 = plat.Platform('platform 1', env, simpleWorld) """1.create world model(s)""" platform1.WM.createArea(3, 3, 0, 'A') platform1.WM.createArea(1.5, 1.5, 1, 'A1') platform1.WM.createArea(1.5, 1.5, 1, 'A2') platform1.WM.createArea(1.5, 1.5, 1, 'A3') platform1.WM.containArea('A', 'A1', [-0.75, -0.75]) platform1.WM.containArea('A', 'A2', [-0.75, 0.75]) platform1.WM.containArea('A', 'A3', [0.75, 0.75]) platform1.WM.linkAreas('A1', 'A2') platform1.WM.linkAreas('A2', 'A3') platform1.WM.setStartingArea('A1') simpleWorld.setAreaList(platform1.WM.areaList) """2. give tasks""" platform1.giveTask(simpleTask) """3. generate paths""" """4. generate plans""" platform1.plan.addState('start', None, None) platform1.plan.addState('PS1', 'waiting in', 'A1')
def __get_suggested_platforms(self): return [Platform.from_dict({"name": "1"}), Platform.from_dict({"name": "2"})]
def __init__(self): Platform.__init__(self) self.platform = "panda"
class Navigation(avango.script.Script): ## Default constructor. def __init__(self): self.super(Navigation).__init__() ## Custom constructor. # @param SCENEGRAPH Reference to the scenegraph in which the navigation should take place. # @param PLATFORM_SIZE Physical size of the platform in meters. Passed in an two-element list: [width, depth] # @param STARTING_MATRIX Initial position matrix of the platform to be created. # @param NAVIGATION_LIST List of all navigations in the setup. # @param INPUT_SENSOR_TYPE String indicating the type of input device to be created, e.g. "XBoxController" or "Spheron" # @param INPUT_SENSOR_NAME Name of the input device sensor as chosen in daemon. # @param NO_TRACKING_MAT Matrix which should be applied if no tracking is available. # @param GF_SETTINGS Setting list for the GroundFollowing instance: [activated, ray_start_height] # @param ANIMATE_COUPLING Boolean indicating if an animation should be done when a coupling of navigations is initiated. # @param MOVEMENT_TRACES Boolean indicating if the device should leave traces behind. # @param TRACKING_TARGET_NAME Name of the device's tracking target name as chosen in daemon. def my_constructor(self, SCENEGRAPH, PLATFORM_SIZE, STARTING_MATRIX, NAVIGATION_LIST, INPUT_SENSOR_TYPE, INPUT_SENSOR_NAME, NO_TRACKING_MAT, GF_SETTINGS, ANIMATE_COUPLING, MOVEMENT_TRACES, TRACKING_TARGET_NAME = None): ## @var SCENEGRAPH # Reference to the scenegraph. self.SCENEGRAPH = SCENEGRAPH ## @var coupled_navigations # List of coupled Navigation instances to which this Navigation's changes are forwarded to. self.coupled_navigations = [] ## @var input_sensor_type # String indicating the type of input device to be created, e.g. "XBoxController" or "Spheron" self.input_sensor_type = INPUT_SENSOR_TYPE ## @var start_matrix # Initial position matrix of the platform. self.start_matrix = STARTING_MATRIX # create device ## @var device # Device instance handling relative inputs of physical device. if self.input_sensor_type == "Spheron": self.device = OldSpheronDevice() self.device.my_constructor(INPUT_SENSOR_NAME, TRACKING_TARGET_NAME, NO_TRACKING_MAT) elif self.input_sensor_type == "XBoxController": self.device = XBoxDevice() self.device.my_constructor(INPUT_SENSOR_NAME, TRACKING_TARGET_NAME, NO_TRACKING_MAT) elif self.input_sensor_type == "KeyboardMouse": self.device = KeyboardMouseDevice() self.device.my_constructor() elif self.input_sensor_type == "Spacemouse": self.device = SpacemouseDevice() self.device.my_constructor(INPUT_SENSOR_NAME) # create ground following ## @var groundfollowing # GroundFollowing instance to correct the absolute matrices with respect to gravity. self.groundfollowing = GroundFollowing() self.groundfollowing.my_constructor(self.SCENEGRAPH, self.device.sf_station_mat, GF_SETTINGS) # create input mapping ## @var inputmapping # InputMapping instance to process and map relative device inputs to an absolute matrix. self.inputmapping = InputMapping() self.inputmapping.my_constructor(self, self.device, self.groundfollowing, STARTING_MATRIX) self.inputmapping.set_input_factors(self.device.translation_factor, self.device.rotation_factor) # create platform ## @var platform # Platform instance that is controlled by the Device. self.platform = Platform() self.platform.my_constructor(self.SCENEGRAPH, PLATFORM_SIZE, self.inputmapping, len(NAVIGATION_LIST)) ## @var NAVIGATION_LIST # Reference to a list containing all Navigation instances in the setup. self.NAVIGATION_LIST = NAVIGATION_LIST # attributes ## @var in_dofchange_animation # Boolean variable to indicate if a movement animation for a DOF change (realistic/unrealistic) is in progress. self.in_dofchange_animation = False ## @var frames_since_last_dofchange # Framecount to make realistic/unrealistic switch on one button. Switching again is possible after x frames. self.frames_since_last_dofchange = 0 ## @var frames_since_last_coupling # Framecount since the last coupling / decoupling operation was done. Used to make functionality on one button. self.frames_since_last_coupling = 0 ## @var in_coupling_animation # Boolean variable to indicate if a movement animation for coupling is in progress. self.in_coupling_animation = False ## @var timer # Instance of TimeSensor to handle the duration of animations. self.timer = avango.nodes.TimeSensor() ## @var ANIMATE_COUPLING # Boolean indicating if an animation should be done when a coupling of navigations is initiated. self.ANIMATE_COUPLING = ANIMATE_COUPLING ## @var movement_traces # Boolean indicating if the movement traces should be visualized by line segments. self.movement_traces = MOVEMENT_TRACES ## @var trace # The trace class that handles the line segment updating. self.trace = None # evaluate every frame self.always_evaluate(True) ## Resets the platform's matrix to the initial value. def reset(self): self.inputmapping.set_abs_mat(self.start_matrix) ## Sets platform to new start position def set_to_pos(self, NEWPOS): self.start_matrix = NEWPOS self.reset() ## Activates 3-DOF (realistic) navigation mode. def activate_realistic_mode(self): # remove pitch and roll from current orientation _current_mat = self.platform.sf_abs_mat.value _current_trans = _current_mat.get_translate() _current_yaw = Tools.get_yaw(_current_mat) ## @var start_rot # Quaternion representing the start rotation of the animation self.start_rot = self.platform.sf_abs_mat.value.get_rotate() ## @var target_rot # Quaternion representing the target rotation of the animation self.target_rot = avango.gua.make_rot_mat(math.degrees(_current_yaw), 0, 1, 0).get_rotate() ## @var animation_time # Time of the rotation animation in relation to the rotation distance. self.animation_time = 2 * math.sqrt(math.pow(self.start_rot.x - self.target_rot.x, 2) + math.pow(self.start_rot.y - self.target_rot.y, 2) + math.pow(self.start_rot.z - self.target_rot.z, 2) + math.pow(self.start_rot.w - self.target_rot.w, 2)) # if no animation is needed, set animation time to a minimum value to avoid division by zero if self.animation_time == 0.0: self.animation_time = 0.01 ## @var start_trans # Starting translation vector of the animation. self.start_trans = _current_trans ## @var animation_start_time # Point in time where the animation started. self.animation_start_time = self.timer.Time.value self.in_dofchange_animation = True ## Animates the removal of pitch and roll angles when switching from 6-DOF (unrealistic) to 3-DOF (realistic) navigation mode. def animate_dofchange(self): _current_time = self.timer.Time.value _slerp_ratio = (_current_time - self.animation_start_time) / self.animation_time if _slerp_ratio > 1: _slerp_ratio = 1 self.in_dofchange_animation = False self.inputmapping.activate_realistic_mode() self.frames_since_last_dofchange = 0 _transformed_quat = self.start_rot.slerp_to(self.target_rot, _slerp_ratio) _position_yaw_mat = avango.gua.make_trans_mat(self.start_trans.x, self.start_trans.y, self.start_trans.z) * \ avango.gua.make_rot_mat(_transformed_quat) self.inputmapping.set_abs_mat(_position_yaw_mat) ## Activates 6-DOF (unrealistic) navigation mode. def deactivate_realistic_mode(self): self.inputmapping.deactivate_realistic_mode() self.frames_since_last_dofchange = 0 ## Bidirectional coupling of this and another navigation. # @param NAVIGATION The Navigation to be coupled. def couple_navigation(self, NAVIGATION): if not ((NAVIGATION in self.coupled_navigations) or (self in NAVIGATION.coupled_navigations)): for _nav in self.coupled_navigations: if not (NAVIGATION in _nav.coupled_navigations): _nav.coupled_navigations.append(NAVIGATION) if not (_nav in NAVIGATION.coupled_navigations): NAVIGATION.coupled_navigations.append(_nav) for _nav in NAVIGATION.coupled_navigations: if not (self in _nav.coupled_navigations): _nav.coupled_navigations.append(self) if not (_nav in self.coupled_navigations): self.coupled_navigations.append(_nav) self.coupled_navigations.append(NAVIGATION) NAVIGATION.coupled_navigations.append(self) ## Bidirectional decoupling of this and another navigation. # @param NAVIGATION The Navigation to be decoupled. def decouple_navigation(self, NAVIGATION): if NAVIGATION in self.coupled_navigations: self.coupled_navigations.remove(NAVIGATION) NAVIGATION.coupled_navigations.remove(self) ## Triggers the coupling mechanism. # When other platforms are close enough, they are coupled to each other. def trigger_coupling(self): self.frames_since_last_coupling = 0 # list containing the navigataions close enough to couple _close_navs = [] # threshold when two navigations should be considered for coupling (distance in meter) _threshold = 7.0 # compute center position of own platform _position_self = (self.platform.sf_abs_mat.value * self.device.sf_station_mat.value).get_translate() # check for all navigations in the setup for _nav in self.NAVIGATION_LIST: # compute center position of currently iterated platform _position_nav = (_nav.platform.sf_abs_mat.value * _nav.device.sf_station_mat.value).get_translate() # append navigation to the list of close ones if distance is smaller than a threshold if _nav != self and Tools.euclidean_distance(_position_self, _position_nav) < _threshold: _close_navs.append(_nav) # sort list of close navs, highest distance first _close_navs.sort(key = lambda _nav: Tools.euclidean_distance(_position_self, (_nav.platform.sf_abs_mat.value * _nav.device.sf_station_mat.value).get_translate()), reverse = True) if len(_close_navs) > 0: # couple the close navigations for _nav in _close_navs: self.couple_navigation(_nav) if self.ANIMATE_COUPLING: # do an animation to closest navigation if this functionality is switched on _nav_animation_target = _close_navs[-1] self.set_coupling_animation_settings(_nav_animation_target) for i in range(len(_close_navs) - 1): _close_navs[i].set_coupling_animation_settings(_nav_animation_target) print "Coupling of platform " + str(self.platform.platform_id) + " successfully initiated." else: print "No platform in range for coupling." self.frames_since_last_coupling = 0 ## Sets all the necessary attributes to perform a lerp and slerp animation to another navigation. # @param TARGET_NAVIGATION The Navigation instance to animate to. def set_coupling_animation_settings(self, TARGET_NAVIGATION): self.start_rot = self.platform.sf_abs_mat.value.get_rotate() self.start_trans = self.platform.sf_abs_mat.value.get_translate() _start_rot_center_mat = self.platform.sf_abs_mat.value * self.device.sf_station_mat.value _target_rot_center_mat = TARGET_NAVIGATION.platform.sf_abs_mat.value * TARGET_NAVIGATION.device.sf_station_mat.value _difference_vector = _target_rot_center_mat.get_translate() - _start_rot_center_mat.get_translate() _difference_vector.y = 0.0 self.target_rot = self.start_rot #self.target_rot = avango.gua.make_rot_mat(math.degrees(Tools.get_yaw(_target_rot_center_mat)), 0, 1, 0).get_rotate() self.target_trans = self.start_trans + _difference_vector self.animation_time = 0.5 * math.sqrt(math.pow(self.start_trans.x - self.target_trans.x, 2) + math.pow(self.start_trans.y - self.target_trans.y, 2) + math.pow(self.start_trans.z - self.target_trans.z, 2)) + \ math.sqrt(math.pow(self.start_rot.x - self.target_rot.x, 2) + math.pow(self.start_rot.y - self.target_rot.y, 2) + math.pow(self.start_rot.z - self.target_rot.z, 2) + math.pow(self.start_rot.w - self.target_rot.w, 2)) # if no animation is needed, set animation time to a minimum value to avoid division by zero if self.animation_time == 0.0: self.animation_time = 0.01 self.animation_start_time = self.timer.Time.value self.in_coupling_animation = True ## Animates the movement to another platform during the coupling process. def animate_coupling(self): _current_time = self.timer.Time.value _animation_ratio = (_current_time - self.animation_start_time) / self.animation_time if _animation_ratio > 1: _animation_ratio = 1 self.in_coupling_animation = False self.frames_since_last_coupling = 0 _transformed_quat = self.start_rot.slerp_to(self.target_rot, _animation_ratio) _transformed_vec = self.start_trans.lerp_to(self.target_trans, _animation_ratio) _animation_mat = avango.gua.make_trans_mat(_transformed_vec.x, _transformed_vec.y, _transformed_vec.z) * \ avango.gua.make_rot_mat(_transformed_quat) self.inputmapping.set_abs_mat(_animation_mat) ## Decouples this Navigation from all coupled Navigations. def clear_couplings(self): if len(self.coupled_navigations) > 0: # create hard copy of coupled navigations _couplings = list(self.coupled_navigations) # iterate over all navigations and clear the coupling for _nav in _couplings: _nav.decouple_navigation(self) self.coupled_navigations = [] self.frames_since_last_coupling = 0 print "Cleared couplings of platform " + str(self.platform.platform_id) ## Switches from realistic to unrealistic or from unrealistic to realistic mode on this # and all other coupled instances. def trigger_dofchange(self): # if in realistic mode, switch to unrealistic mode if self.inputmapping.realistic == True: self.deactivate_realistic_mode() for _navigation in self.coupled_navigations: _navigation.deactivate_realistic_mode() # if in unrealistic mode, switch to realistic mode else: self.activate_realistic_mode() for _navigation in self.coupled_navigations: _navigation.activate_realistic_mode() ## Evaluated every frame. def evaluate(self): # increase frame counters self.frames_since_last_dofchange = self.frames_since_last_dofchange + 1 self.frames_since_last_coupling = self.frames_since_last_coupling + 1 # handle visibilities self.platform.platform_transform_node.GroupNames.value = [] for _nav in self.coupled_navigations: self.platform.platform_transform_node.GroupNames.value.append("couple_group_" + str(_nav.platform.platform_id)) # handle button inputs if self.input_sensor_type == "Spheron" or self.input_sensor_type == "KeyboardMouse": # left mouse button (Spheron) or R-key (KeyboardMouse) resets platform if self.device.mf_buttons.value[1] == True: self.reset() for _navigation in self.coupled_navigations: _navigation.reset() # right mouse button (Spheron) or H-key (KeyboardMouse) triggers switch between # realistic (3 DOF) and unrealistic (6 DOF) mode if self.device.mf_buttons.value[0] == True: if self.frames_since_last_dofchange > 100: # at least 100 frames must lie between two dofchanges self.trigger_dofchange() # middle mouse button (Spheron) or G-key (KeyboardMouse) triggers coupling if self.device.mf_buttons.value[2] == True: if self.frames_since_last_coupling > 100: # at least 100 frames must lie between two coupling actions if len(self.coupled_navigations) == 0: self.trigger_coupling() else: self.clear_couplings() elif self.input_sensor_type == "XBoxController": # X Button resets platform if self.device.mf_buttons.value[2] == True: self.reset() for _navigation in self.coupled_navigations: _navigation.reset() # A Button triggers switch between realistic (3 DOF) and unrealistic (6 DOF) mode if self.device.mf_buttons.value[0] == True: if self.frames_since_last_dofchange > 100: # at least 100 frames must lie between two dofchanges self.trigger_dofchange() # B Button triggers coupling if self.device.mf_buttons.value[1] == True: if self.frames_since_last_coupling > 100: # at least 100 frames must lie between two coupling actions if len(self.coupled_navigations) == 0: self.trigger_coupling() else: self.clear_couplings() elif self.input_sensor_type == "Spacemouse": # left button triggers switch between realistic (3 DOF) and unrealistic (6 DOF) mode if self.device.mf_buttons.value[0] == True: if self.frames_since_last_dofchange > 100: # at least 100 frames must lie between two dofchanges self.trigger_dofchange() # right button triggers coupling if self.device.mf_buttons.value[1] == True: if self.frames_since_last_coupling > 100: # at least 100 frames must lie between two coupling actions if len(self.coupled_navigations) == 0: self.trigger_coupling() else: self.clear_couplings() # handle dofchange animation if self.in_dofchange_animation: self.animate_dofchange() # handle coupling animation elif self.in_coupling_animation: self.animate_coupling() # draw the traces if enabled #if self.movement_traces: # _station_trans = self.device.sf_station_mat.value.get_translate() # _mat = self.platform.sf_abs_mat.value * avango.gua.make_trans_mat(_station_trans.x, 0, _station_trans.z) # if self.trace == None: # self.trace = TraceLines.Trace(self.SCENEGRAPH.Root.value, self.platform.platform_id, 20, _mat) # self.trace.update(_mat)
from subprocess import call from button import Button from player import Player from Enemy import Enemy from AeroEnemy import AeroEnemy from Projectile import Projectile from Platform import Platform import pygame index = 0 with open("currentLevel", "r") as f: try: index = int(f.readline()) print(index) except Exception as e: print(e) if index == 1: level = [[AeroEnemy(100, 240, 64, 64)], [Enemy(200, 580, 64, 64), Enemy(300, 580, 64, 64)], Player(680, 580, 64, 64), [Platform(480, 540, 200, 25, (0, 255, 0)), Platform(100, 500, 200, 25, (0, 255, 0)), Platform(550, 400, 200, 25, (0, 221, 0))], pygame.image.load('background/maxresdefault2.jpg')] else: level = [[AeroEnemy(100, 240, 64, 64)], [Enemy(200, 620, 64, 64)], Player(680, 620, 64, 64), [Platform(500, 540, 200, 25, (0, 255, 0)), Platform(100, 500, 200, 25, (0, 255, 0)), Platform(550, 400, 200, 25, (0, 221, 0))], pygame.image.load('background/maxresdefault.jpg')]
def loadWorld_11(self): tmxData = load_pygame("worlds/1-1/W11.tmx") self.mapSize = (tmxData.width, tmxData.height) self.sky = pg.Surface((WINDOW_W, WINDOW_H)) self.sky.fill((pg.Color('#5c94fc'))) # 2D List self.map = [[0] * tmxData.height for i in range(tmxData.width)] layer_num = 0 for layer in tmxData.visible_layers: for y in range(tmxData.height): for x in range(tmxData.width): # Getting pygame surface image = tmxData.get_tile_image(x, y, layer_num) # It's none if there are no tile in that place if image is not None: tileID = tmxData.get_tile_gid(x, y, layer_num) if layer.name == 'Foreground': # 22 ID is a question block, so in taht case we shoud load all it's images if tileID == 22: image = ( image, # 1 tmxData.get_tile_image(0, 15, layer_num), # 2 tmxData.get_tile_image(1, 15, layer_num), # 3 tmxData.get_tile_image( 2, 15, layer_num) # activated ) # Map class has 1)"map" list, which is used in collision system because we can # easily get block by x and y coordinate 2)"obj", "obj_bg" and simular arrays - # they are used in rendering because you don't need to cycle through every # (x, y) pair. Here we are adding the same platform object in 2 different arrays. self.map[x][y] = Platform(x * tmxData.tileheight, y * tmxData.tilewidth, image, tileID) self.obj.append(self.map[x][y]) elif layer.name == 'Background': self.map[x][y] = BGObject(x * tmxData.tileheight, y * tmxData.tilewidth, image) self.obj_bg.append(self.map[x][y]) layer_num += 1 # Tubes self.spawn_tube(28, 10) self.spawn_tube(37, 9) self.spawn_tube(46, 8) self.spawn_tube(55, 8) self.spawn_tube(163, 10) self.spawn_tube(179, 10) # Mobs self.mobs.append(Goombas(736, 352, False)) self.mobs.append(Goombas(1295, 352, True)) self.mobs.append(Goombas(1632, 352, False)) self.mobs.append(Goombas(1672, 352, False)) self.mobs.append(Goombas(5570, 352, False)) self.mobs.append(Goombas(5620, 352, False)) self.map[21][8].bonus = 'mushroom' self.map[78][8].bonus = 'mushroom' self.map[109][4].bonus = 'mushroom' self.flag = Flag(6336, 48)
def __init__(self): Platform.__init__(self) self.platform = "bilibili"
class Navigation(avango.script.Script): # input fields ## @var sf_reset_trigger # Boolean field to indicate if the platform is to be reset. sf_reset_trigger = avango.SFBool() ## @var sf_coupling_trigger # Boolean field to indicate if the coupling mechanism is to be triggered. sf_coupling_trigger = avango.SFBool() ## @var sf_dof_trigger # Boolean field to indicate if the change of the dof mode is to be triggered. sf_dof_trigger = avango.SFBool() # static class variables ## @var trace_materials # List of material pretexts to choose from when a trace is created. All avatars on this # platform will have this material. trace_materials = ['AvatarBlue', 'AvatarCyan', 'AvatarGreen', 'AvatarMagenta', 'AvatarDarkGreen', 'AvatarOrange', 'AvatarRed', 'AvatarWhite', 'AvatarYellow', 'AvatarGrey'] ## @var material_used # List of booleans to indicate if a material in trace_materials was already used. material_used = [False, False, False, False, False, False, False, False, False, False] ## Default constructor. def __init__(self): self.super(Navigation).__init__() # if every material has already been used, reset the pool _reset_pool = True for _boolean in Navigation.material_used: if _boolean == False: _reset_pool = False break if _reset_pool: Navigation.material_used = [False, False, False, False, False, False, False, False, False, False] # get a random material from the pool of materials _random_material_number = random.randint(0, len(Navigation.trace_materials) - 1) # if the material is already used, go further until the first unused one is found while Navigation.material_used[_random_material_number] == True: _random_material_number = (_random_material_number + 1) % len(Navigation.material_used) # get the selected material ## @var trace_material # The material to be used for the movement traces. self.trace_material = Navigation.trace_materials[_random_material_number] Navigation.material_used[_random_material_number] = True ## Custom constructor. # @param NET_TRANS_NODE Reference to the net matrix node in the scenegraph for distribution. # @param SCENEGRAPH Reference to the scenegraph in which the navigation should take place. # @param PLATFORM_SIZE Physical size of the platform in meters. Passed in an two-element list: [width, depth] # @param SCALE Start scaling of the platform. # @param STARTING_MATRIX Initial position matrix of the platform to be created. # @param NAVIGATION_LIST List of all navigations in the setup. # @param INPUT_SENSOR_TYPE String indicating the type of input device to be created, e.g. "XBoxController" or "OldSpheron" # @param INPUT_SENSOR_NAME Name of the input device sensor as chosen in daemon. # @param NO_TRACKING_MAT Matrix which should be applied if no tracking is available. # @param GF_SETTINGS Setting list for the GroundFollowing instance: [activated, ray_start_height] # @param ANIMATE_COUPLING Boolean indicating if an animation should be done when a coupling of navigations is initiated. # @param MOVEMENT_TRACES Boolean indicating if the device should leave traces behind. # @param INVERT Boolean indicating if the input values should be inverted. # @param SLOT_MANAGER Reference to the one and only SlotManager instance in the setup. # @param TRANSMITTER_OFFSET The matrix offset that is applied to the values delivered by the tracking system. # @param DISPLAYS The names of the displays that belong to this navigation. # @param AVATAR_TYPE A string that determines what kind of avatar representation is to be used ["joseph", "joseph_table", "kinect"]. # @param CONFIG_FILE The path to the config file that is used. # @param TRACKING_TARGET_NAME Name of the device's tracking target name as chosen in daemon. def my_constructor( self , NET_TRANS_NODE , SCENEGRAPH , PLATFORM_SIZE , SCALE , STARTING_MATRIX , NAVIGATION_LIST , INPUT_SENSOR_TYPE , INPUT_SENSOR_NAME , NO_TRACKING_MAT , GF_SETTINGS , ANIMATE_COUPLING , MOVEMENT_TRACES , INVERT , SLOT_MANAGER , TRANSMITTER_OFFSET , DISPLAYS , AVATAR_TYPE , CONFIG_FILE , TRACKING_TARGET_NAME = None ): ## @var SCENEGRAPH # Reference to the scenegraph. self.SCENEGRAPH = SCENEGRAPH ## @var NET_TRANS_NODE # Reference to the net matrix node in the scenegraph for distribution. self.NET_TRANS_NODE = NET_TRANS_NODE ## @var coupled_navigations # List of coupled Navigation instances to which this Navigation's changes are forwarded to. self.coupled_navigations = [] ## @var input_sensor_type # String indicating the type of input device to be created, e.g. "XBoxController" or "OldSpheron" self.input_sensor_type = INPUT_SENSOR_TYPE ## @var input_sensor_name # Name of the input device sensor as chosen in daemon. self.input_sensor_name = INPUT_SENSOR_NAME if self.input_sensor_name == None: self.input_sensor_name = "keyboard" ## @var start_matrix # Initial position matrix of the platform. self.start_matrix = STARTING_MATRIX # create device ## @var device # Device instance handling relative inputs of physical device. if self.input_sensor_type == "OldSpheron": self.device = OldSpheronDevice() self.device.my_constructor(INPUT_SENSOR_NAME, TRACKING_TARGET_NAME, NO_TRACKING_MAT) elif self.input_sensor_type == "NewSpheron": self.device = NewSpheronDevice() self.device.my_constructor(INPUT_SENSOR_NAME, TRACKING_TARGET_NAME, NO_TRACKING_MAT) elif self.input_sensor_type == "XBoxController": self.device = XBoxDevice() self.device.my_constructor(INPUT_SENSOR_NAME, TRACKING_TARGET_NAME, NO_TRACKING_MAT) elif self.input_sensor_type == "KeyboardMouse": self.device = KeyboardMouseDevice() self.device.my_constructor(NO_TRACKING_MAT) elif self.input_sensor_type == "Spacemouse": self.device = SpacemouseDevice() self.device.my_constructor(INPUT_SENSOR_NAME, NO_TRACKING_MAT) elif self.input_sensor_type == "Globefish": self.device = GlobefishDevice() self.device.my_constructor(INPUT_SENSOR_NAME, NO_TRACKING_MAT) # init field connections self.sf_reset_trigger.connect_from(self.device.sf_reset_trigger) self.sf_coupling_trigger.connect_from(self.device.sf_coupling_trigger) self.sf_dof_trigger.connect_from(self.device.sf_dof_trigger) # create ground following ## @var groundfollowing # GroundFollowing instance to correct the absolute matrices with respect to gravity. self.groundfollowing = GroundFollowing() self.groundfollowing.my_constructor(self.SCENEGRAPH, self.device.sf_station_mat, float(GF_SETTINGS[1])) # create input mapping ## @var inputmapping # InputMapping instance to process and map relative device inputs to an absolute matrix. self.inputmapping = InputMapping() self.inputmapping.my_constructor(self, self.device, self.groundfollowing, STARTING_MATRIX, INVERT) self.inputmapping.set_input_factors(self.device.translation_factor, self.device.rotation_factor) self.inputmapping.sf_scale.value = SCALE # activate correct input mapping mode according to configuration file if GF_SETTINGS[0]: self.inputmapping.activate_realistic_mode() else: self.inputmapping.deactivate_realistic_mode() # create platform ## @var platform # Platform instance that is controlled by the Device. self.platform = Platform() self.platform.my_constructor( NET_TRANS_NODE = self.NET_TRANS_NODE , SCENEGRAPH = self.SCENEGRAPH , PLATFORM_SIZE = PLATFORM_SIZE , INPUT_MAPPING_INSTANCE = self.inputmapping , PLATFORM_ID = len(NAVIGATION_LIST) , TRANSMITTER_OFFSET = TRANSMITTER_OFFSET , NO_TRACKING_MAT = NO_TRACKING_MAT , DISPLAYS = DISPLAYS , AVATAR_TYPE = AVATAR_TYPE , SLOT_MANAGER = SLOT_MANAGER , CONFIG_FILE = CONFIG_FILE , AVATAR_MATERIAL = self.trace_material ) # create device avatar if AVATAR_TYPE != "None": self.device.create_device_avatar(self.platform.platform_scale_transform_node , self.platform.platform_id) ## @var NAVIGATION_LIST # Reference to a list containing all Navigation instances in the setup. self.NAVIGATION_LIST = NAVIGATION_LIST # attributes ## @var in_dofchange_animation # Boolean variable to indicate if a movement animation for a DOF change (realistic/unrealistic) is in progress. self.in_dofchange_animation = False ## @var in_coupling_animation # Boolean variable to indicate if a movement animation for coupling is in progress. self.in_coupling_animation = False ## @var timer # Instance of TimeSensor to handle the duration of animations. self.timer = avango.nodes.TimeSensor() ## @var ANIMATE_COUPLING # Boolean indicating if an animation should be done when a coupling of navigations is initiated. self.ANIMATE_COUPLING = ANIMATE_COUPLING ## @var movement_traces # Boolean indicating if the movement traces are currently visualized by line segments. self.movement_traces = MOVEMENT_TRACES ## @var movement_traces_activated # Boolean indicating if the movement traces are generally activated. self.movement_traces_activated = self.movement_traces ## @var trace # The trace class that handles the line segment updating. self.trace = None if self.movement_traces: # create trace and add 'Shadeless' to material string to have a nicer line apperance ## @var trace # Instance of Trace class to handle trace drawing of this navigation's movements. self.trace = TraceLines.Trace(self.NET_TRANS_NODE, self.platform.platform_id, 500, 20.0, STARTING_MATRIX, self.trace_material + 'Shadeless') # evaluate every frame self.always_evaluate(True) ## Resets the platform's matrix to the initial value. def reset(self): self.inputmapping.set_abs_mat(self.start_matrix) self.inputmapping.set_scale(1.0) self.trace.clear(self.start_matrix) ## Activates 3-DOF (realistic) navigation mode. def activate_realistic_mode(self): # remove pitch and roll from current orientation _current_mat = self.platform.sf_abs_mat.value _current_trans = _current_mat.get_translate() _current_yaw = Tools.get_yaw(_current_mat) ## @var start_rot # Quaternion representing the start rotation of the animation self.start_rot = self.platform.sf_abs_mat.value.get_rotate() ## @var target_rot # Quaternion representing the target rotation of the animation self.target_rot = avango.gua.make_rot_mat(math.degrees(_current_yaw), 0, 1, 0).get_rotate() ## @var animation_time # Time of the rotation animation in relation to the rotation distance. self.animation_time = 2 * math.sqrt(math.pow(self.start_rot.x - self.target_rot.x, 2) \ + math.pow(self.start_rot.y - self.target_rot.y, 2) \ + math.pow(self.start_rot.z - self.target_rot.z, 2) \ + math.pow(self.start_rot.w - self.target_rot.w, 2)) # if no animation is needed, set animation time to a minimum value to avoid division by zero if self.animation_time == 0.0: self.animation_time = 0.01 ## @var start_trans # Starting translation vector of the animation. self.start_trans = _current_trans ## @var animation_start_time # Point in time where the animation started. self.animation_start_time = self.timer.Time.value self.in_dofchange_animation = True ## Animates the removal of pitch and roll angles when switching from 6-DOF (unrealistic) to 3-DOF (realistic) navigation mode. def animate_dofchange(self): _current_time = self.timer.Time.value _slerp_ratio = (_current_time - self.animation_start_time) / self.animation_time # when end of animation is reached if _slerp_ratio > 1: _slerp_ratio = 1 self.in_dofchange_animation = False self.inputmapping.activate_realistic_mode() # compute slerp position and set it on the player's inputmapping _transformed_quat = self.start_rot.slerp_to(self.target_rot, _slerp_ratio) _position_yaw_mat = avango.gua.make_trans_mat(self.start_trans.x, self.start_trans.y, self.start_trans.z) * \ avango.gua.make_rot_mat(_transformed_quat) self.inputmapping.set_abs_mat(_position_yaw_mat) ## Activates 6-DOF (unrealistic) navigation mode. def deactivate_realistic_mode(self): self.inputmapping.deactivate_realistic_mode() ## Bidirectional coupling of this and another navigation. # @param NAVIGATION The Navigation to be coupled. def couple_navigation(self, NAVIGATION): # write navigation to be coupled in the list of coupled navigations on all coupled navigations if not ((NAVIGATION in self.coupled_navigations) or (self in NAVIGATION.coupled_navigations)): for _nav in self.coupled_navigations: if not (NAVIGATION in _nav.coupled_navigations): _nav.coupled_navigations.append(NAVIGATION) if not (_nav in NAVIGATION.coupled_navigations): NAVIGATION.coupled_navigations.append(_nav) for _nav in NAVIGATION.coupled_navigations: if not (self in _nav.coupled_navigations): _nav.coupled_navigations.append(self) if not (_nav in self.coupled_navigations): self.coupled_navigations.append(_nav) self.coupled_navigations.append(NAVIGATION) NAVIGATION.coupled_navigations.append(self) # if one of the navigations is in unrealistic (6 dof) mode, switch the other one to unrealistic as well if self.inputmapping.realistic == False and NAVIGATION.inputmapping.realistic == True: NAVIGATION.deactivate_realistic_mode() elif self.inputmapping.realistic == True and NAVIGATION.inputmapping.realistic == False: self.deactivate_realistic_mode() ## Bidirectional decoupling of this and another navigation. # @param NAVIGATION The Navigation to be decoupled. def decouple_navigation(self, NAVIGATION): if NAVIGATION in self.coupled_navigations: self.coupled_navigations.remove(NAVIGATION) NAVIGATION.coupled_navigations.remove(self) ## Triggers the coupling mechanism. # When other platforms are close enough, they are coupled to each other. def trigger_coupling(self): # list containing the navigataions close enough to couple _close_navs = [] # threshold when two navigations should be considered for coupling (distance in meter) _threshold = 7.0 # compute center position of own platform _position_self = (self.platform.sf_abs_mat.value * self.device.sf_station_mat.value).get_translate() # check for all navigations in the setup for _nav in self.NAVIGATION_LIST: # compute center position of currently iterated platform _position_nav = (_nav.platform.sf_abs_mat.value * _nav.device.sf_station_mat.value).get_translate() # append navigation to the list of close ones if distance is smaller than a threshold if _nav != self and \ Tools.euclidean_distance(_position_self, _position_nav) < _threshold and \ _nav.platform.sf_scale.value == self.platform.sf_scale.value: _close_navs.append(_nav) # sort list of close navs, highest distance first _close_navs.sort(key = lambda _nav: Tools.euclidean_distance(_position_self, (_nav.platform.sf_abs_mat.value * _nav.device.sf_station_mat.value).get_translate()), reverse = True) if len(_close_navs) > 0: if self.movement_traces_activated: _mat = self.get_current_world_pos() self.trace.clear(_mat) # couple the close navigations for _nav in _close_navs: self.couple_navigation(_nav) # clear movement traces if _nav.movement_traces_activated: _mat = _nav.get_current_world_pos() _nav.trace.clear(_mat) _nav.movement_traces = False if self.ANIMATE_COUPLING: # do an animation to closest navigation if this functionality is switched on _nav_animation_target = _close_navs[-1] self.set_coupling_animation_settings(_nav_animation_target) self.inputmapping.blocked = True self.platform.show_coupling_plane() for i in range(len(_close_navs)): _close_navs[i].set_coupling_animation_settings(_nav_animation_target) _close_navs[i].inputmapping.blocked = True _close_navs[i].platform.show_coupling_plane() # notify users _all_coupled_navs = list(self.coupled_navigations) _all_coupled_navs.append(self) for _nav in _all_coupled_navs: _nav.platform.display_coupling(_all_coupled_navs) else: print "No platform in range for coupling." ## Sets all the necessary attributes to perform a lerp and slerp animation to another navigation. # @param TARGET_NAVIGATION The Navigation instance to animate to. def set_coupling_animation_settings(self, TARGET_NAVIGATION): # determine start and target rotation and translation self.start_rot = self.platform.sf_abs_mat.value.get_rotate() self.start_trans = self.platform.sf_abs_mat.value.get_translate() _start_rot_center_mat = self.platform.sf_abs_mat.value * self.device.sf_station_mat.value _target_rot_center_mat = TARGET_NAVIGATION.platform.sf_abs_mat.value * TARGET_NAVIGATION.device.sf_station_mat.value _difference_vector = _target_rot_center_mat.get_translate() - _start_rot_center_mat.get_translate() _difference_vector.y = 0.0 # it turned out that slerping rotation does not look that nice # can be changed by switching comments in the two lines below self.target_rot = self.start_rot #self.target_rot = avango.gua.make_rot_mat(math.degrees(Tools.get_yaw(_target_rot_center_mat)), 0, 1, 0).get_rotate() ## @var target_trans # The current animation's target translation. self.target_trans = self.start_trans + _difference_vector ## @var target_navigation # Reference to the target Navigation instance used in coupling animations. Used for updating target_trans when the rotation center moves. self.target_navigation = TARGET_NAVIGATION ## @var start_rot_center_mat # Matrix representing the transformation of the start navigation's rotation center (used for coupling animation purposes). self.start_rot_center_mat = _start_rot_center_mat self.animation_time = 0.5 * math.sqrt(math.pow(self.start_trans.x - self.target_trans.x, 2) \ + math.pow(self.start_trans.y - self.target_trans.y, 2) + math.pow(self.start_trans.z - self.target_trans.z, 2)) \ + math.sqrt(math.pow(self.start_rot.x - self.target_rot.x, 2) + math.pow(self.start_rot.y - self.target_rot.y, 2) \ + math.pow(self.start_rot.z - self.target_rot.z, 2) + math.pow(self.start_rot.w - self.target_rot.w, 2)) # if no animation is needed, set animation time to a minimum value to avoid division by zero if self.animation_time == 0.0: self.animation_time = 0.01 self.animation_start_time = self.timer.Time.value self.in_coupling_animation = True ## Animates the movement to another platform during the coupling process. def animate_coupling(self): _current_time = self.timer.Time.value _animation_ratio = (_current_time - self.animation_start_time) / self.animation_time # recompute target_trans in case the rotation center moves _target_rot_center_mat = self.target_navigation.platform.sf_abs_mat.value * self.target_navigation.device.sf_station_mat.value _difference_vector = _target_rot_center_mat.get_translate() - self.start_rot_center_mat.get_translate() _difference_vector.y = 0.0 self.target_trans = self.start_trans + _difference_vector # when end of animation is reached if _animation_ratio > 1: _animation_ratio = 1 self.in_coupling_animation = False # clear blockings when all coupling animations are done _clear_blockings = True for _nav in self.coupled_navigations: if _nav.in_coupling_animation == True: _clear_blockings = False break if _clear_blockings: self.inputmapping.blocked = False self.platform.hide_coupling_plane() for _nav in self.coupled_navigations: _nav.inputmapping.blocked = False _nav.platform.hide_coupling_plane() # compute slerp and lerp position and set it on the player's inputmapping _transformed_quat = self.start_rot.slerp_to(self.target_rot, _animation_ratio) _transformed_vec = self.start_trans.lerp_to(self.target_trans, _animation_ratio) _animation_mat = avango.gua.make_trans_mat(_transformed_vec.x, _transformed_vec.y, _transformed_vec.z) * \ avango.gua.make_rot_mat(_transformed_quat) self.inputmapping.set_abs_mat(_animation_mat) ## Decouples this Navigation from all coupled Navigations. def clear_couplings(self): if len(self.coupled_navigations) > 0: # create hard copy of coupled navigations _couplings = list(self.coupled_navigations) if self.movement_traces_activated: self.movement_traces = True _mat = self.get_current_world_pos() self.trace.clear(_mat) if len(_couplings) == 1: _couplings[0].movement_traces = True _mat = _couplings[0].get_current_world_pos() _couplings[0].trace.clear(_mat) # iterate over all navigations and clear the coupling for _nav in _couplings: _nav.decouple_navigation(self) _nav.platform.remove_from_coupling_display(self, True) self.platform.remove_from_coupling_display(_nav, False) self.coupled_navigations = [] ## Switches from realistic to unrealistic or from unrealistic to realistic mode on this # and all other coupled instances. def trigger_dofchange(self): # if in realistic mode, switch to unrealistic mode if self.inputmapping.realistic == True: #print "GF off" self.deactivate_realistic_mode() for _navigation in self.coupled_navigations: _navigation.deactivate_realistic_mode() # if in unrealistic mode, switch to realistic mode else: #print "GF on" self.activate_realistic_mode() for _navigation in self.coupled_navigations: _navigation.activate_realistic_mode() ## Computes the current world position of the rotation center on the platform ground (y = 0). def get_current_world_pos(self): _station_trans = self.device.sf_station_mat.value.get_translate() _mat = self.platform.sf_abs_mat.value * avango.gua.make_trans_mat(avango.gua.Vec3(_station_trans.x, 0, _station_trans.z) * self.platform.sf_scale.value) return _mat ## Evaluated every frame. def evaluate(self): # handle visibilities if self.ANIMATE_COUPLING: self.platform.platform_transform_node.GroupNames.value = [] for _nav in self.coupled_navigations: self.platform.platform_transform_node.GroupNames.value.append("couple_group_" + str(_nav.platform.platform_id)) # handle dofchange animation if self.in_dofchange_animation: self.animate_dofchange() # handle coupling animation elif self.in_coupling_animation: self.animate_coupling() # draw the traces if enabled if self.movement_traces: _mat = self.get_current_world_pos() self.trace.update(_mat) ## Evaluated when value changes. @field_has_changed(sf_reset_trigger) def sf_reset_trigger_changed(self): if self.sf_reset_trigger.value == True: # button pressed #print "RESET" self.reset() for _navigation in self.coupled_navigations: _navigation.reset() ## Evaluated when value changes. @field_has_changed(sf_coupling_trigger) def sf_coupling_trigger_changed(self): if self.sf_coupling_trigger.value == True: # button pressed if self.in_coupling_animation == False: if len(self.coupled_navigations) == 0: self.trigger_coupling() else: self.clear_couplings() ## Evaluated when value changes. @field_has_changed(sf_dof_trigger) def sf_dof_trigger_changed(self): if self.sf_dof_trigger.value == True: # button pressed if self.in_dofchange_animation == False: self.trigger_dofchange()
def __init__(self): Platform.__init__(self) self.platform = "momo" pass
def __init__(self, screen_wdith, screen_height): # Call the parent constructor. super().__init__() # The borders of the level. self.left_edge = -1500 self.right_edge = 2500 self.top_edge = -1800 self.bottom_edge = 1000 # Where the camera stops moving on this level. self.shift_left_bound = self.left_edge + (screen_wdith / 2) self.shift_right_bound = self.right_edge - (screen_wdith / 2) self.shift_up_bound = self.top_edge + (screen_height / 2) self.shift_down_bound = self.bottom_edge - (screen_height / 2) # Where the player starts on this level. self.starting_x = 429 self.starting_y = 212 self.starting_right = False # The portal to the next level. self.portal = Portal(460, -1430) self.portal_list.add(self.portal) # Music for this level. self.music = "Assets/Music/Level_2.mp3" # 2D array, containing the x and y coordinates and type for each platform. platforms = [[210, 288, 0], [280, 288, 1], [350, 288, 1], [420, 288, 1], [490, 288, 1], [560, 288, 2], [-700, 168, 0], [-630, 168, 1], [-560, 168, 1], [-490, 168, 1], [-420, 168, 1], [-350, 168, 1], [-280, 168, 1], [-210, 168, 1], [-140, 168, 1], [-70, 168, 1], [0, 168, 1], [70, 168, 2], [-910, 28, 0], [-840, 28, 2], [-680, -108, 0], [-610, -108, 1], [-540, -108, 1], [-470, -108, 1], [-400, -108, 1], [-330, -108, 1], [-260, -108, 1], [-190, -108, 1], [-120, -108, 2], [150, -108, 0], [220, -108, 2], [490, -108, 0], [560, -108, 1], [630, -108, 2], [910, -108, 0], [980, -108, 2], [1130, -230, 0], [1200, -230, 1], [1270, -230, 1], [1340, -230, 1], [1410, -230, 1], [1480, -230, 1], [1550, -230, 2], [1700, -360, 0], [1770, -360, 2], [1410, -480, 0], [1480, -480, 2], [1700, -600, 0], [1770, -600, 2], [1410, -730, 0], [1480, -730, 2], [1700, -860, 0], [1770, -860, 2], [-200, -1000, 0], [-130, -1000, 1], [-60, -1000, 1], [10, -1000, 1], [80, -1000, 1], [150, -1000, 1], [220, -1000, 1], [290, -1000, 1], [360, -1000, 1], [430, -1000, 1], [500, -1000, 1], [570, -1000, 1], [640, -1000, 1], [710, -1000, 1], [780, -1000, 1], [850, -1000, 1], [920, -1000, 1], [990, -1000, 1], [1060, -1000, 1], [1130, -1000, 1], [1200, -1000, 1], [1270, -1000, 1], [1340, -1000, 1], [1410, -1000, 1], [1480, -1000, 2], [-490, -1120, 0], [-420, -1120, 2], [-200, -1260, 0], [-130, -1260, 1], [-60, -1260, 1], [10, -1260, 1], [80, -1260, 1], [150, -1260, 1], [220, -1260, 1], [290, -1260, 1], [360, -1260, 1], [430, -1260, 1], [500, -1260, 2]] # Go through the array above and create the platforms. for temp in platforms: platform = Platform(temp[0], temp[1], temp[2]) self.platform_list.add(platform) # A 2D array containing the min-x, max-x, and y coordinates and color of each enemy. enemies = [[-700, -350, 138, False], [-350, 140, 138, True], [490, 700, -138, False], [-680, -50, -138, False], [1130, 1620, -260, True], [-200, 220, -1030, True], [220, 640, -1030, False], [640, 1060, -1030, True], [1060, 1550, -1030, False], [-200, 290, -1290, True]] # Go through the array above and create the enemies. for temp in enemies: enemy = Enemy(temp[0], temp[1], temp[2], temp[3]) self.enemy_list.add(enemy)
def __init__(self): Platform.__init__(self) self.platform = "yizhibo" pass
def main(): pygame.init() screen = pygame.display.set_mode(SCREEN_SIZE.size) pygame.display.set_caption("Use arrows to move!") timer = pygame.time.Clock() level = [ "PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP", "P P", "P P", "P P", "P P", "P P", "P PPPPPPPPPPP P", "P PPPPPPPPPPP P", "P P", "P P", "P P", "P P", "P P", "P PPPPPPPPPPPPPPPP P", "P PPPPPPPPPPPPPPPP P", "P P", "P P", "P P", "P P", "P P", "P PP P", "P PP P", "P PP P", "P PP P", "P PPPPPPPPPPP PP P", "P PPPPPPPPPPP PP P", "P PPPPPPPPPPP P", "P PPPPPPPPPPP P", "P PPPPPPPPPPP P", "P P", "P P", "P P", "P P", "PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP", ] platforms = pygame.sprite.Group() player = Player(platforms, (TILE_SIZE, TILE_SIZE), 100) level_width = len(level[0]) * TILE_SIZE level_height = len(level) * TILE_SIZE entities = CameraAwareLayeredUpdates( player, pygame.Rect(0, 0, level_width, level_height)) # build the level x = y = 0 for row in level: for col in row: if col == "P": Platform((x, y), platforms, entities) x += TILE_SIZE y += TILE_SIZE x = 0 enemies = [] lost = False lost_count = 0 lost_font = pygame.font.SysFont("comicsans", 60) while 1: if player.health <= 0: lost = True lost_count += 1 if lost: if lost_count > FPS * 3: return else: print("You lost !!!") continue if len(enemies) == 0: #spawn all enemies for i in range(5): enemyX = random.randrange(50, level_width - 150) enemyY = random.randrange(50, level_height - 200) enemy = Enemy(platforms, (enemyX, enemyY), 100, entities) enemies.append(enemy) # handle events for e in pygame.event.get(): if e.type == QUIT: return mouse1, mouse2, mouse3 = pygame.mouse.get_pressed() if mouse1: mouseX, mouseY = pygame.mouse.get_pos() targetX = mouseX - SCREEN_CENTER_X + player.rect.left targetY = mouseY - SCREEN_CENTER_Y + player.rect.top player.shoot(targetX, targetY, entities) player.draw_healthbar(entities) player.move_fireballs(enemies) for enemy in enemies: if enemy.health <= 0: enemy.dispose() enemies.remove(enemy) else: enemy.move(player) enemy.draw_healthbar(entities) if random.randrange(0, 2 * FPS) == 1: enemy.shoot(player.rect.left, player.rect.top, entities) enemy.move_fireballs([player]) entities.update() screen.fill((0, 0, 0)) entities.draw(screen) pygame.display.update() timer.tick(FPS)
def test_from_dict(self): Platform.from_dict({"":""})
def reinit(): global player global platform_controller global floor global camera player = Player() platform_controller = PlatformController() floor = Platform(0, SCREEN_HEIGHT - 36, SCREEN_WIDTH, 36) camera = Camera(player) player = Player() platform_controller = PlatformController() floor = Platform(0, SCREEN_HEIGHT - 36, SCREEN_WIDTH, 36) arrow_image = load_image("arrow.png") selected_option = 0.30 background = load_image('background.jpg') thief = load_image('7.png') over = load_image('8.png') camera = Camera(player) game_state = 'Menu' game_loop = True clock = pygame.time.Clock() fps = 60
def get_platform(self, platform_id="", name=""): platform = Platform() platform.id = platform_id platform.name = name return platform