def new(self): self.result = 0 self.objects = pg.sprite.Group() self.platforms = pg.sprite.Group() self.players = pg.sprite.Group() self.player = Player(self) self.player.set_image("p1_front.png") self.players.add(self.player) self.objects.add(self.player) p1 = Platform(0, 560, WIDTH, 40) p2 = Platform(200, 464, 100, 20) p3 = Platform(125, 348, 80, 20) p4 = Platform(350, 232, 90, 20) p5 = Platform(175, 116, 110, 20) self.objects.add(p1) self.objects.add(p2) self.objects.add(p3) self.objects.add(p4) self.objects.add(p5) self.platforms.add(p1) self.platforms.add(p2) self.platforms.add(p3) self.platforms.add(p4) self.platforms.add(p5) self.run()
def addPlatforms(self, platforms): for platform in platforms: block = Platform(platform[0]) block.rect.x = platform[1] block.rect.y = platform[2] block.player = self.player self.platform_list.add(block)
def isRunnable(self, entry_point=None): # fold>> """ @description checks runnability conditions. @description A package is runnable for a given entry point when the following conditions are met: @description - there is an executable group with that entry point @description - the executable exists for the current platform and is executable @description - if an interpreter is declared, the interpreter can be found and is executable """ if self.__is_zipped: self._unpack() # if we have no executables, it is quickly said if len(self.__manifest.executableGroupList()) == 0: return False # try with the default entry point if not provided if entry_point is None: entry_point = self.defaultExecutableGroupEntryPoint() # no default? then we know the answer if entry_point is None: return False executable_group = self.__manifest.executableGroup(entry_point) if executable_group is None: return False # try with the executable for the current platform. If not found, try with something that is supported executable = executable_group.executable(Platform.currentPlatform()) if executable is None: # try to see if there's an executable that can run on this platform for exe in executable_group.executableList(): if Platform.isCompatibleWith(exe.platform()): executable = exe break # still none? we rest our case if executable is None: return False # check for the existence of the file as specified in the path executable_absolute_path = _computeExecutableAbsolutePath(self.rootDir(), executable.path(), executable.pathType(), executable.platform()) if not os.path.exists(executable_absolute_path): return False # check if the executable is interpreted, and in this case, if the interpreter can be found and executed interpreter = executable.interpreter() if interpreter is not None: interpreter_path=_which(interpreter) if interpreter_path is None: return False if not _isExecutable(interpreter_path): return False else: # not interpreted, check the executability of the file itself if not _isExecutable(executable_absolute_path): return False # looks like there are chances it can be executable, after all return True
def initJson(): global jsonInstall load_json(DEFAULT_JSON) if Platform.getPackage("apt"): jsonInstall = get_json("apt") elif Platform.getPackage("yum"): jsonInstall = get_json("yum")
def hs(): # Hide some objects names = ["Wall"] Platform.ShowObjectList("spyroom", names, False) # Disable physics for some objects names = ["Collid"] Platform.PhysObjectList("spyroom", names, False)
def add_rotating_platform(self, position, radius=2, platform_width=1, T=600, color=(50, 50, 50)): height = 10 * S R = radius * box_size * 2 width = platform_width * box_size * 2 # top will be at same level as floor for position[1] = 0 pos = np.array(position, dtype='float') * (box_size * 2.0) + [ 0, floor + height ] path = [ np.array([ pos[0] + R * math.cos(2 * math.pi * x / T), pos[1] + R * math.sin(2 * math.pi * x / T) ]) for x in range(T) ] self.master_platform_list.append( Platform.Moving_Platform([width, height], copy.copy(path), color=color)) self.master_platform_list.append( Platform.Moving_Platform([width, height], path[int(T / 2):] + path[:int(T / 2)], color=color)) self.background_list.append(Platform.Platform(pos, [height, height]))
def __init__(self, player): """ Create level 1. """ # Call the parent constructor Level.__init__(self, player) self.background = pygame.image.load("background_01.png").convert() self.background.set_colorkey(constants.WHITE) self.level_limit = -2500 # Array with type of platform, and x, y location of the platform. level = [[500, 500, Platform.GRASS_LEFT]] # Go through the array above and add platforms for platform in level: block = Platform.Platform(platform[0], platform[1], platform[2], "tiles_spritesheet.png") block.player = self.player self.platform_list.add(block) # Add a custom moving platform block = Platform.Moving_Platform(1350, 280, Platform.STONE_PLATFORM_MIDDLE, "tiles_spritesheet.png") block.boundary_left = 1350 block.boundary_right = 1600 block.change_x = 1 block.player = self.player block.level = self self.platform_list.add(block)
def generateplatforms(self, initial): y = 900 # Generate from bottom of the screen start = -100 if (initial == True): self.startY = -100 # Fill starting screen with platforms while (y > -70): p = Platform.Platform() p.getKind(self.score) p.y = y p.startY = start self.platforms.append(p) y -= 30 # Generate every 30 pixels start += 30 self.startY = start else: # Creates a platform based on current score p = Platform.Platform() if (self.score <= 2500): difficulty = 50 elif (self.score < 4000): difficulty = 60 else: difficulty = 70 p.y = self.platforms[-1].y - difficulty self.startY += difficulty p.startY = self.startY p.getKind(self.score) self.platforms.append(p)
def __init__(self, player): # Call the parent constructor Level.__init__(self, player) self.level_limit = -1000 # Array with width, height, x, and y of platform level = [[210, 70, 500, 530], [210, 30, 1000, 500], [210, 30, 1000, 300], [210, 30, 710, 400], [210, 30, 1300, 150] ] # Go through the array above and add platforms for platform in 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) # Add one enemies to the level # Set the height and width of the screen size = [SCREEN_WIDTH, SCREEN_HEIGHT] screen = pygame.display.set_mode(size) self.enemy_list.add(Enemy())
def setup(self, target_point, target_ent=None): self.nextPointIndex = 1 self.targetPoint = vec3(target_point) self.targetEnt = target_ent start_time = Platform.time_in_seconds() self.path = self.entity.pathToLocation(self.targetPoint) end_time = Platform.time_in_seconds() self.pathGraphic = None
def initPlatforms(self): """Create and add platforms to platformList""" myPlatform = Platform.Platform((255, 0, 0), 10) self.platformList.append(myPlatform) myPlatform = Platform.Platform((255, 255, 0), 115) self.platformList.append(myPlatform) myPlatform = Platform.Platform((0, 0, 255), 220) self.platformList.append(myPlatform)
def setup(self, target_point, target_ent=None): self.nextPointIndex = 1 self.targetPoint = vec3(target_point) self.targetEnt = target_ent start_time = Platform.time_in_seconds() self.path = self.entity.pathToLocation( self.targetPoint ) end_time = Platform.time_in_seconds() self.pathGraphic = None
def hide(bOn=False): #Platform.HideJalak() # Hide some objects names = [ "Bamboo", "Dome", "Garden", "Pillar", "TreeTrunk", "Rain", "Water" ] Platform.ShowObjectList("garden", names, bOn) # Disable physics for some objects names = ["TreeTrunk"] Platform.PhysObjectList("garden", names, bOn)
def loadLayers( modname, mapname): path = '../%s/maps/%s/' % (modname, mapname ) filename = path + 'layers.xml' layers = [] tree = ET.parse( filename ) root = tree.getroot() for l in root.getchildren( ): new_layer = Layer() for attrs in l.getchildren(): setattr( new_layer, attrs.tag.strip( string.whitespace) , attrs.text ) layers.append( TerrainLayer( Platform.asOSPath(new_layer.TextureName), Platform.asOSPath(path + 'layer_' + new_layer.Name + '.png'), Platform.asOSPath(path+'shadows.png') ) ) return layers
def loadLayers(modname, mapname): path = '../%s/maps/%s/' % (modname, mapname) filename = path + 'layers.xml' layers = [] tree = ET.parse(filename) root = tree.getroot() for l in root.getchildren(): new_layer = Layer() for attrs in l.getchildren(): setattr(new_layer, attrs.tag.strip(string.whitespace), attrs.text) layers.append( TerrainLayer( Platform.asOSPath(new_layer.TextureName), Platform.asOSPath(path + 'layer_' + new_layer.Name + '.png'), Platform.asOSPath(path + 'shadows.png'))) return layers
def set_fm(self): pi_version = Platform.pi_version() srate = str(int(self.sample_rate / (1 if self.num_channels > 1 else 2))) if os.path.exists(cm.fm.fmfifo): os.remove(cm.fm.fmfifo) os.mkfifo(cm.fm.fmfifo, 0777) fm_command = [ "sudo", cm.home_dir + "/bin/pifm", "-", cm.fm.frequency, srate, "stereo" if self.num_channels > 1 else "mono" ] if pi_version >= 2: fm_command = [ "sudo", cm.home_dir + "/bin/pi_fm_rds", "-audio", "-", "-freq", cm.fm.frequency, "-srate", srate, "-ps", cm.fm.program_service_name, "-rt", cm.fm.radio_text, "-ctl", cm.fm.fmfifo, "-nochan", "2" if self.num_channels > 1 else "1" ] log.info("Sending output as fm transmission") with open(os.devnull, "w") as dev_null: self.fm_process = subprocess.Popen(fm_command, stdin=subprocess.PIPE, stdout=dev_null) self.output = lambda raw_data: self.fm_process.stdin.write(raw_data) fmoutthr = Thread(target=self.update_fmout, args=(cm, cm.fm.program_service_name)) fmoutthr.daemon = True fmoutthr.start()
def hide(): Platform.HideJalak() # Hide some objects names = ["column_23", "column_22", "column_21", "column_20", "column_19", "column_18", "column_17", "column_16", "column_15", "Light"] Platform.ShowObjectList("jalak", names, False) names = ["Dak2FAKE", "Dak1Plane", "dkta", "DAK2grndEntrnc"] Platform.ShowObjectList("city", names, False) names = ["Wall"] Platform.ShowObjectList("spyroom", names, False) # Disable physics for some objects names = ["Collid"] Platform.PhysObjectList("spyroom", names, False)
def hc(): # Hide some objects names = ["column_23", "column_22", "column_21", "column_20", "column_19", "column_18", "column_17", "column_16", "column_15", "Light"] Platform.ShowObjectList("jalak", names, False)
def platform2(where=None): matPos = None if where is None or where not in range(1, 5): matPos = PtGetLocalAvatar().getLocalToWorld() else: #Ahnonay if where == 1: tupPos = ((0.98276501894, 0.184859260917, 0.0, 23.3415126801), (-0.184859260917, 0.98276501894, 0.0, 54.0308570862), (0.0, 0.0, 1.0, -0.0328424945474), (0.0, 0.0, 0.0, 1.0)) elif where == 2: tupPos = ((-0.897078573704, -0.44187015295, 0.0, 649.721862793), (0.44187015295, -0.897078573704, 0.0, -877.984619141), (0.0, 0.0, 1.0, 9445.71386719), (0.0, 0.0, 0.0, 1.0)) elif where == 3: tupPos = ((0.00954949762672, -0.999954581261, 0.0, -102.545890808), (0.999954581261, 0.00954949762672, 0.0, 54.9582672119), (0.0, 0.0, 1.0, 10563.0976562), (0.0, 0.0, 0.0, 1.0)) elif where == 4: tupPos = ((-0.748968303204, 0.662607133389, 0.0, 1560.00488281), (-0.662607133389, -0.748968303204, 0.0, -51.4498291016), (0.0, 0.0, 1.0, 10171.9091797), (0.0, 0.0, 0.0, 1.0)) elif where == 5: tupPos = ((-0.937420606613, -0.3482016325, 0.0, 993.751708984), (0.3482016325, -0.937420606613, 0.0, -455.378509521), (0.0, 0.0, 1.0, 9424.86523438), (0.0, 0.0, 0.0, 1.0)) matPos = ptMatrix44() matPos.setData(tupPos) Platform.CreatePlatform2(bShow=False, matAv=matPos)
def update(self): # game loop - update self.all_sprites.update() # check collision only when falling downwards if self.player.velocity.y > 0: collision = pg.sprite.spritecollide(self.player, self.platforms, False) if collision: self.player.position.y = collision[0].rect.top + 1 self.player.velocity.y = 0 self.player.jump() # if player reaches top of the screen if self.player.rect.top <= HEIGHT / 4: self.player.position.y += abs(self.player.velocity.y) for platform in self.platforms: platform.rect.y += abs(self.player.velocity.y) # delete platform if goes off the screen if platform.rect.top >= HEIGHT: platform.kill() # spawn new platforms while len(self.platforms) < 6: plat_width = random.randrange(50, 100) platform = Platform(random.randrange(0, WIDTH - plat_width), random.randrange(-30, -20), plat_width, 15) self.platforms.add(platform) self.all_sprites.add(platform)
def set_fm(self): pi_version = Platform.pi_version() srate = str(int(self.sample_rate / (1 if self.num_channels > 1 else 2))) fm_command = ["sudo", cm.home_dir + "/bin/pifm", "-", cm.fm.frequency, srate, "stereo" if self.num_channels > 1 else "mono"] if pi_version >= 2: fm_command = ["sudo", cm.home_dir + "/bin/pi_fm_rds", "-audio", "-", "-freq", cm.fm.frequency, "-srate", srate, "-nochan", "2" if self.num_channels > 1 else "1"] log.info("Sending output as fm transmission") with open(os.devnull, "w") as dev_null: self.fm_process = subprocess.Popen(fm_command, stdin=subprocess.PIPE, stdout=dev_null) self.output = lambda raw_data: self.fm_process.stdin.write(raw_data)
def create(background, ar): entities = pygame.sprite.Group() x = y = 0 for row in ar: for col in row: if col == "g": block = Platform("ground.bmp", x, y) # background.blit(block, (x, y)) if col == "t": block = Platform("gr1.bmp", x, y) # background.blit(block, (x, y)) entities.add(block) x += block.get_width() y += block.get_height() x = 0 return entities
def __init__(self, name, time_stamp, header=None): self._platform = Platform.Platform() self._os = OS.OS() self._name = name self._ERR_FILE_EXIST = "ERROR: Log file '%s' already exists" % name self._ERR_FILE_OPEN = "ERROR: Unable to open log file '%s'" % name if self._os.is_file(name): raise Error.Error(msg=self._ERR_FILE_EXIST) else: try: f = open(name, 'w') except IOError: raise Error.Error(msg=self._ERR_FILE_OPEN) if header != None: f.write("%s\n" % header) line = "Generated %s" % time_stamp.as_string() f.write(line+"\n\n") line = "System: %s" % self._platform.system() f.write(line+"\n") line = "Python version: %s" % self._platform.python_version() f.write(line+"\n") line = ("Python implementation: %s" % self._platform.python_implementation()) f.write(line+"\n\n") f.close()
def InstanceDataFromPacket(packet): """Grab instance data from the packet""" typepath = Platform.asOSPath(packet.typepath) typestr = GetEntTypeInfoForTypePath(typepath).typeClass yaw, pitch, roll = MathUtil.quaternionToEulerYawPitchRoll( quat(packet.qw, packet.qx, packet.qy, packet.qz)) return EntInstanceData(None, typestr, typepath, packet.scriptname, packet.x, packet.y, packet.z, yaw, pitch, roll)
def __init__(self, player): """ Create level 1. """ # Call the parent constructor Level.__init__(self, player) # Array with width, height, x, and y of platform level = [[210, 70, 500, 500], [210, 70, 200, 400], [210, 70, 600, 300], [250, 70, 500, 300], [100, 100, 250, 250], [50, 50, 100, 100]] # Go through the array above and add platforms for platform in 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 new(self): # start a new game self.all_sprites = pg.sprite.Group() self.platforms = pg.sprite.Group() self.player = Player(self) for plat in PLATFORM_LIST: Platform(plat[0], plat[1], plat[2], plat[3], self) self.run()
def map_level_5(self):# 5번 맵 로딩 함수 self.coin = 5 #몬스터 self.monster.append(Monster.Monster("mouse",1900,300, CHARACTER_SCALING * 0.5, MONSTER_MOVEMENT_SPEED*3, 300, 2400)) self.monster.append(Monster.Monster("wormGreen",2400,300, CHARACTER_SCALING * 0.5, MONSTER_MOVEMENT_SPEED*3, 300, 2400)) self.monster.append(Monster.Monster("bee",1100,450, CHARACTER_SCALING * 0.5, MONSTER_MOVEMENT_SPEED*3, 300, 1200)) self.monster.append(Monster.Monster("bee",600,450, CHARACTER_SCALING * 0.5, MONSTER_MOVEMENT_SPEED*3, 1200, 2400)) self.monster.append(Monster.Monster("bee",500,1000, CHARACTER_SCALING * 0.5, MONSTER_MOVEMENT_SPEED*3, 600, 1200)) self.monster.append(Monster.Monster("bee",800,1000, CHARACTER_SCALING * 0.5, MONSTER_MOVEMENT_SPEED*3, 1200, 2400)) #플랫폼 self.platform.append(Platform.Platform("thunder",1080,900, CHARACTER_SCALING * 0.5,fall = True, die = True)) #2층에서 내리는 번개 self.platform.append(Platform.Platform("doorClosed_mid",2400,290, CHARACTER_SCALING * 0.5, teleport = True)) #아래 텔레포트 self.platform.append(Platform.Platform("doorClosed_mid",50,610, CHARACTER_SCALING * 0.5, teleport = False)) #윗 텔레포트 #3층 번개 for i in range(1): self.platform.append(Platform.Platform("thunder",288+ (i*128),800, CHARACTER_SCALING * 0.5, fall = True, die = True)) for i in range(1): self.platform.append(Platform.Platform("thunder",358+ ( (14 + i)*64),800, CHARACTER_SCALING * 0.5, fall = True, die = True)) self.platform.append(Platform.Platform("thunder",1900,820, CHARACTER_SCALING, fall = True, die = True)) self.platform.append(Platform.Platform("bridgeA",400,930, CHARACTER_SCALING * 0.5,PLATFORM_MOVEMENT_SPEED*4, 400, 2200, hard_platform = True)) #몬스터 for i in range(len(self.monster)): self.monster_sprite.append(self.monster[i].newMonster()) self.monster_list.append(self.monster_sprite[i]) #플랫폼 for i in range(len(self.platform)): self.platform_sprite.append(self.platform[i].newPlatform()) self.platform_list.append(self.platform_sprite[i])
def platform(name="spy"): matPos = None if name == "spy": tupPos = ((0.841503858566, -0.540251135826, 0.0, -141.0), (0.540251135826, 0.841503858566, 0.0, -131.0), (0.0, 0.0, 1.0, 255.0), (0.0, 0.0, 0.0, 1.0)) matPos = ptMatrix44() matPos.setData(tupPos) else: pass Platform.CreatePlatformSpy(bShow=False, matAv=matPos)
def get_default_bus(): """Return the default bus number based on the device platform. For a Raspberry Pi either bus 0 or 1 (based on the Pi revision) will be returned. For a Beaglebone Black the first user accessible bus, 1, will be returned. """ plat = Platform.platform_detect() if plat == Platform.RASPBERRY_PI: if Platform.pi_revision() == 1: # Revision 1 Pi uses I2C bus 0. return 0 else: # Revision 2 Pi uses I2C bus 1. return 1 elif plat == Platform.BEAGLEBONE_BLACK: # Beaglebone Black has multiple I2C buses, default to 1 (P9_19 and P9_20). return 1 else: raise RuntimeError('Could not determine default I2C bus for platform.')
def runEntryPoint(self, entry_point, arguments=None, environment=None): # fold>> """ @description runs the platform specific executable with a given entry poin, or a compatible @description platform specific/aspecific code under the same entry point. @description The function never returns. The executable runs with an execve call which @description replaces the current executable with the new executable. If you want to fork, you @description have to do it before calling run() """ if self.__is_zipped: self._unpack() if not self.isRunnable(entry_point): raise NotRunnableException("Entry point "+entry_point+" is not runnable.") if arguments is None: arguments=[] if environment is None: environment = os.environ # add the environment variable containing the package base directory. # we use this and not os.setenv because os.setenv does not export to child processes. environment["PACKAGE_ROOT_DIR"]=self.rootDir() environment["CN_ROOT_DIR"]=self.rootDir() environment["CN_ENTRY_POINT"] = entry_point # FIXME: this code is heavily repeated. refactor it out! executable_group = self.__manifest.executableGroup(entry_point) executable = executable_group.executable(Platform.currentPlatform()) if executable is None: # try to see if there's an executable that can run on this platform for exe in executable_group.executableList(): if Platform.isCompatibleWith(exe.platform()): executable = exe break environment["CN_RUN_ARCH"]=executable.platform() executable_absolute_path = _computeExecutableAbsolutePath(self.rootDir(), executable.path(), executable.pathType(), executable.platform()) interpreter = executable.interpreter() if interpreter is not None: interpreter_path=_which(interpreter) os.execve(interpreter_path, [interpreter_path, executable_absolute_path]+list(arguments), environment) else: os.execve(executable_absolute_path,[executable_absolute_path]+list(arguments), environment)
def map_level_3(self):# 3번 맵 로딩 함수 self.coin = 4 self.monster.append(Monster.Monster("bee",400,150, CHARACTER_SCALING * 0.5, MONSTER_MOVEMENT_SPEED*2, 300, 1000)) self.platform.append(Platform.Platform("bridgeA",400,50, CHARACTER_SCALING * 0.5,PLATFORM_MOVEMENT_SPEED, 300, 1200, hard_platform = True)) for i in range(len(self.platform)): self.platform_sprite.append(self.platform[i].newPlatform()) self.platform_list.append(self.platform_sprite[i]) for i in range(len(self.monster)): self.monster_sprite.append(self.monster[i].newMonster()) self.monster_list.append(self.monster_sprite[i])
def say(sentence): global __popen__ if __popen__ is not None: __popen__.wait() print("Saying '{0}'".format(sentence)) cmd = ['mpg123', '-q', "http://translate.google.com/translate_tts?tl=en&q={0}".format(sentence)] if Platform.is_raspberrypi(): __popen__ = subprocess.Popen(cmd)
def add_floor(self, start, stop, color=platform_color, line_color=(0, 0, 0), line_width=2): self.master_platform_list.append( Platform.Platform([(start + stop) * box_size, floor + 50 * S], [(stop - start + 1) * box_size, 50 * S], color, line_color, line_width))
def play(file): global __popen__ if __popen__ is not None: __popen__.wait() print("Playing '{0}'".format(file)) cmd = ['mpg123', '-q', file] if Platform.is_raspberrypi(): __popen__ = subprocess.Popen(cmd)
def map_level_2(self):# 2번 맵 로딩 함수 self.coin = 4 self.monster.append(Monster.Monster("bee",800,420, CHARACTER_SCALING * 0.5, MONSTER_MOVEMENT_SPEED, 800, 930)) for i in range(len(self.monster)): self.monster_sprite.append(self.monster[i].newMonster()) self.monster_list.append(self.monster_sprite[i]) self.platform.append(Platform.Platform("rock",690,700, CHARACTER_SCALING * 0.5, fall = True, die = True)) for i in range(len(self.platform)): self.platform_sprite.append(self.platform[i].newPlatform()) self.platform_list.append(self.platform_sprite[i])
def main( argv=None ): if argv is None: argv = sys.argv try: try: opts, args = getopt.getopt( argv[1:], "dC:c:h", [ "debug", "config", "crontab", "help" ] ) except getopt.error, msg: raise Utils.Usage( msg ) debugMode = configFile = crontabFile = None for cliOpts, cliArgs in opts: if cliOpts in ( "-c", "--crontab" ): crontabFile = cliArgs if cliOpts in ( "-d", "--debug" ): debugMode = True if cliOpts in ( "-C", "--config" ): configFile = cliArgs if cliOpts in ( "-h", "--help" ): DisplayUsage() return 2 if not Platform.isRunning(): Utils.initLogging( logLevelNo=3 ) logFacility = logging.getLogger( Utils.returnScriptName( ) ) if configFile is None: print "A Config File Is Required." return 2 configSettings = Utils.loadConfig( configFile ) if not debugMode: if not Utils.makeDaemon(): logFacility.error( "Failed To Daemonize. Running In The Foreground. " ) print "Failed To Daemonize. Going To Run In The Foreground." if crontabFile is None: if not configSettings is None: cronDaemon = CronLib.CronSQL( configSettings ) else: print "There Was A Problem Loading The Config File. Check The Log File." return 2 else: try: cronDaemon = CronLib.CronFile( crontabFile ) except CronLib.CronError, errorMsg: logFacility.error( "Failed To Start crond. Reason: %s \n" % errorMsg ) print "Failed To Start crond. Reason: %s \n" % errorMsg return 1 cronDaemon.run()
def int(self, amount, screen, character): self.amount = amount self.platforms = [None] * amount self.visiblePlatforms = [] for i in range(0, amount): if i > 0: randomX = random.randint((self.platforms[i-1].X)-(500), self.platforms[i-1].X + 500) while randomX < 0 or randomX > screen.get_width() - 80: randomX = random.randint((self.platforms[i-1].X)-(500), self.platforms[i-1].X + 500) randomY = random.randint((self.platforms[i-1].Y)-(500), self.platforms[i-1].Y - 300) platform = Platform.Plateform() platform.int(randomX, randomY, screen, character, self) else: platform = Platform.Plateform() platform.int(screen.get_width()/2, 500, screen, character, self) self.platforms[i] = platform if platform.bottom > 0: self.visiblePlatforms.append(platform)
def new(self): # start new game self.all_sprites = pg.sprite.Group() self.platforms = pg.sprite.Group() self.player = Player(self) self.all_sprites.add(self.player) for platform in PLATFORM_LIST: platform_to_add = Platform(*platform) self.all_sprites.add(platform_to_add) self.platforms.add(platform_to_add) self.run()
def platform(where=None, bAttachOn=False): matPos = None #if where is None or where not in range(1, 5): if where is None or where not in range(1, 6): matPos = PtGetLocalAvatar().getLocalToWorld() else: """ #Ahnonay if where == 1: tupPos = ((0.98276501894, 0.184859260917, 0.0, 23.3415126801), (-0.184859260917, 0.98276501894, 0.0, 54.0308570862), (0.0, 0.0, 1.0, -0.0328424945474), (0.0, 0.0, 0.0, 1.0)) elif where == 2: tupPos = ((-0.897078573704, -0.44187015295, 0.0, 649.721862793), (0.44187015295, -0.897078573704, 0.0, -877.984619141), (0.0, 0.0, 1.0, 9445.71386719), (0.0, 0.0, 0.0, 1.0)) elif where == 3: tupPos = ((0.00954949762672, -0.999954581261, 0.0, -102.545890808), (0.999954581261, 0.00954949762672, 0.0, 54.9582672119), (0.0, 0.0, 1.0, 10563.0976562), (0.0, 0.0, 0.0, 1.0)) elif where == 4: tupPos = ((-0.748968303204, 0.662607133389, 0.0, 1560.00488281), (-0.662607133389, -0.748968303204, 0.0, -51.4498291016), (0.0, 0.0, 1.0, 10171.9091797), (0.0, 0.0, 0.0, 1.0)) elif where == 5: tupPos = ((-0.937420606613, -0.3482016325, 0.0, 993.751708984), (0.3482016325, -0.937420606613, 0.0, -455.378509521), (0.0, 0.0, 1.0, 9424.86523438), (0.0, 0.0, 0.0, 1.0)) """ """ # Descent V1 if where == 1: tupPos = ((-0.0784590244293, 0.996917307377, 0.0, 789.132202148), (-0.996917307377, -0.0784590244293, 0.0, -583.487670898), (0.0, 0.0, 1.0, 1151.59057617), (0.0, 0.0, 0.0, 1.0)) elif where == 2: tupPos = ((0.859911203384, 0.510443627834, 0.0, 785.749572754), (-0.510443627834, 0.859911203384, 0.0, -574.134643555), (0.0, 0.0, 1.0, 1151.59057617), (0.0, 0.0, 0.0, 1.0)) elif where == 3: tupPos = ((-0.398735255003, 0.91706776619, 0.0, 766.0), (-0.91706776619, -0.398735255003, 0.0, -699.0), (0.0, 0.0, 1.0, 715.0), (0.0, 0.0, 0.0, 1.0)) elif where == 4: """ # Descent V2 if where == 1: tupPos = ((0.722353339195, -0.691524147987, 0.0, 766.198181152), (0.691524147987, 0.722353339195, 0.0, -698.65826416), (0.0, 0.0, 1.0, 608.855895996), (0.0, 0.0, 0.0, 1.0)) elif where == 2: tupPos = ((1.0, -0.0, 0.0, 769.0), (0.0, 1.0, 0.0, -610.0), (0.0, 0.0, 1.0, 1152.0), (0.0, 0.0, 0.0, 1.0)) elif where == 3: tupPos = ((0.0, -1.0, 0.0, 766.0), (1.0, 0.0, 0.0, -699.0), (0.0, 0.0, 1.0, 1146.0), (0.0, 0.0, 0.0, 1.0)) elif where == 4: tupPos = ((0.0, -1.0, 0.0, 766.0), (1.0, 0.0, 0.0, -680.0), (0.0, 0.0, 1.0, 1140.0), (0.0, 0.0, 0.0, 1.0)) elif where == 5: tupPos = ((0.0, -1.0, 0.0, 766.0), (1.0, 0.0, 0.0, -680.0), (0.0, 0.0, 1.0, 715.0), (0.0, 0.0, 0.0, 1.0)) elif where == 6: tupPos = ((0.0, -1.0, 0.0, 766.0), (1.0, 0.0, 0.0, -680.0), (0.0, 0.0, 1.0, 610.0), (0.0, 0.0, 0.0, 1.0)) matPos = ptMatrix44() matPos.setData(tupPos) Platform.CreatePlatform2(bShow=False, matAv=matPos, bAttach=bAttachOn)
def InstanceDataFromPacket( packet ): """Grab instance data from the packet""" typepath = Platform.asOSPath(packet.typepath) typestr = GetEntTypeInfoForTypePath(typepath).typeClass yaw, pitch, roll = MathUtil.quaternionToEulerYawPitchRoll( quat( packet.qw, packet.qx, packet.qy, packet.qz) ) return EntInstanceData(None, typestr, typepath, packet.scriptname, packet.x, packet.y, packet.z, yaw, pitch, roll)
def test(): model, header = Platform.get_model() print "We are going to do some basic tests to make sure" print "your hardware is working as expected." print "Raspberry Pi %s" % model print "You have %s channels defined" % str(cm.hardware.gpio_len) print "They are using gpio pins %s" % ", ".join( map(str, cm.hardware.gpio_pins)) print "You have configured your relays as active %s" % ( "low" if cm.hardware.active_low_mode else "high") print "pin_modes are %s " % ", ".join(cm.hardware.pin_modes) print "custom_channel_mapping %s being used" % ("is" if ccm else "is not") if ccm: print "[%s]" % ", ".join( map(str, cm.audio_processing.custom_channel_mapping)) print "\nFirst we are going to flash each light in order to see if they are all working" raw_input("Press Enter to continue....") flash(True) print "If everything went correctly you should have seen each of your channels" print "flash one at a time in order of assignment." while True: answer = raw_input( "Did you see all channels flash in order? (yes/no) ").lower() yes = ['yes', 'y', 'yep', 'ja', 'si', 'oui'] no = ['no', 'n', 'nope', 'nein', 'non'] if answer in yes or answer in no: if answer in yes: print "Great, your basic config is ready for you to start with\n\n" sys.exit(1) if answer in no: print "Lets make sure you're using the correct gpio pins" print "Here is what the %s header looks like\n" % model print header print print "Make sure you are using the correct pins as listed above" if ccm: print "Disable custom channel mapping to help with debugging your config" print "After you have made these corrections please rerun this test\n\n" sys.exit(1) print "Please answer yes or no"
def resourceAbsolutePath(self, entry_point): # fold>> if self.__is_zipped: self._unpack() platform = Platform.currentPlatform() group = self.__manifest.resourceGroup(entry_point) if group is None: return None resource = group.resource(platform) if resource is not None: return _computeResourceAbsolutePath(self.rootDir(), resource.path(), resource.pathType(), platform) # look for something compatible for resource in group.resourceList(): if Platform.isCompatibleWith(resource.platform()): return _computeResourceAbsolutePath(self.rootDir(), resource.path(), resource.pathType(), resource.platform()) return None
def executableAbsolutePath(self, entry_point): # fold>> if self.__is_zipped: self._unpack() platform = Platform.currentPlatform() group = self.__manifest.executableGroup(entry_point) if group is None: return None executable = group.executable(platform) if executable is not None: return _computeExecutableAbsolutePath(self.rootDir(), executable.path(), executable.pathType(), platform) # look for something compatible for executable in group.executableList(): if Platform.isCompatibleWith(executable.platform()): return _computeExecutableAbsolutePath(self.rootDir(), executable.path(), executable.pathType(), executable.platform()) return None
def __init__(self, north, south, east, west, up, down): self.north = Platform.asOSPath(north) self.south = Platform.asOSPath(south) self.east = Platform.asOSPath(east) self.west = Platform.asOSPath(west) self.up = Platform.asOSPath(up) self.down = Platform.asOSPath(down)
def test(): model, header = Platform.get_model() print "We are going to do some basic tests to make sure" print "your hardware is working as expected." print "Raspberry Pi %s" % model print "You have %s channels defined" % str(cm.hardware.gpio_len) print "They are using gpio pins %s" % ", ".join(map(str, cm.hardware.gpio_pins)) print "You have configured your relays as active %s" % ( "low" if cm.hardware.active_low_mode else "high") print "pin_modes are %s " % ", ".join(cm.hardware.pin_modes) print "custom_channel_mapping %s being used" % ("is" if ccm else "is not") if ccm: print "[%s]" % ", ".join(map(str, cm.audio_processing.custom_channel_mapping)) print "\nFirst we are going to flash each light in order to see if they are all working" raw_input("Press Enter to continue....") flash(True) print "If everything went correctly you should have seen each of your channels" print "flash one at a time in order of assignment." while True: answer = raw_input("Did you see all channels flash in order? (yes/no) ").lower() yes = ['yes', 'y', 'yep', 'ja', 'si', 'oui'] no = ['no', 'n', 'nope', 'nein', 'non'] if answer in yes or answer in no: if answer in yes: print "Great, your basic config is ready for you to start with\n\n" return if answer in no: print "Lets make sure you're using the correct gpio pins" print "Here is what the %s header looks like\n" % model print header print print "Make sure you are using the correct pins as listed above" if ccm: print "Disable custom channel mapping to help with debugging your config" print "After you have made these corrections please rerun this test\n\n" return print "Please answer yes or no"
def __init__(self, player): """ Create level 1. """ # Call the parent constructor Level.__init__(self, player) self.level_limit = -1000 # Array with type of platform, and x, y location of the platform. level = [[210, 30, 450, 570], [210, 30, 850, 420], [210, 30, 850, 520], [210, 30, 1120, 280], [210, 50, 1120, 400], [210, 50, 1120, 520]] # Go through the array above and add platforms for platform in 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 require_repeated_start(): """Enable repeated start conditions for I2C register reads. This is the normal behavior for I2C, however on some platforms like the Raspberry Pi there are bugs which disable repeated starts unless explicitly enabled with this function. See this thread for more details: http://www.raspberrypi.org/forums/viewtopic.php?f=44&t=15840 """ plat = Platform.platform_detect() if plat == Platform.RASPBERRY_PI: # On the Raspberry Pi there is a bug where register reads don't send a # repeated start condition like the kernel smbus I2C driver functions # define. As a workaround this bit in the BCM2708 driver sysfs tree can # be changed to enable I2C repeated starts. subprocess.check_call('chmod 666 /sys/module/i2c_bcm2708/parameters/combined', shell=True) subprocess.check_call('echo -n 1 > /sys/module/i2c_bcm2708/parameters/combined', shell=True)
def draw(self): TextureManager.GetTexture( Platform.asOSPath(self.textureName)).bind() glDisable(GL_CULL_FACE) glEnable(GL_BLEND) glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA) glDisable(GL_ALPHA_TEST) glDisable(GL_LIGHTING) glDepthMask( GL_FALSE ) glColor4(1, 1, 1, 0.25) self._drawQuad(self.flowOffset) glColor4(1, 1, 1, 0.25) self._drawQuad(-self.flowOffset) glDepthMask( GL_TRUE ) glEnable(GL_CULL_FACE)
def get_platform_gpio(**keywords): """Attempt to return a GPIO instance for the platform which the code is being executed on. Currently supports only the Raspberry Pi using the RPi.GPIO library and Beaglebone Black using the Adafruit_BBIO library. Will throw an exception if a GPIO instance can't be created for the current platform. The returned GPIO object is an instance of BaseGPIO. """ plat = Platform.platform_detect() if plat == Platform.RASPBERRY_PI: import RPi.GPIO return RPiGPIOAdapter(RPi.GPIO, **keywords) elif plat == Platform.BEAGLEBONE_BLACK: import Adafruit_BBIO.GPIO return AdafruitBBIOAdapter(Adafruit_BBIO.GPIO, **keywords) elif plat == Platform.UNKNOWN: raise RuntimeError('Could not determine platform.')
def set_audio_device(sample_rate, num_channels): global fm_process pi_version = Platform.pi_version() if cm.audio_processing.fm: srate = str(int(sample_rate / (1 if num_channels > 1 else 2))) fm_command = ["sudo", cm.home_dir + "/bin/pifm", "-", cm.audio_processing.frequency, srate, "stereo" if num_channels > 1 else "mono"] if pi_version == 2: fm_command = ["sudo", cm.home_dir + "/bin/pi_fm_rds", "-audio", "-", "-freq", cm.audio_processing.frequency, "-srate", srate, "-nochan", "2" if num_channels > 1 else "1"] log.info("Sending output as fm transmission") with open(os.devnull, "w") as dev_null: fm_process = subprocess.Popen(fm_command, stdin=subprocess.PIPE, stdout=dev_null) return lambda raw_data: fm_process.stdin.write(raw_data) elif cm.lightshow.audio_out_card is not '': if cm.lightshow.mode == 'stream-in': num_channels = 2 output_device = aa.PCM(aa.PCM_PLAYBACK, aa.PCM_NORMAL, cm.lightshow.audio_out_card) output_device.setchannels(num_channels) output_device.setrate(sample_rate) output_device.setformat(aa.PCM_FORMAT_S16_LE) output_device.setperiodsize(CHUNK_SIZE) return lambda raw_data: output_device.write(raw_data) else: return lambda raw_data: None
def __init__(self, world, ent_xml_data, ent_config): """Initializes location data and mesh filename """ self.initialData = ent_xml_data self.typeInfo = ent_config self.world = world self.scriptname = ent_xml_data.scriptname self.meshOffset = vec3( 0, 0, 0) self.meshFile = Platform.asOSPath( ent_config.meshFile ) self.behaviors = [x(self) for x in ent_config.behaviors] self.typeName = ent_config.typeName self.boundingSphere = None self.owner = None self.netVector = None if world.isServer and self.serverside: self.entID = world.generateEntID() else: self.entID = None self._createPhysicsBody() self._resetLocation()
def LoadEntsFromFile( filename, world, is_server ): #store instance variables ents = [] #Load from the XML file holding the entities tree = ET.parse( filename ) root = tree.getroot() for ent in root.getchildren( ): if ent.tag == 'count': continue #Ignore the count element #read all the XML data associated with the ent into an object instance_data = EntInstanceData(ent.getchildren()) #read the INI files description of the ent type type_info = GetEntTypeInfoForTypePath(Platform.asOSPath(instance_data.typepath)) if not is_server and type_info.pythonClass.serverside: continue #if we're on the client side, and this is a serverside ent #don't make it else: ents.append(MakeEnt(world, instance_data, type_info)) return ents
def main(): """The main game function that contains all the game attributes and the main game loop. """ pygame.init() FPS = 30 fps_clock = pygame.time.Clock() SCREENSIZE = (800, 600) screen = pygame.display.set_mode(SCREENSIZE) pygame.display.set_caption("Journey to the West") pygame.mouse.set_visible(False) background = Background.Background((800, 600)) platform = Platform.platformGroup() player = Player.Player((-100, 0)) moveL = False moveR = False gameIdle =True gameContinue = True gamePause = False endGameCounter = 100 pygame.mixer.music.load('bg.ogg') pygame.mixer.music.set_endevent(USEREVENT) pygame.mixer.music.play() fullscreen = False while True: for event in pygame.event.get(): if event.type == pygame.QUIT: pygame.quit() sys.exit() if event.type == USEREVENT: pygame.mixer.music.play() if (event.type == KEYDOWN and event.key == K_RETURN and (pygame.key.get_mods() & KMOD_ALT)): if fullscreen: fullscreen = False screen = pygame.display.set_mode(SCREENSIZE) else: fullscreen = True screen = pygame.display.set_mode(SCREENSIZE, FULLSCREEN) if gameContinue: if gameIdle: if event.type == KEYDOWN and event.key == K_RETURN: gameIdle = False player.unhideHeart() elif gamePause: if event.type == KEYDOWN: if event.key == K_p: gamePause = False if event.key == K_q: pygame.quit() sys.exit() else: if event.type == KEYDOWN: if event.key == K_EQUALS: player.increaseHealth() if event.key == K_RIGHT: moveR = True if event.key == K_LEFT: moveL = True if event.key == K_SPACE: player.jump() if event.key == K_p: gamePause = True if event.type == KEYUP: if event.key == K_RIGHT: moveR = False if event.key == K_LEFT: moveL = False else: if event.type == KEYDOWN: if event.key == K_r: background = Background.Background((800, 600)) platform = Platform.platformGroup() player = Player.Player((150, 200)) gameContinue = True moveL = False moveR = False if event.key == K_q: pygame.quit() sys.exit() if gameContinue: if gameIdle: player.hideHeart() player.land(platform.platList(), Platform.Platform(1, (13000, 3))) background.update(screen) player.update(screen) demo(screen) platform.update(screen) if not player.moveR(): background.moveR() elif gamePause: pause(screen) else: if moveL: player.moveL() if moveR: if not player.moveR(): background.moveR() platform.moveR() screen.fill((0, 0, 0)) player.land(platform.platList(), platform.finalPlat()) player.enemyCollision(platform.monList()) player.fruitCollison(platform.fruList()) player.fireballCollison(platform.fireList()) if player.gameOver() or player.win(): gameContinue = False background.update(screen) platform.update(screen) player.update(screen) else: if endGameCounter == 0: gameIdle = True background = Background.Background((800, 600)) platform = Platform.platformGroup() player = Player.Player((150, 200)) gameContinue = True moveL = False moveR = False endGameCounter = 100 else: endGameCounter -= 1 if player.win(): gameWon(screen) else: gameOver(screen) pygame.display.update() fps_clock.tick(FPS)
def MakeEnt( world, init_data, type_info=None ): """Creates an entity from an EntInstanceData object""" if not type_info: type_info = GetEntTypeInfoForTypePath( Platform.asOSPath(init_data.typepath) ) return type_info.pythonClass( world, init_data, type_info )
def flash_nrf51(jtag, softdevice, bootloader, board, firmware): """Flash Bluefruit module Softdevice + Bootloader + Firmware""" if (board is None) or (board not in supported_boards): click.echo( "Please specify the board either " + ', '.join(supported_boards) ) sys.exit(1) if (board == "blefriend16"): board = "blefriend" bootloader = 0 # force legacy bootloader if firmware is None: click.echo("Please specify the firmware version e.g: 0.6.5") sys.exit(1) if jtag not in supported_programmers: click.echo("Unsupported programmer, please specify one of following: " + ', '.join(supported_programmers)) sys.exit(1) click.echo('jtag \t: %s' % jtag) click.echo('softdevice \t: %s' % softdevice) click.echo('bootloader \t: %s' % bootloader) click.echo('board \t: %s' % board) click.echo('firmware \t: %s' % firmware) softdevice_hex = glob.glob(firmware_dir + '/softdevice/*' + softdevice + '_softdevice.hex')[0].replace('\\', '/') bootloader_hex = glob.glob(firmware_dir + '/bootloader/*' + str(bootloader) + '.hex')[0].replace('\\', '/') signature_hex = glob.glob(firmware_dir + '/' + firmware + '/' + board + '/*_signature.hex')[0].replace('\\', '/') firmware_hex = signature_hex.replace('_signature.hex', '.hex') click.echo('Writing Softdevice + DFU bootloader + Application to flash memory') if (jtag == 'jlink') or (jtag == 'stlink'): # click.echo('adalink -v nrf51822 --programmer ' + jtag + # ' --wipe --program-hex "' + softdevice_hex + '"' + # ' --program-hex "' + bootloader_hex + '"' + # ' --program-hex "' + firmware_hex + '"' + # ' --program-hex "' + signature_hex + '"') flash_status = subprocess.call('adalink nrf51822 --programmer ' + jtag + ' --wipe --program-hex "' + softdevice_hex + '"' + ' --program-hex "' + bootloader_hex + '"' + ' --program-hex "' + firmware_hex + '"' + ' --program-hex "' + signature_hex + '"', shell=True) elif (jtag == 'rpigpio'): # or (jtag == 'stlink'): if (jtag == 'rpigpio'): if (Platform.platform_detect() != Platform.RASPBERRY_PI): sys.exit() else: openocd_bin = openocd_dict['RPi_gpio'] subprocess.call('chmod 755 ' + openocd_bin, shell=True) interface_cfg = 'raspberrypi' + ('2' if Platform.pi_version() == 2 else '') + '-native.cfg' interface_cfg = interface_cfg + ' -c "transport select swd" -c "set WORKAREASIZE 0"' else: interface_cfg = 'stlink-v2.cfg' if platform.system() != 'Linux': openocd_bin = openocd_dict[platform.system()] else: if Platform.platform_detect() == Platform.RASPBERRY_PI: openocd_bin = openocd_dict['RPi'] else: openocd_bin = openocd_dict['Ubuntu'] subprocess.call('chmod 755 ' + openocd_bin, shell=True) interface_cfg = 'stlink-v2.cfg' openocd_cmd = openocd_bin + ' -s ' + openocd_dir + '/scripts -l log.txt ' + '-f interface/' + interface_cfg + ' -f target/nrf51.cfg' flash_status = subprocess.call(openocd_cmd + ' -c init -c "reset init" -c halt -c "nrf51 mass_erase"' + ' -c "program ' + softdevice_hex + ' verify"' + ' -c "program ' + bootloader_hex + ' verify"' + ' -c "program ' + firmware_hex + ' verify"' + ' -c "program ' + signature_hex + ' verify"' + ' -c reset -c exit', shell=True if platform.system() != 'Windows' else False) else: click.echo('unsupported debugger') sys.exit() if flash_status != 0: print "Flash FAILED" else: print "Flash OK"
def end_early(): """atexit function""" if state == "random_pattern": exit_event.set() time.sleep(3) turn_off_lights() atexit.register(end_early) # Remove traceback on Ctrl-C signal.signal(signal.SIGINT, lambda x, y: sys.exit(0)) cm = configuration_manager.Configuration() is_a_raspberryPI = Platform.platform_detect() == 1 if is_a_raspberryPI: import wiringpi2 as wiringpi else: # if this is not a RPi you can't run wiringpi so lets load # something in its place import wiring_pi as wiringpi logging.debug("Not running on a raspberryPI") _PWM_MAX = cm.hardware.pwm_range _ACTIVE_LOW_MODE = cm.hardware.active_low_mode always_on_channels = cm.lightshow.always_on_channels always_off_channels = cm.lightshow.always_off_channels
def __init__(self, type, data): self.type = type self.data = data self.handled = False self.timestamp = Platform.time_in_seconds()
import time import Platform if Platform.is_raspberrypi(): import RPi.GPIO as GPIO # we have to use BCM mode to stay compatible with the dot3k GPIO.setmode(GPIO.BCM) lamps = [6, 13, 19, 26] if Platform.is_raspberrypi(): for lamp in lamps: GPIO.setup(lamp, GPIO.OUT) def set_lamp(lamp_id, state): if Platform.is_raspberrypi() and lamp_id >= 0 and lamp_id < len(lamps): GPIO.output(lamps[lamp_id], state) def all_off(): for lamp in range(0, len(lamps)): set_lamp(lamp, 0) def build_good(): set_lamp(0, 1) set_lamp(1, 1) set_lamp(2, 0) set_lamp(3, 0) def broken_test(): set_lamp(0, 0) set_lamp(1, 1)
def set_lamp(lamp_id, state): if Platform.is_raspberrypi() and lamp_id >= 0 and lamp_id < len(lamps): GPIO.output(lamps[lamp_id], state)