def main(): gfx = Video() inp = Input() gui = GUI() # Initialize try: gfx.initialize() inp.initialize() gui.initialize() except InitializationError as error: print(error) return 1 # Setup the interface gui.setupInterface() # Main Loop gfx.enterMainLoop() # Done # - We will never actually get here. gfx.shutdown() return 0
def __init__(self): """ Class used to initialize the different arrays Size of arrays depends on the type of mesh Variables: x : variable containing the x position of the nodes y : variable containing the y position of the nodes dom_size : number of nodes in the domain nodes : |id of node|y position of node|x position of node| neig : |id of node|neighbor 1|neighbor 2| ... in neig : -1 = no more neighbors, -2 = wall, -3 = symetry """ Input.__init__(self) self.x = np.linspace(0, self.Lx / 2, self.Nptsx) self.y = np.linspace(self.Lx / 2, self.Ly - self.Lx / 2, self.Nptsy) if (self.mesh_type == 'cart'): self.dom_size = self.Nptsx * self.Nptsy self.nodes = np.zeros((self.dom_size, 3)) self.neig = np.zeros((self.dom_size, 6)) else: self.dom_size = self.Nptsx * self.Nptsy + 2 * (self.Nptsx - 1) * self.ntheta self.nodes = np.zeros((self.dom_size, 3)) self.neig = np.zeros((self.dom_size, 5 + self.ntheta))
def main(): screen = pygame.display.set_mode((WIDTH, HEIGHT)) pygame.display.set_caption("Engine RPG") clock = pygame.time.Clock() #rejilla = load_image('resources/graphics/rejilla.png', True) map_loaded = Map("pruebas.tmx") heroe = Actor(map_loaded) camara = Camera(map_loaded, heroe) inp = Input() while True: time = clock.tick(40) inp.update() salir(inp.get_key_list()) id = heroe.mover(map_loaded, inp) heroe.update(id) camara.update(screen, map_loaded, heroe) camara.show_fps(screen, clock.get_fps()) #screen.blit(rejilla, (0, 0)) pygame.display.flip() return 0
def test_compareresults(self): # os.remove("Output1.txt") keyWordList = [] keyWord = "science" filePath = os.path.join(dirPath, "testcases/Test3/ListOfFiles.in") filePathTitle = os.path.join(dirPath, "testcases/Test3") outputTestPath = os.path.join(dirPath, "testcases/Test3/Output3.txt") flag = False # os.remove("Output1.txt") for i in range(2): if len(keyWordList) == 0: keyWordList.append(keyWord) self.input = Input(filePath, keyWordList, filePathTitle) else: keyWord = "Computer" if keyWord not in keyWordList: keyWordList.append(keyWord) flag = True else: flag = False # keyWordList.append(keyWord) if len(keyWordList) > 1: with open(outputPath, "w") as file: file.close() # self.input = Input(filePath, keyWordList, filePathTitle) if len(keyWordList) > 1 and flag == True: self.input = Input(filePath, keyWordList, filePathTitle) self.assertTrue(filecmp.cmp(outputPath, outputTestPath, shallow=False))
def __init__(self): self.running = True self.UC = Udp_communication(socket, pickle, self.server_ip, self.server_port) self.state = Start(self.UC, bge, ras) #THIS JUST FORWARDS TO LOBBY, UPDATE IT. self.input = Input(bge)
def read_input(self): joystick_input = Input() MULTIPLIER = 1 / 511.5 while True: output = joystick_input.read() x1 = int(output[0]) y1 = int(output[1]) b1 = bool(output[2]) # joystick 2 x2 = int(output[3]) y2 = int(output[4]) b2 = bool(output[5]) x2_float = MULTIPLIER * x1 - 1 y2_float = -(MULTIPLIER * y1 - 1) x1_float = MULTIPLIER * x2 - 1 y1_float = -(MULTIPLIER * y2 - 1) if self.init: # self.joy_display[0].set_pos_inner(x1_float, y1_float) # self.joy_display[0].click = b1 # self.joy_display[1].set_pos_inner(x2_float, y2_float) # self.joy_display[1].click = b2 self.lbl_joy1.setText("Joy1:\t\tX: " + str(x1_float)[:5] + ", Y: " + str(y1_float)[:5]) # time.sleep(0.5) self.lbl_joy2.setText("Joy2:\t\tX: " + str(x2_float)[:5] + ", Y: " + str(y2_float)[:5]) time.sleep(0.5)
def _test(): d = { 'type': 'REST', 'name': 'api_input_test', # I just need it to be unique 'id': 'page', 'location' : { 'url': lambda v: 'https://reqres.in/api/users?page={}'.format(v.get('page')), 'errors' : { 200: "OK", 403: "Bad request params", 404: "File not found... ?", 500: "Permanent fail", }, }, 'data': { 'REMAP': { 'reqres_page' : "page", 'reqres_count': "per_page", 'reqres_total': "total", 'reqres_pages': "total_pages", 'reqres_ids' : ('data', 0, { 'id' : 'id', 'name': lambda v: "{} {}".format(v.get('first_name'), v.get('last_name')), 'avatar': 'avatar', }), }, }, } urlin = Input(**d) rv = urlin.get(1) return search(('reqres_ids', 'name'), rv) == "George Bluth"
def __init__(self): print(protologue) self.inp = Input() self.upd = Update() self.world = World(3,4) self.player1 = Player(self.world) self.out = Output()
def from_json(self, json): required = ['inputs', 'outputs', 'duration', 'timestamp'] if not all(k in json for k in required): logging.warning(f'value missing in {required}') return False if not isinstance(json['inputs'], list) or not isinstance(json['outputs'], list) \ or not isinstance(json['timestamp'], float): logging.warning("inputs and outputs should be both type<list> and timestamp should be type<float>") return False for input in json['inputs']: # print(json['inputs']) i = Input() if not i.from_json(input): return False self.add_input(i) for output in json['outputs']: o = Output() if not o.from_json(output): return False self.add_output(o) if not self._duration.from_json(json['duration']): return False self._timestamp = json['timestamp'] return True
def __init__(self): self.screen = pygame.display.get_surface() GLOBALS.UI = UserInterface() GLOBALS.game_running = False GLOBALS.tile_map = TileMap() GLOBALS.tile_map.map_layer.zoom = 2 # pyscroll supports layered rendering. our map has 3 'under' layers # layers begin with 0, so the layers are 0, 1, and 2. # since we want the sprite to be on top of layer 1, we set the default # layer for sprites as 2 self.group = PyscrollGroup(map_layer=GLOBALS.tile_map.map_layer, default_layer=2) GLOBALS.hero = Hero() GLOBALS.hero.position = GLOBALS.tile_map.map_layer.map_rect.center for tree in GLOBALS.trees: self.group.add(tree) for ground in GLOBALS.ground: self.group.add(ground) self.group.add(GLOBALS.hero) # add player last! self.input = Input()
def replace_matching_key(word): parsed_word = "" diagonal = re.match( "[UDBFudbf][UDBFudbf]", word) # this regex needs more tweaking inputs like ff will get ignored if diagonal: for key, value in Input.items(): while does_key_has_match(key, diagonal.string): result = value for k in key: word.replace(k, "", 1) parsed_word += result result = "" break return parsed_word for letter in word: for key, value in Input.items(): while does_key_has_match(key, letter): result = value for k in key: word = word.replace(k, "", 1) parsed_word += result result = "" break return parsed_word
def train(config): """Prepare input data(train, dev), model and fit """ # build input train and dev data train_file = 'data/train.txt' dev_file = 'data/dev.txt' '''for KOR train_file = 'data/kor.train.txt' dev_file = 'data/kor.dev.txt' ''' '''for CRZ train_file = 'data/cruise.train.txt.in' dev_file = 'data/cruise.dev.txt.in' ''' train_data = Input(train_file, config, build_output=True, do_shuffle=True, reuse=False) dev_data = Input(dev_file, config, build_output=True, reuse=False) tf.logging.debug('loading input data ... done') config.update(train_data) tf.logging.debug('config.num_train_steps = %s' % config.num_train_steps) tf.logging.debug('config.num_warmup_epoch = %s' % config.num_warmup_epoch) tf.logging.debug('config.num_warmup_steps = %s' % config.num_warmup_steps) # create model and compile model = Model(config) model.compile() # do actual training fit(model, train_data, dev_data)
def __init__(self, game): GameState.__init__(self, game) self.input_map = { Input(key=pg.K_ESCAPE): lambda _: self.return_to_menu(), Input(key=pg.K_RETURN): lambda _: self._submit() } self.ip_textentry = UI.TextEntry(pos=(c.screen_size[0] // 2 - 100, c.screen_size[1] // 2), type='ip', font=fonts.main_menu_font_med, label='IP Address', default_text='localhost') self.port_textentry = UI.TextEntry(pos=(c.screen_size[0] // 2 - 100, c.screen_size[1] // 2 + 100), type='port', font=fonts.main_menu_font_med, label='Port', default_text='4141') self.connect_button = UI.Button(pos=(c.screen_size[0] // 2 - 100, c.screen_size[1] // 2 + 200), font=fonts.main_menu_font_med, text='Connect') self.ui_container.add_element(self.ip_textentry) self.ui_container.add_element(self.port_textentry) self.ui_container.add_element(self.connect_button) self.sel = None
def __init__(self, args): """ BoomBoomClient constructor. @param host: Server hostname. @type host: C{str} @param display_port: Server port for "display"/"view" connection. @type display_port: C{int} @param input_port: Server port for "input" connection. @type input_port: C{int} @param verbose: Verbose mode flag. @type verbose: C{bool} @param debug: Debug mode flag. @type debug: C{bool} @param max_fps: Maximal number of frames per second, for optimization. @type max_fps: C{int} """ args["protocol"] = protocol.loadProtocol("protocol.xml") args["features"] = ["game"] # Constant features Happyboom.__init__(self, args) EventListener.__init__(self, prefix="evt_") self.display = Display(args) self.input = Input(args) self.__verbose = args.get("verbose", False) self.registerEvent("happyboom") self.registerEvent("game")
def main(): gfx = Video() inp = Input() gui = GUI() # Initialize try: gfx.initialize() inp.initialize() gui.initialize() except InitializationError as error: print(error) return 1 # Setup the interface gui.setupInterface() # Main Loop gfx.enterMainLoop() # Done # - We will never actually get here. gfx.shutdown() return 0
def main(): input = Input() trainX, trainY, testX, testY = input.init() trainNum = trainX.shape[0] testNum = testX.shape[0] T = 200 clfs = list() for i in range(T): print('i = ', i) partX, partY = bootstrap(trainX, trainY) clf = tree.DecisionTreeClassifier(min_samples_split=3, max_features=3) clf = clf.fit(partX, partY) clfs.append(clf) testPredict = np.zeros((T, testNum)) for i in range(T): testPredict[i, :] = clfs[i].predict(testX) aveSum, result = vote(testPredict, T, testNum) correct = compare(result, testY, testNum) print('test correct num = ', correct, ', ratio = ', correct / 16281) auc = roc_auc_score(testY, aveSum) print('auc = ', auc)
def __init__(self, screen, start_state=None, debug=False): self.screen = screen self.card_pool = CardPool() goblin_card_prototype = CreatureCard(name='Goblin', cost=2, base_power=3, max_health=2, visibility=[1]) elf_card_prototype = CreatureCard(name='Elf', cost=1, base_power=2, max_health=1, visibility=[1,0,0,0]) scout_card_prototype = CreatureCard(name='Scout', cost=1, base_power=1, max_health=1, visibility=[3,0,0,0]) drone_card_prototype = BuilderCard(name='Drone', cost=1, base_power=1, max_health=1, visibility=[1]) blacksmith_card_prototype = BuildingCard(name='Blacksmith', cost=1, max_health=4, visibility=[0]) satellite_card_prototype = BuildingCard(name='Satellite', cost=1, max_health=3, visibility=[0], default_action='SCN', active_actions={'SCN': lambda card: ScanAction}) tower_card_prototype = BuildingCard(name='Tower', cost=2, max_health=4, visibility=[3,0,0,0]) self.card_pool.add_card(goblin_card_prototype) self.card_pool.add_card(elf_card_prototype) self.card_pool.add_card(scout_card_prototype) self.card_pool.add_card(drone_card_prototype) self.card_pool.add_card(blacksmith_card_prototype) self.card_pool.add_card(satellite_card_prototype) self.card_pool.add_card(tower_card_prototype) self.network_data_queue = [] self.connection_label = UI.Label( pos=(0,0), font=fonts.main_menu_font_small, text='', text_color=c.green, align=('left','up')) self.chat_window = UI.ChatWindow( name_font=fonts.chat_name_font, message_font=fonts.chat_message_font, name_width=100, message_width=300, log_height=150) self.ui_group = None self.ui_container = UI.Container() self.ui_container.add_element(self.connection_label) #self.ui_container.add_element(self.chat_window) self.input_map = { Input(key='any'): lambda key, mod, unicode_key: self.any_key_pressed(key=key, mod=mod, unicode_key=unicode_key), Input(mouse_button=1): lambda mouse_pos: self.left_mouse_pressed(mouse_pos), Input(mouse_button=1, type='release'): lambda mouse_pos: self.left_mouse_released(mouse_pos) } self._state = None self.state = start_state(self) self.selector = None self.socket = None self.connected_to_address = None self.connection_role = None self._connected = False self._accepting_connections = False if debug is True: d.debugger = d.DebugUI(game=self, active=True)
def __init__(self, port): self.running = False self.pid = 0 self.pids = [] self.nbPlayer = 0 self.players = {} self.entities = {} self.moves = [] self.shoot = False self.shoots = [] self.deads = [] self.killed = [] self.input = Input() self.graphics = Graphics() self.velocity = Constant.VELOCITY self.id = 0 self.port = port self.players_socket = {} self.players_socket_awaiting = {} self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.socket.bind(('', self.port)) self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.socket.listen(5)
class Weapon(Emitter, Inputable): def __init__(self, level, **kwargs): super().__init__(**kwargs) self._level = level self._part = None self._s = Surface((20, 10)) self._s.fill((255, 0, 0)) self._input = Input(inputStream=self.getInputStream()) self._input.set(pygame.KEYDOWN, self.createNew, pygame.K_f) def createNew(self): x, y = self._offsetFunc() self._part = Particle((self._anchor.x + x, self._anchor.y + y, 20, 10), (10, 0), self._s, self._level, Behaviors.killAt(150, 150), Behaviors.moveAt(self._anchor.getIntDir() * 10, 0), Behaviors.killOnCollision(exceptions=(self._anchor.getId(),)), Behaviors.cleanupCollision(), altname="bullet") if x < 0: self._part.x -= self._part.w self._part.move.setSpeed(x=self._part.move.getTopSpeed(x=True)) def _emit(self): if self._part: self._children.append(self._part) self._part = None def tick(self): self._input() super().tick()
def __init__(self, level, speed, tileset, **kwargs): super().__init__(dirRule=lambda: { -1: Direction.Left, 0: None, 1: Direction.Right }[self.move.getDir(x=True)], **kwargs) self.collision = Collision(self, level) self.move = Move(self, speed, collision=self.collision) self._gravity = GravityLine(self, 2, h=level.map.h // 2) self.jumping = Jumping(self.move, self._gravity, 2) self._input = Input(inputStream=self.getInputStream()) self.applyInputSettings() self._damageTimer = MinTimeEventStream(duration=2) self._damageTimer.subscribe("self", self._takeDmg, autoInit=False) def _isMoving(): return self.move.getSpeed(x=True) != 0 def _hDir(): return self.move.getDir(x=True) def _vDir(): return {False: -1, True: 1}[self._gravity.positiveDir()] image = Files.loadImage(tileset) self._display = Display(image, self, Animation(image, 11, _isMoving, _hDir, _vDir), True) self._weapon = Weapon(level, anchor=self, offsetFunc=lambda: ((5 * self.getIntDir()), 0), inputStream=self.getInputStream())
def __init__(self, name, inputs, id=None, cache=None, **kwargs): # we can't immediately resolve inputs. Process args when requested. self.name = name if self.name in Doc._all: raise Exception("Doc: name collision: {}".format(self.name)) self.id_name = id try: self.cache = Input(name=self.name, id=self.id_name, ** cache) if cache else None except NotFound: logger.warning("Unable to load cache for {}".format(self.name)) self.cache = None self._query_config = kwargs.get('query') self._input_config = inputs try: # This attempts to build the inputs. # Hopefully any errors will be found now while the file context exists. self.inputs except NotFound: # our inputs are merely named (not defined...yet). As more plugins are built this should resolve. pass self.query_count = 0 self.cache_hits = 0 self.cache_misses = 0 # Api tracks all instances for 'from_url' Doc._all[self.name] = self
class App(object): def __init__(self): self.config = IniParser() self._lastTick = 0 self.deltaTime = 0 try: self.config.read(open('config.cfg')) except: self.config.data['DISPLAY'] = { 'fullscreen': 'false', 'nativemode': 'false', 'opengl': 'false' } self.config.data['PATHS'] = { 'gamelist': './gamelist.csv', 'favorites': './fav.csv', 'sdcard': '.' } self.config.write(open('config.cfg', 'w')) pygame.init() self.input = Input() self.game = Game(self) #end of init def run(self): self.game.start() # start game self.game.active = True self._lastTick = pygame.time.get_ticks() while 1: # main game loop # deltaTime in seconds. t = pygame.time.get_ticks() self.deltaTime = (t - self._lastTick) / 1000.0 self._lastTick = t for event in pygame.event.get(): self.input.collectEvents(event) if event.type == pygame.QUIT: self.game.active = False sys.exit(0) self.game.update(self.deltaTime) self.game.render() #end of run #end of App
def __init__(self): self.grid_size = 100 self.board = [[0 for i in range(self.grid_size)] for j in range(self.grid_size)] self.row_width = 7 self.row_height = 3 self.num_colors = { 0: "white", 2: "red", 4: "yellow", 8: "green", 16: "blue", 32: "magenta", 64: "cyan", 128: "white", 256: "red", 512: "yellow", 1024: "green", 2048: "blue", 4096: "magenta", 8192: "cyan", } self.num_attrs = { 0: ["concealed"], 2: [], 4: [], 8: [], 16: [], 32: [], 64: [], 128: ["bold"], 256: ["bold"], 512: ["bold"], 1024: ["bold"], 2048: ["bold"], 4096: ["bold"], 8192: ["bold"], } self.directions = { "w": 1, "a": 4, "s": 3, "d": 2, } #bind keys self.input = Input(self.keyboard_listen) self.input.bind("w") self.input.bind("a") self.input.bind("s") self.input.bind("d") # start the game self.generate_tile() self.generate_tile() self.input.listen()
def __init__(self) -> None: self.input1 = Input(Device(config.device1)) self.input2 = Input(Device(config.device2)) self.position = 0 self.min_position = 0 self.max_position = 3 self.entered = False
def pacman_die(self): if self.scores.lives >= 1: self.scores.lives -= 1 if self.scores.lives: Music.play('go') self.units.reset() Input.reset() else: self.game_over()
def next_level(self): # type: () -> None """Switch to next level""" self.scores.level += 1 Input.reset() self.field = Field(str(self.scores.level) + '_lvl.txt') self.units.add_pacman(self.field.get_pacman_spawn()) self.units.add_ghosts(self.field.get_ghosts_spawn()) Music.play('bg', .1)
def initGameObjects(self): self.prevGameState = self.gameState self.inp = Input() self.gameBoard = GameBoard(self) self.shipMan = ShipManager(self.screen, GameBoard.BOTTOM) self.hitMan = HitManager(self.screen) self.opponent = Opponent(self.screen, OpponentType.AI) self.helpergui = Helpergui(self) self.sound = Sound(self.screen)
def __init__(self, pyray, font, config): self.pyray = pyray self.font = font self.config = config self.input = Input(self.pyray, self.font) self.device = DeviceIO() self.race_type = None # The config object passed in was modified by the user within the configuration menu self.config_updated = False self.race_timeout_updated = False # Initialize attributes used to select the number of lanes self.num_lanes_selected = False self.num_lanes_pos = False # Initialize attributes used to set servo limits self.servo_down_value_updated = False self.servo_up_value_updated = False self.cursor_pos = MenuState.SINGLE_TRACK # Start at the top of the main menu self.current_func = self.__top_menu # Dispaly loop calls __top_menu function self.config_window_top = MenuState.TRACK_NAME # Initial config menu window top self.config_window_bottom = MenuState.TRACK_NAME # Initial config menu window bottom self.config_menu_pos = self.config_window_top # Initial window position for config menu self.config_menu_first = MenuState.TRACK_NAME # Top of config menu, up wraps self.config_menu_last = MenuState.RESET # Bottom of config menu, down wraps self.last_cursor_pos = MenuState.RESET self.__init_function_pointers() # Initialize attributes used for selecting car images self.car_icons_loaded = False self.car_icon_index = 0 self.car_textures = [] self.car_icon_selected = None background_image = self.pyray.load_image("images/background.png") self.background_texture = self.pyray.load_texture_from_image( background_image) self.pyray.unload_image(background_image) single_track_image = self.pyray.load_image("images/Single-Track.png") self.single_track_texture = self.pyray.load_texture_from_image( single_track_image) self.pyray.unload_image(single_track_image) multi_track_image = self.pyray.load_image("images/Multi-Track.png") self.multi_track_texture = self.pyray.load_texture_from_image( multi_track_image) self.pyray.unload_image(multi_track_image) configure_image = self.pyray.load_image("images/Configure.png") self.configure_texture = self.pyray.load_texture_from_image( configure_image) self.pyray.unload_image(configure_image)
class Game(object): def __init__(self): pygame.mixer.pre_init(44100, 16, 2, 4096) # setup mixer to avoid sound lag pygame.init() pygame.display.set_caption("lakeception") self.world = World("Test World", (100,100), debug=False) # resolution, viewport self.screen = Screen(self.world, (800, 475), (25, 11)) self.screen = Screen(self.world, (800, 475), (99, 99)) # debug res self.input = Input(self) self.fps = 60 self.clock = pygame.time.Clock() self.ANIMATE = pygame.USEREVENT+0 self.animationRate = 1 * 1000 # Temporarily (?) disabled animations, because moving + animating was # an INTENSE visual experience # pygame.time.set_timer(self.ANIMATE, self.animationRate) self.updated = True self.quitting = False self.muted = False self.inspecting = False self.editing = False pygame.mixer.init() # From https://www.freesound.org/people/juskiddink/sounds/60507/ # albeit a bit mixed to allow for looping tracks = [] tracks.append(pygame.mixer.Sound(os.path.join(sys.path[0],'60507__juskiddink__waves2.ogg'))) tracks.append(pygame.mixer.Sound(os.path.join(sys.path[0],'sea-space.ogg'))) # Play & loop crashing waves in the background # Set the volume to an unobtrusive level tracks[0].set_volume(0.1) tracks[0].play(-1) # Play the song at a slightly higher volume # tracks[1].set_volume(0.4) # tracks[1].play() def tick(self): for event in pygame.event.get(): if event.type == pygame.KEYDOWN: self.input.handleKey(event) elif event.type == self.ANIMATE: self.screen.draw() self.updated = False elif event.type == pygame.QUIT: self.quitting = True if self.updated: self.screen.draw(self.inspecting, self.editing) self.updated = False timeDelta = self.clock.tick(self.fps)
def iniciar(self): log.info("iniciar") self._establecer_parametros() # b = self.contexto.base # física self.mundo_fisica.setGravity(Vec3(0, 0, -9.81)) df = BulletDebugNode("debug_fisica") self.mundo_fisica.setDebugNode(df) self.debug_fisica = b.render.attachNewNode(df) self.debug_fisica.hide() self.accept("f11", self._toggle_debug_fisica) # input self.input = Input(self.contexto) if not self.input.iniciar(): return False # terreno if self.cargar_terreno: self.terreno = Terreno(self.contexto, self.mundo_fisica) if not self.terreno.iniciar(): return False # animados (actors) self._iniciar_animados() # atmosfera if self.cargar_atmosfera: self.atmosfera = Atmosfera(self.contexto) if not self.atmosfera.iniciar(): return False # controlador camara self.cntrlcam = ControladorCamara(self.contexto) if not self.cntrlcam.iniciar(): return False # info texto self.info_texto = OnscreenText( text="cámara: f1:libre f2:1ºpers f3:3ºpers\n" "debug física: f11") # debug hud self.debug_hud = OnscreenText(parent=b.a2dTopLeft, text="Debug?", pos=(0, -0.1), scale=0.05, align=TextNode.ALeft, bg=(1, 1, 1, 0.3)) # pelota (ball) pelota = b.loader.loadModel("modelos/items/pelota.egg") pelota.reparentTo(b.render) pelota.setPos(0, 0.5, 15) b.messenger.send("establecer_objetivo", [pelota]) # eventos self.accept("escape-up", self._salir) # tasks b.taskMgr.doMethodLater(0.1, self._update_debug_hud, "Mundo_update_debug_hud") b.taskMgr.add(self._update, "Mundo_update") # return True
def __init__(self, level, **kwargs): super().__init__(**kwargs) self._level = level self._part = None self._s = Surface((20, 10)) self._s.fill((255, 0, 0)) self._input = Input(inputStream=self.getInputStream()) self._input.set(pygame.KEYDOWN, self.createNew, pygame.K_f)
def main(): pygame.init() pygame.font.init() screen = pygame.display.set_mode((1200, 700)) delta_time = 0 views = [] #Create a Game view game = Game(screen) views.append(game) #Create a Menu view menu = Menu(screen, game) views.append(menu) lastTime = time.time() while (True): # Process OS events evt = pygame.event.get() for event in evt: # Checks if the user closed the window if (event.type == pygame.QUIT): # Exits the application immediately return elif (event.type == pygame.KEYDOWN): if (event.key == pygame.K_ESCAPE): return if (event.key == pygame.K_KP_ENTER): game.on_finish_game() #Update mouse inputs Input.update(evt) #Paint Background screen.fill((0, 20, 20)) #Draw views for v in views: v.draw(screen) #Display result on screen pygame.display.flip() #Update delta _time delta_time = time.time() - lastTime lastTime = time.time() #call coroutines Routine.delta_time = delta_time for r in Routine.routines: v = next(r, False) if (v == False): Routine.routines.remove(r)
def _mainloop(self, fps): step = 1. / fps clock = pygame.time.Clock() while not Input.quitflag: Input.update() map(GameObject.update, GameObject._gameobjects) #self.scene.lateupdate() self._renderloop() PhysicsEngine.step(step * Game.scale) delta = clock.tick(fps) Game.delta = delta / 1000.
class Game: def __init__(self): self.inp = Input() self.upd = Update() self.player1 = Player() self.out = Output() def update(self): self.inp.update(self.upd) self.upd.update(self.player1, self.out) self.out.update()
class Game(): '''A class containing all major elements of the game engine. GUI, input, draw functions, current state, save/load, AI, map functions, as well as settings.''' def __init__(self): '''Initializes the Game class.''' self.clock = pygame.time.Clock() # Initialize display, state self.display, self.state = Display(), State(self) # Initialize GUI and scene self.gui, self.scene = Gui(self), Scene(self) # Initialize input self.input = Input(self) self.gui.mainMenu() def events(self): '''Handles events such as input, but also ingame events which raise dialogs.''' # Iterate over new events for event in pygame.event.get(): # Quit if event.type == pygame.QUIT: sys.exit() else: self.input.handle(event) def update(self): '''Goes through updates on the game engine and manages time. :return: ''' # Update each sprite group. self.gui.widgets.update() self.scene.sprites.update() # Refresh pygame's event list. pygame.event.pump() # Keep framerate at 30 fps. self.clock.tick(30) def draw(self): '''Send current sprites to be drawn on the display.''' self.display.draw(self.gui.widgets, self.scene.sprites)
def __init__(self, args): """ BoomBoomClient constructor. @param host: Server hostname. @type host: C{str} @param display_port: Server port for "display"/"view" connection. @type display_port: C{int} @param input_port: Server port for "input" connection. @type input_port: C{int} @param verbose: Verbose mode flag. @type verbose: C{bool} @param debug: Debug mode flag. @type debug: C{bool} @param max_fps: Maximal number of frames per second, for optimization. @type max_fps: C{int} """ args["protocol"] = protocol.loadProtocol("protocol.xml") args["features"] = ["game"] # Constant features Happyboom.__init__(self, args) EventListener.__init__(self, prefix="evt_") self.display = Display(args) self.input = Input(args) self.__verbose = args.get("verbose", False) self.registerEvent("happyboom") self.registerEvent("game")
def __init__(self, levels): super().__init__() # --- Inits os.environ["SDL_VIDEO_CENTERED"] = "1" pygame.mixer.pre_init(44100, 16, 2, 4096) pygame.init() pygame.font.init() pygame.display.set_caption(const.gameName) self._surface = pygame.display.set_mode((const.screenSize[0] * const.res, const.screenSize[1] * const.res)) self._clock = pygame.time.Clock() self._levAttr = levels self._world = None self._paused = False self._menu = Menu(surface=self._surface, pos=(const.screenSize[0] * const.res / 2 - 50, const.screenSize[1] * const.res / 2 - 100), inputStream=self.getInputStream()) self._menu.addItem("resume", (0, 0, 100, 48), MColor((255, 0, 0), (0, 0, 255)), MText("Resume", (0, 255, 0)), MAction(self._resume)) self._menu.addItem("start", (0, 50, 100, 48), MColor((255, 0, 0), (0, 0, 255)), MText("Start", (0, 255, 0)), MAction(self.start)) self._menu.addItem("editor", (0, 100, 100, 48), MColor((255, 0, 0), (0, 0, 255)), MText("Editor", (0, 255, 0)), MAction(self._editor)) self._menu.addItem("exit", (0, 150, 100, 48), MColor((255, 0, 0), (0, 0, 255)), MText("Exit", (0, 255, 0)), MAction(self.setFinished)) self._input = Input(inputStream=self.getInputStream()) self._input.set(pygame.KEYDOWN, self._menuToggle, pygame.K_m) self._input.set(pygame.KEYDOWN, self._pause, pygame.K_p)
def __init__(self, level, speed, tileset, **kwargs): super().__init__( dirRule=lambda: { -1: Direction.Left, 0: None, 1: Direction.Right }[self.move.getDir(x=True)], **kwargs) self.collision = Collision(self, level) self.move = Move(self, speed, collision=self.collision) self._gravity = GravityLine(self, 2, h=level.map.h // 2) self.jumping = Jumping(self.move, self._gravity, 2) self._input = Input(inputStream=self.getInputStream()) self.applyInputSettings() self._damageTimer = MinTimeEventStream(duration=2) self._damageTimer.subscribe("self", self._takeDmg, autoInit=False) def _isMoving(): return self.move.getSpeed(x=True) != 0 def _hDir(): return self.move.getDir(x=True) def _vDir(): return {False: -1, True: 1}[self._gravity.positiveDir()] image = Files.loadImage(tileset) self._display = Display(image, self, Animation(image, 11, _isMoving, _hDir, _vDir), True) self._weapon = Weapon(level, anchor=self, offsetFunc=lambda: ((5 * self.getIntDir()), 0), inputStream=self.getInputStream())
def __init__(self): '''Initializes the Game class.''' self.clock = pygame.time.Clock() # Initialize display, state self.display, self.state = Display(), State(self) # Initialize GUI and scene self.gui, self.scene = Gui(self), Scene(self) # Initialize input self.input = Input(self) self.gui.mainMenu()
def __init__(self, screen, width, height, debug=False, start_level=1): self.target_fps = 60 self.clock = pygame.time.Clock() self.running = False self.test_text = "Hello world" self.font = pygame.font.Font('./assets/font/vcr.ttf', 28) self.screen = screen self.width = width self.height = height self.current_scene = None self.restarting = False self.input = Input(pygame.key, pygame.mouse) self.current_scene = MenuScene(self, start_level) self.next_scene = None self.debug = debug
def __init__(self, id = -1, config = None): self.id = id self.set_config(config) # inner data structure self.input = Input() self.context_database = ContextDatabase() self.assorted_context_database = AssortedContextDatabase() self.output = Output() self.context_history = ContextHistory() # instance variables for debugging purposes self.new_aggregate = None self.filtered_singles = None self.data = None self.average = None
def start(self): self.map.load() self._entity_map = {} self._position_map = {} self._entities = {} self._registered = {} self._enemySpawns = {} for x, y in self.map.getMap().keys(): self._position_map[(x, y)] = [] self._total_surface = Surface((self.map.w, self.map.h)) tid = self.addEntity(register=True, entity=MChar(self, self.map.getType(Tiles.Start)[0], inputStream=self.getInputStream())) self._camera = Viewport(tuple([s * const.res for s in const.screenSize]), lambda: self.map.getAttr("scale"), self.get(tid), (150, 200, 150, 200), self.map) self._background = Parallax(const.backgrounds) self.editor = Editor(self.map, self._surface, enabled=False, inputStream=self.getInputStream()) self._input = Input(inputStream=self.getInputStream()) self._input.set(KEYDOWN, self.editor.toggleEnabled, K_e) self._input.set(KEYDOWN, self.start, K_r) # self._sound = Sound("assets\\music.ogg") # self._sound.play(-1) try: self._healthBar = HealthBar(10, 10, self.get(tid)) except AssertionError: pass for (x, y), val in self.map.enemies.items(): block = self.map.get(x, y) self._enemySpawns[block] = EnemySpawn(level=self, anchor=Object(pos=(block.x, block.y)), maxEmitted=val, timeBetween=2) self._countdown = CountdownTimer(const.screenSize[0] * const.res - 50, 10, self.map.getAttr("timeLim"))
def main(): with open('sample_map.yaml') as f: data = yaml.load(f) map = Map(data) input_object = Input(read_line=input, put_line=print) game = Game(data = map) input_object.put_line(game.start()) while True: read = input_object.next_move() if read: move, args = read response = getattr(game, move)(*args) input_object.put_line(response)
class Game(Enableable, Completable, Inputable): def __init__(self, levels): super().__init__() # --- Inits os.environ["SDL_VIDEO_CENTERED"] = "1" pygame.mixer.pre_init(44100, 16, 2, 4096) pygame.init() pygame.font.init() pygame.display.set_caption(const.gameName) self._surface = pygame.display.set_mode((const.screenSize[0] * const.res, const.screenSize[1] * const.res)) self._clock = pygame.time.Clock() self._levAttr = levels self._world = None self._paused = False self._menu = Menu(surface=self._surface, pos=(const.screenSize[0] * const.res / 2 - 50, const.screenSize[1] * const.res / 2 - 100), inputStream=self.getInputStream()) self._menu.addItem("resume", (0, 0, 100, 48), MColor((255, 0, 0), (0, 0, 255)), MText("Resume", (0, 255, 0)), MAction(self._resume)) self._menu.addItem("start", (0, 50, 100, 48), MColor((255, 0, 0), (0, 0, 255)), MText("Start", (0, 255, 0)), MAction(self.start)) self._menu.addItem("editor", (0, 100, 100, 48), MColor((255, 0, 0), (0, 0, 255)), MText("Editor", (0, 255, 0)), MAction(self._editor)) self._menu.addItem("exit", (0, 150, 100, 48), MColor((255, 0, 0), (0, 0, 255)), MText("Exit", (0, 255, 0)), MAction(self.setFinished)) self._input = Input(inputStream=self.getInputStream()) self._input.set(pygame.KEYDOWN, self._menuToggle, pygame.K_m) self._input.set(pygame.KEYDOWN, self._pause, pygame.K_p) def start(self): self.enable() self._world = World(self._surface, self._levAttr, inputStream=self.getInputStream()) self._world.nextLevel() self._menu.disable() def _pause(self): self._paused = not self._paused def _resume(self): if self._world is not None and not self._world.isComplete(): self.enable() else: self.start() self._menu.disable() def _editor(self): if self._world: self._world.level.editor.enabled() self._menu.disable() def _menuToggle(self): self._menu.toggleEnabled() self.toggleEnabled() def tick(self): self.getEvents() self._input() if self._menu.enabled(): self._menu.tick() self._menu.draw() elif self.enabled: if self._world.isComplete(): if self._world.isFinished(): self._win() elif self._world.isLost(): self._gameOver() else: if not self._paused: self._world.tick() self.clearInputStream() self._clock.tick(const.FPS) pygame.display.flip() def _win(self): self._endGame("YOU WIN!") def _gameOver(self): self._endGame("GAME OVER!") def _endGame(self, text): try: self.__gameOverCount += 1 except AttributeError: self.__gameOverCount = 1 self.__goText = pygame.font.Font(None, 100).render(text, 1, (255, 0, 0)) self.__gameOverX = int(self._surface.get_width() / 2 - self.__goText.get_width() / 2) self.__gameOverY = int(self._surface.get_height() / 2 - self.__goText.get_height() / 2) if self.__gameOverCount < (const.FPS * 5): self._surface.fill((0, 0, 0)) self._surface.blit(self.__goText, (self.__gameOverX, self.__gameOverY)) else: self.__gameOverCount = 0 self._surface.fill((0, 0, 0)) self._menuToggle() Event = namedtuple("Event", "type key pos") def getEvents(self): result = self.getInputStream() for event in pygame.event.get(): if event.type in [pygame.KEYDOWN, pygame.KEYUP]: result.append(Game.Event(event.type, event.key, None)) if event.type in [pygame.MOUSEBUTTONDOWN, pygame.MOUSEBUTTONUP, pygame.MOUSEMOTION]: result.append(Game.Event(event.type, None, event.pos)) if event.type == pygame.QUIT: self.setFinished()
def run(self): graphics = Graphics(units.tileToPixel(SCREEN_WIDTH), units.tileToPixel(SCREEN_HEIGHT)) input = Input() event = SDL_Event() self.player = Player(graphics, units.tileToGame(SCREEN_WIDTH // 2), units.tileToGame(SCREEN_HEIGHT // 2)) self.bat = FirstCaveBat(graphics, units.tileToGame(7), units.tileToGame(SCREEN_HEIGHT // 2 + 1)) self.map = Map.createTestMap(graphics) running = True lastUpdateTime = SDL_GetTicks() # units.MS while running: startTime = SDL_GetTicks() # units.MS input.beginNewFrame() while SDL_PollEvent(ctypes.byref(event)): if event.type == SDL_KEYDOWN: input.keyDownEvent(event) elif event.type == SDL_KEYUP: input.keyUpEvent(event) if input.wasKeyPressed(SDLK_ESCAPE): running = False # Player horizontal movement if input.isKeyHeld(SDLK_LEFT) and input.isKeyHeld(SDLK_RIGHT): self.player.stopMoving() elif input.isKeyHeld(SDLK_LEFT): self.player.startMovingLeft() elif input.isKeyHeld(SDLK_RIGHT): self.player.startMovingRight() else: self.player.stopMoving() # Player look if input.isKeyHeld(SDLK_UP) and input.isKeyHeld(SDLK_DOWN): self.player.lookHorizontal() elif input.isKeyHeld(SDLK_UP): self.player.lookUp() elif input.isKeyHeld(SDLK_DOWN): self.player.lookDown() else: self.player.lookHorizontal() # Player jump if input.wasKeyPressed(SDLK_z): self.player.startJump() elif input.wasKeyReleased(SDLK_z): self.player.stopJump() currentTime = SDL_GetTicks() # units.MS elapsedTime = currentTime - lastUpdateTime # units.MS self.update(min(elapsedTime, MAX_FRAME_TIME)) lastUpdateTime = currentTime self.draw(graphics) # This loop lasts 1/60th of a second, or 1000/60th ms msPerFrame = 1000 // FPS # units.MS elapsedTime = SDL_GetTicks() - startTime # units.MS if elapsedTime < msPerFrame: SDL_Delay(msPerFrame - elapsedTime)
def initInput(self): """ Initializes the input class """ self.input = Input()
class SceneManager(object): _instance2 = None _count2 = 0 def __new__(cls, *args, **kwargs): if not cls._instance2: cls._instance2 = super(SceneManager, cls).__new__( cls, *args, **kwargs) # _count += 1 print "Created new instance of SceneManger" return cls._instance2 def __init__(self): """ Initializes the scenemanager """ # Display some text if SceneManager._count2 == 0: #Init self.initPygame() self.initEventReaders() self.initScreen() self.initClock() self.initInput() self.initGame() SceneManager._count2 += 1 def initGame(self): """ Initializes the first scene """ self.gamemode = GameModes.MENU_MAIN self.scene = None self.running = True def initPygame(self): """ Initializes pygame """ result = pygame.init() return result[1] def initEventReaders(self): """ Initializes the event readers """ self.eventReaders = [] def initScreen(self): """ Initializes the screen """ self.surface = pygame.display.set_mode([Settings.SCREEN_WIDTH, Settings.SCREEN_HEIGHT]) #retourneert Surface pygame.display.set_caption(Settings.GAME_TITLE) def initClock(self): """ Initializes the clock """ self.clock = pygame.time.Clock() def initInput(self): """ Initializes the input class """ self.input = Input() def run(self): """ Run the scene """ while(self.running): self.clock.tick(90) self.input.update() #E Event for event in pygame.event.get(): if event.type == pygame.QUIT: self.running = False else: for eventReader in self.eventReaders: eventReader(event) self.scene.update(self.input) self.surface.fill(Settings.SCREEN_COLOR) self.scene.draw(self.surface) pygame.display.flip() self.scene.clean() def setScene(self, scene): """ Change the scene @param scene: The new scene """ if self.scene: self.scene.clean() if not scene == None: self.scene = scene else: self.running = False def registerEventReader(self, callback): """ Register a event reader @param callback: The function that should be called """ self.eventReaders.append(callback) def unregisterEventReader(self, callback): """ Unregisters a event reader @param callback: The function that should be unregistered """ self.eventReaders.remove(callback)
class Client(Happyboom, EventListener): """ The main class of the client of BoomBoom. @ivar display: Display manager of the game. @type display: C{L{BoomBoomDisplay}} @ivar input: Input manager of the game. @type input: C{L{BoomBoomInput}} @ivar __verbose: Verbose mode flag. @type __verbose: C{bool} @ivar __stopped: Stopped game flag. @type __stopped: C{bool} @ivar __stoplock: Mutex for synchronizing __stopped. @type __stoplock: C{thread.lock} """ def __init__(self, args): """ BoomBoomClient constructor. @param host: Server hostname. @type host: C{str} @param display_port: Server port for "display"/"view" connection. @type display_port: C{int} @param input_port: Server port for "input" connection. @type input_port: C{int} @param verbose: Verbose mode flag. @type verbose: C{bool} @param debug: Debug mode flag. @type debug: C{bool} @param max_fps: Maximal number of frames per second, for optimization. @type max_fps: C{int} """ args["protocol"] = protocol.loadProtocol("protocol.xml") args["features"] = ["game"] # Constant features Happyboom.__init__(self, args) EventListener.__init__(self, prefix="evt_") self.display = Display(args) self.input = Input(args) self.__verbose = args.get("verbose", False) self.registerEvent("happyboom") self.registerEvent("game") def start(self): """ Starts the game client.""" if self.__verbose: log.info("[BOOMBOOM] Starting client...") Happyboom.start(self) # Create thread for display thread.start_new_thread(self.displayThread, ()) quit = False while not quit: self.input.process() time.sleep(0.100) quit = self.stopped def stop(self): """ Stops the game client.""" if self.__verbose: log.info("[BOOMBOOM] Stopping client...") Happyboom.stop(self) self.launchEvent("happyboom", "disconnection", self._io, u"Quit.") self.display.stop() def evt_game_stop(self): self.stop() def evt_happyboom_stop(self): """ Stop event handler. """ self.stop() def displayThread(self): """ Thread handler for the "display" part.""" try: self.display.start() except Exception, msg: bt = getBacktrace() log.error("EXCEPTION IN DISPLAY THREAD:\n%s\n%s" % (msg, bt)) try: self.stop() except Exception, msg: bt = getBacktrace() log.error("EXCEPTION (2) IN DISPLAY THREAD:\n%s\n%s" % (msg, bt))
class Game(object): def __init__(self, screen, width, height, debug=False, start_level=1): self.target_fps = 60 self.clock = pygame.time.Clock() self.running = False self.test_text = "Hello world" self.font = pygame.font.Font('./assets/font/vcr.ttf', 28) self.screen = screen self.width = width self.height = height self.current_scene = None self.restarting = False self.input = Input(pygame.key, pygame.mouse) self.current_scene = MenuScene(self, start_level) self.next_scene = None self.debug = debug # self.background = Background((800, 600), 'assets/img/bgs.png') def run(self): self.running = True current_time = 0 previous_time = time.time() while self.running: self.clock.tick( self.target_fps ) self.input.update() if not self.next_scene is None: self.current_scene = copy.copy(self.next_scene) self.next_scene = None for event in pygame.event.get(): if event.type == pygame.QUIT: self.running = False self.restarting = False self.input.handle_event(event) if game.input.is_down(pygame.K_ESCAPE): self.running = False self.restarting = False current_time = time.time() delta_time = (current_time - previous_time) self.update(delta_time) self.draw() if self.debug: fps = round(1.0 / delta_time) fps_text = 'FPS: {0}'.format(fps) fps_w, fps_h = self.font.size(fps_text) fps_text_pos = (self.width - fps_w - 40, 20) self.screen.blit(self.font.render(fps_text, 1, WHITE), fps_text_pos) pygame.display.update() previous_time = current_time if self.restarting: game.run() else: game.quit() def restart(self): self.running = False self.restarting = True def quit(self): pygame.quit() quit() def update(self, dt): self.current_scene.update(dt) def draw(self): self.current_scene.draw()
def test_wrong_input(self): result = [] input = Input(self.__make_input(['dupa']), self.__make_output(result)) self.assertEqual(input.next_move(), None) self.assertEqual(result, ['Wrong move. Try: look.'])
def test_look(self): result = [] input = Input(self.__make_input(['look']), self.__make_output(result)) self.assertEqual(input.next_move(), ("look", []))
def main(): pygame.init() pygame.display.gl_set_attribute(pygame.GL_DEPTH_SIZE, 16) screen = pygame.display.set_mode((800,600), pygame.OPENGL|pygame.DOUBLEBUF) inp = Input() glEnable(GL_DEPTH_TEST) glDepthFunc(GL_LEQUAL) glDisable(GL_CULL_FACE) glBlendFunc(GL_SRC_ALPHA, GL_ONE) glViewport(0,0,800,600) print 'Window: Actual color bits r%d g%d b%d a%d'%( pygame.display.gl_get_attribute(pygame.GL_RED_SIZE), pygame.display.gl_get_attribute(pygame.GL_GREEN_SIZE), pygame.display.gl_get_attribute(pygame.GL_BLUE_SIZE), pygame.display.gl_get_attribute(pygame.GL_ALPHA_SIZE)) print 'Window: Actual depth bits: %d'%( pygame.display.gl_get_attribute(pygame.GL_DEPTH_SIZE),) print 'Window: Actual stencil bits: %d'%( pygame.display.gl_get_attribute(pygame.GL_STENCIL_SIZE),) print 'Window: Actual multisampling samples: %d'%( pygame.display.gl_get_attribute(pygame.GL_MULTISAMPLESAMPLES),) print "Running..." frame = 0 old_t = 0 scene = MainScene() try: scene.init() max_fps = 65.0 frame_ticks = 1000.0 / max_fps while True: glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT) t = pygame.time.get_ticks() inp.process() if (inp.shouldQuit()): break scene.advance(screen, t, inp) #t0 = pygame.time.get_ticks() pygame.display.flip() #t1 = pygame.time.get_ticks() dt = pygame.time.get_ticks() - t pygame.time.delay(max(0,int(frame_ticks - dt))) # be nice and yield some time #------ if 0: frame += 1 if (t - old_t > 1000.0): dt = t - old_t #load = 1.0 - float(t1-t0) / dt #print "%s FPS, LOAD: %s%%"%(1000.0*(float(frame) / dt), int(load*100) ) print "%s FPS"%(1000.0*(float(frame) / dt)) prof.printTotals(frame) frame = 0 old_t = t finally: scene.destroy()
class Level(Completable, Inputable): def __init__(self, surface, level, **kwargs): super().__init__(**kwargs) self._surface = surface self.map = Map(level[0], level[1]) def start(self): self.map.load() self._entity_map = {} self._position_map = {} self._entities = {} self._registered = {} self._enemySpawns = {} for x, y in self.map.getMap().keys(): self._position_map[(x, y)] = [] self._total_surface = Surface((self.map.w, self.map.h)) tid = self.addEntity(register=True, entity=MChar(self, self.map.getType(Tiles.Start)[0], inputStream=self.getInputStream())) self._camera = Viewport(tuple([s * const.res for s in const.screenSize]), lambda: self.map.getAttr("scale"), self.get(tid), (150, 200, 150, 200), self.map) self._background = Parallax(const.backgrounds) self.editor = Editor(self.map, self._surface, enabled=False, inputStream=self.getInputStream()) self._input = Input(inputStream=self.getInputStream()) self._input.set(KEYDOWN, self.editor.toggleEnabled, K_e) self._input.set(KEYDOWN, self.start, K_r) # self._sound = Sound("assets\\music.ogg") # self._sound.play(-1) try: self._healthBar = HealthBar(10, 10, self.get(tid)) except AssertionError: pass for (x, y), val in self.map.enemies.items(): block = self.map.get(x, y) self._enemySpawns[block] = EnemySpawn(level=self, anchor=Object(pos=(block.x, block.y)), maxEmitted=val, timeBetween=2) self._countdown = CountdownTimer(const.screenSize[0] * const.res - 50, 10, self.map.getAttr("timeLim")) def addEntity(self, register=False, entity=None): if not entity: raise Exception("Entity must not be None.") tid = entity.getId() self._entities[tid] = entity if register: self._registered[tid] = entity self._entity_map[tid] = set() return tid def removeEntity(self, entity): del self._entities[entity.id] def get(self, entityId): return self._entities.get(entityId) def process(self): for entity in self._entities.values(): result = entity.tick() if not entity.isAlive(): self._entities.pop(entity.getId()) # This should generally only apply to playable characters. if entity in self._registered.values(): if Tiles.End in result.keys(): self.setFinished() if not entity.isAlive(): self.setLost() for s in self._enemySpawns.values(): s.tick() self._camera.tick() self._countdown.tick() if self._countdown.isFinished(): self.setLost() if self.editor.enabled(): self.editor.tick(self._camera) if self.isComplete(): pass # self._sound.fadeout(3000) def render(self): self._surface.fill((0, 0, 0)) self._background.draw(self._total_surface, self._camera) for s in self._enemySpawns.values(): s.draw(self._total_surface) for entity in self._entities.values(): entity.draw(self._total_surface) self.map.draw(self._total_surface) if self.editor.enabled(): self.editor.draw(self._total_surface) self._camera.draw(self._surface, self._total_surface) self._healthBar.draw(self._surface) self._countdown.draw(self._surface) if self.editor.enabled(): self.editor.menu.draw() def tick(self): self._input() self.process() self.render()
def test_move(self): result = [] input = Input(self.__make_input(['move north']), self.__make_output(result)) self.assertEqual(input.next_move(), ("move", ['north']))
import socket import struct import time from input import Input class piCmd(object): __slots__ = [ 'lMotorVal', 'rMotorVal', 'lMotorBrake', 'rMotorBrake' ] def getVals(self): return (self.lMotorVal, self.rMotorVal, self.lMotorBrake, self.rMotorBrake) controller = Input(12000, 32768, 255) clientsocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) clientsocket.connect(('192.168.0.200', 9595)) running = True while running: #time.sleep(.05) time.sleep(1) state = controller.getState() #print( state ) cmd = piCmd() cmd.lMotorVal = int(state["rtrigger"]) cmd.rMotorVal = int(state["rtrigger"]) cmd.lMotorBrake = 0 cmd.rMotorBrake = 0 data = cmd.getVals() numElements = len(data)
def __init__(self, id, function): Input.__init__(self, id, function)
def initInput(self): self.input = Input(self, self.robots[0], self.robots[1])
class Simulator(object): objects=[] robots=[] images={} # Options and arguments headless=False vision=None pitch=None ai=[] robot1=None robot2=None def __init__(self, **kwargs): logging.debug("Simulator started with the arguments:") for k, v in kwargs.items(): self.__setattr__(k, v) logging.debug("\t%s = %s", k, v) def initVision(self): if self.vision: logging.info("Starting simulator vision bridge") world = self.world if not self.real_world: # Vision must always use the real World world = common.world.World(self.colour) self.vision = Vision(simulator=self, world=world) self.visionFile = tempfile.mktemp(suffix='.bmp') def drawEnts(self): if self.pitch: bg = self.pitch.get() self.screen.blit(bg, (0,0)) self.sprites.draw(self.screen) if self.vision: pygame.image.save(self.screen, self.visionFile) self.vision.processFrame() # Update overlay after we've passed the "raw image" to vision self.screen.blit(self.overlay, (0,0)) # Make the overlay "blank" again. Should be completely # transparent but I don't know how to do that self.overlay.fill( (130,130,130,255)) if not self.headless: pygame.display.flip() def initScreen(self): logging.debug("Creating simulator screen") if self.headless: self.screen = pygame.Surface(World.Resolution) else: pygame.display.set_mode(World.Resolution) pygame.display.set_caption('SDP 9 Simulator') self.screen = pygame.display.get_surface() self.overlay = pygame.Surface(World.Resolution) self.overlay.convert_alpha() self.overlay.set_alpha(100) def makeObjects(self): logging.debug("Creating game objects") colours = ('blue', 'yellow') if random() < 0.5: col1, col2 = colours else: col2, col1 = colours logging.info("Robot 1 is %s. Robot 2 is %s", col1, col2) self.makeRobot(World.LeftStartPos, col1, 0, self.robot1[0]) self.makeRobot(World.RightStartPos, col2, -pi, self.robot2[0]) # Only make a real ball when there are two simulated robots if len(self.robots) == 2: pos = World.Pitch.center logging.info("Creating a ball at %s", pos2string(pos)) self.makeBall(pos) else: logging.info("Not making a simulated ball with real robots") self.sprites = pygame.sprite.RenderPlain(self.objects) def setRobotAI(self, robot, ai): # TODO: just delete the image and reclassify the robot as a # real robot #del robot pass def initAI(self): logging.debug("Initialising AI") ai1, real1 = self.robot1 ai2, real2 = self.robot2 if ai1 and real1: real_interface = RealRobotInterface() #meta_interface = MetaInterface(real_interface, self.robots[0]) ai = ai1(self.world, real_interface) self.ai.append(ai) robotSprite = self.robots[0] #self.robots[0] = ai #del robotSprite self.setRobotAI(self.robots[0], ai) logging.debug("AI 1 started in the real world") elif ai1: self.ai.append( ai1(self.world, self.robots[0]) ) logging.debug("AI 1 started in the simulated world") else: logging.debug("No AI 1 present") if ai2 and real2: # TODO: reverse sides here ai = ai2(self.world, RealRobotInterface()) self.ai.append(ai) robotSprite = self.robots[0] self.robots[1] = ai #del robotSprite self.setRobotAI(self.robots[1], ai) logging.debug("AI 2 started in the real world") elif ai2: self.ai.append( ai2(self.world, self.robots[1]) ) logging.debug("AI 2 started in the simulated world") else: logging.debug("No AI 2 present") def runAI(self): #logging.debug("Running AI players") for ai in self.ai: ai.run() def run(self): pygame.init() self.clock = pygame.time.Clock() self.initVision() self.initScreen() self.loadImages() self.makeObjects() self.world.assignSides() self.initAI() self.initInput() # by initialising the input after the AI, we can control even # AI robots with keyboard self.drawEnts() while True: self.handleInput() self.clock.tick(25) self.drawEnts() self.sprites.update() self.runAI() def initInput(self): self.input = Input(self, self.robots[0], self.robots[1]) def handleInput(self): for event in pygame.event.get(): if event.type == QUIT: sys.exit(0) else: #logging.debug("Got input event: %s", event) self.input.robotInput(event) def makeRobot(self, pos, colour, angle, ai): ent = Robot(self, pos, self.images[colour], angle) ent.side = colour self.world.ents[colour] = ent self.robots.append(ent) self.addEnt(ent) def makeBall(self, pos): ent = Ball(self, pos, self.images['ball']) #ent.v += [1, 7] self.world.ents['ball'] = ent self.addEnt(ent) def addEnt(self, ent): self.objects.append(ent) def loadImages(self): logging.debug("Loading images") for name in World.image_names.keys(): self.images[name] = pygame.image.load(World.image_names[name])