def __init__(self, verb=0): self.mem = Memory() self.reg = Registers() self.instr = Instructions(self) self.stack = Stack(self) self.zf = False self.cf = False self.verb = verb
def main(): #pygame init pygame.mixer.pre_init(SAMPLE_RATE, BIT, CHANNELS, BUFFER_SIZE) pygame.init() pygame.display.set_mode((WIDTH, HEIGHT)) pygame.display.set_caption('PyTone') #make background background = Gradient((WIDTH, HEIGHT), GRAD_START, GRAD_END) #path to medias path = 'media/' pygame.display.set_icon(pygame.image.load(path + 'petrol.png')) #intro duration in milliseconds duration = 4000 #states intro = Intro(background, path, duration) menu = Menu(background, path) game = Game(background, path) instructions = Instructions(background, path) intro.run() #storing return value from menu running = True while running: option = menu.run() if option == NEW_GAME: option = game.run() elif option == INSTRUCTIONS: instructions.run() elif option == PRACTICE: #intro.run() game.set_practise(True) game.run() game.set_practise(False) #no elif here to make different states be able to quit as well if option == pygame.locals.QUIT: pygame.quit() running = False
def __init__(self): self.settings = GameSettings() self.scoreBoard = ScoreBoard(self.settings) self.gameBoard = GameBoard(self.settings) self.instructions = Instructions() self.endScreen = EndScreen() self.ballGrid = [[0 for x in range(self.settings.numberBallsH)] for y in range(self.settings.numberBallsV)] self.level = 2 self.score = 0
def process_cli_args(args): currentIndex = 0 skipIndex = 0 instructions = None for item in args: if (skipIndex == currentIndex): currentIndex = currentIndex + 1 continue if (item == 'decode'): if (instructions is None): instructions = Instructions("decode") else: print("Not allowed to have multiple methods.") raise Exception() elif (item == 'encode'): if (instructions is None): instructions = Instructions("encode") else: print("Not allowed to have multiple methods.") raise Exception() elif (item == 'main.py'): print("found main method") elif (item == '-i'): iterations = int(args[currentIndex + 1]) instructions.iterations = iterations skipIndex = currentIndex + 1 else: instructions.string = item currentIndex = currentIndex + 1 return instructions
class CPU(object): def __init__(self, verb=0): self.mem = Memory() self.reg = Registers() self.instr = Instructions(self) self.stack = Stack(self) self.zf = False self.cf = False self.verb = verb def run(self): while self.instr.next(self.verb): pass
def game_thread(data): ''' Used by create_game. It is the component of the function that is run in a seperate thread. This is to prevent the controller from locking up. ''' print(data) global GAME global INSTRUCTIONS INSTRUCTIONS = True DISPLAY.update(Instructions().get(data)) SOCKETIO.sleep(25) INSTRUCTIONS = False GAME = GameList.select_game(data, list(USERS.values()), \ socketio=SOCKETIO, display_game=DISPLAY) SOCKETIO.emit('gameStarted', data, broadcast=True) GAME.run_game() threading.Thread(target=check_thread).start()
#!python # imports do sistema do python import sys import re # criados por nos from instructions import Instructions from registers import Registers instr = Instructions() regs = Registers() # parse dos registradores def parse_immediate(line): line = line.split() for i, token in enumerate(line): # ignore a instrucao e os registradores, # processe somente numeros decimais # (imediatos e numeros crus) if (i == 0 or token[0] == 'r'): continue # verifique o tamanho final das palavra word_size = (5 if i < 3 else 16) # altere o token (que e um numero) token = bin(int(token))[2:] # faca o prepend de zeros na frente do token pra que # ele tenha o tamanho correto line[i] = '0' * (word_size - len(token)) + token return ' '.join(line)
pauseGame = False # Pause mode musicPlaying = False # Toggle for music flashTextTimer = 60 # On-screen text timer highscore = 500 # Default highscore shakeX = 0 health = 10 # Health of ship bulletCount = 9 bombs = 0 # Bombs for player emergencies gameMode = 0 # 0 for arcade, 1 for survival # Counters shuttleTimer = 200 enemyTimer = 400 bossTimer = 500 # Init classes instructions = Instructions() bg = Background(0, 0) player = Player(playerPos[0], playerPos[1], 0, 94, 0, 71) audio = Audio(g_sound, isThisRealHardware) shake = Shake() # Sprites, images, objects bg = graphics.g_background.bg logo = graphics.g_items.logo scoreChars = [graphics.g_numbers.number0, graphics.g_numbers.number1, graphics.g_numbers.number2, graphics.g_numbers.number3, graphics.g_numbers.number4, graphics.g_numbers.number5, graphics.g_numbers.number6, graphics.g_numbers.number7, graphics.g_numbers.number8, graphics.g_numbers.number9] rockImages = [graphics.g_rocks.rock01, graphics.g_rocks.rock02, graphics.g_rocks.rock03, graphics.g_rocks.rock04, graphics.g_rocks.rock05] crystalImages = [graphics.g_items.crystal01, graphics.g_items.crystal02, graphics.g_items.crystal03, graphics.g_items.crystal04, graphics.g_items.crystal05, graphics.g_items.crystal06] playerShip = graphics.g_ships.playerShip shuttleShip = graphics.g_ships.ship04 enemyShipImages = [graphics.g_ships.ship01, graphics.g_ships.ship02, graphics.g_ships.ship03] bossShipImages = [graphics.g_ships.boss01, graphics.g_ships.boss02, graphics.g_ships.boss03, graphics.g_ships.boss04]
def instructionsGame(): screen_dimensions = utils.get_screen_dimensions() instructions = Instructions(screen_dimensions['width'], screen_dimensions['height']) instructions.run(True)
def run_game(): # Initialise pygame, settings and screen object. pygame.init() pygame.mixer.init() ai_settings = Settings() screen = pygame.display.set_mode( (ai_settings.screen_width, ai_settings.screen_height)) pygame.display.set_caption("Alien Invasion") # Make the Play button play_button = Button(ai_settings, screen, "Ready Player 1?") pause_button = Button(ai_settings, screen, "Paused") instructions = Instructions(ai_settings, screen) # Make a ship ship = Ship(ai_settings, screen) # Make a group to store bullets in bullets = Group() # Make a group to store aliens in aliens = Group() # Create a fleet of aliens gf.create_fleet(ai_settings, screen, ship, aliens) bombs = Group() # Make a group to store bricks in bricks_1 = Group() bricks_2 = Group() bricks_3 = Group() # Create a barrier of bricks gf.create_barriers(ai_settings, screen, ship, bricks_1, bricks_2, bricks_3) # create an instance to store game statistics and create a scoreboard stats = GameStats(ai_settings) sb = Scoreboard(ai_settings, screen, stats) # Start the main loop for the game. while True: # Watch for keybaord and mouse events. gf.check_events(ai_settings, stats, sb, screen, play_button, pause_button, ship, aliens, bullets, bombs, bricks_1, bricks_2, bricks_3) if stats.game_paused: gf.check_pause(stats) if stats.game_active: # Update the ship position ship.update() # update the ship bullets gf.update_bullets(ai_settings, stats, sb, screen, ship, aliens, bullets, bricks_1, bricks_2, bricks_3) # update the aliens position gf.update_aliens(ai_settings, stats, sb, screen, ship, aliens, bullets, bombs, bricks_1, bricks_2, bricks_3) gf.update_bombs(ai_settings, stats, sb, screen, ship, aliens, bullets, bombs, bricks_1, bricks_2, bricks_3) # Redraw the screen during each pass through the loop and, # make the most recently drawn screen visible. gf.update_screen(ai_settings, stats, sb, screen, ship, aliens, bullets, bombs, bricks_1, bricks_2, bricks_3, play_button, pause_button, instructions)
def __init__(self, port): self.port = port self.reg = ControlTable() self.instructions = Instructions()
class BasicInstructions: def __init__(self, port): self.port = port self.reg = ControlTable() self.instructions = Instructions() # EEPROM Area Instructions def get_model_number(self, device): return self.read_register(device, self.reg.MODEL_NUMBER_L) def get_firmware_version(self, device): return self.read_register(device, self.reg.FIRMWARE_VERSION) def get_id(self, device): return self.read_register(device, self.reg.ID) def set_id(self, device, value): return self.write_register(device, self.reg.ID, value) def get_baudrate(self, device): return self.read_register(device, self.reg.BAUD_RATE) def set_baudrate(self, device, value): return self.write_register(device, self.reg.BAUD_RATE, value) def get_return_delay(self, device): return self.read_register(device, self.reg.RETURN_DELAY) def set_return_delay(self, device, value): return self.write_register(device, self.reg.RETURN_DELAY, value) def get_cw_angle_limit(self, device): return self.read_register(device, self.reg.CW_ANGLE_LIMIT_L) def set_cw_angle_limit(self, device, value): return self.write_register(device, self.reg.CW_ANGLE_LIMIT_L, value) def get_ccw_angle_limit(self, device): return self.read_register(device, self.reg.CCW_ANGLE_LIMIT_L) def set_ccw_angle_limit(self, device, value): return self.write_register(device, self.reg.CCW_ANGLE_LIMIT_L, value) def get_highest_limit_temperature(self, device): return self.read_register(device, self.reg.HIGHEST_LIMIT_TEMPERATURE) def set_highest_limit_temperature(self, device, value): return self.write_register(device, self.reg.HIGHEST_LIMIT_TEMPERATURE, value) def get_lowest_limit_voltage(self, device): return self.read_register(device, self.reg.LOWEST_LIMIT_VOLTAGE) def set_lowest_limit_voltage(self, device, value): return self.write_register(device, self.reg.LOWEST_LIMIT_VOLTAGE, value) def get_highest_limit_voltage(self, device): return self.read_register(device, self.reg.HIGHEST_LIMIT_VOLTAGE) def set_highest_limit_voltage(self, device, value): return self.write_register(device, self.reg.HIGHEST_LIMIT_VOLTAGE, value) def get_max_torque(self, device): return self.read_register(device, self.reg.MAX_TORQUE_L) def set_max_torque(self, device, value): return self.write_register(device, self.reg.MAX_TORQUE_L, value) def get_status_return_level(self, device): return self.read_register(device, self.reg.STATUS_RETURN_LEVEL) def set_status_return_level(self, device, value): return self.write_register(device, self.reg.STATUS_RETURN_LEVEL, value) def get_alarm_led(self, device): return self.read_register(device, self.reg.ALARM_LED) def set_alarm_led(self, device, value): return self.write_register(device, self.reg.ALARM_LED, value) def get_alarm_shutdown(self, device): return self.read_register(device, self.reg.ALARM_SHUTDOWN) def set_alarm_shutdown(self, device, value): return self.write_register(device, self.reg.ALARM_SHUTDOWN, value) def get_down_calibration(self, device): return self.read_register(device, self.reg.DOWN_CALIBRATION_L) def get_up_calibration(self, device): return self.read_register(device, self.reg.UP_CALIBRATION_L) # RAM Area Instruction def get_torque(self, device): return self.read_register(device, self.reg.TORQUE_ENABLE) def set_torque(self, device, enabled): return self.set_boolean(device, self.reg.TORQUE_ENABLE.address, enabled) def get_led(self, device): return self.read_register(device, self.reg.LED) def set_led(self, device, enabled): return self.set_boolean(device, self.reg.LED.address, enabled) def get_cw_compliance_margin(self, device): return self.read_register(device, self.reg.CW_COMPLIANCE_MARGIN) def set_cw_compliance_margin(self, device, value): return self.write_register(device, self.reg.CW_COMPLIANCE_MARGIN, value) def get_ccw_compliance_margin(self, device): return self.read_register(device, self.reg.CCW_COMPLIANCE_MARGIN) def set_ccw_compliance_margin(self, device, value): return self.write_register(device, self.reg.CCW_COMPLIANCE_MARGIN, value) def get_cw_compliance_slope(self, device): return self.read_register(device, self.reg.CW_COMPLIANCE_SLOPE) def set_cw_compliance_slope(self, device, value): return self.write_register(device, self.reg.CW_COMPLIANCE_SLOPE, value) def get_ccw_compliance_slope(self, device): return self.read_register(device, self.reg.CCW_COMPLIANCE_SLOPE) def set_ccw_compliance_slope(self, device, value): return self.write_register(device, self.reg.CCW_COMPLIANCE_SLOPE, value) def get_goal_position(self, device): return self.read_register(device, self.reg.GOAL_POSITION_L) def set_goal_position(self, device, value): return self.write_register(device, self.reg.GOAL_POSITION_L, value) def get_speed(self, device): return self.read_register(device, self.reg.MOVING_SPEED_L) def set_speed(self, device, value): return self.write_register(device, self.reg.MOVING_SPEED_L, value) def get_torque_limit(self, device): return self.read_register(device, self.reg.TORQUE_LIMIT_L) def set_torque_limit(self, device, value): return self.write_register(device, self.reg.TORQUE_LIMIT_L, value) def get_present_position(self, device): return self.read_register(device, self.reg.PRESENT_POSITION_L) def get_present_speed(self, device): return self.read_register(device, self.reg.PRESENT_SPEED_L) def get_present_load(self, device): return self.read_register(device, self.reg.PRESENT_LOAD_L) def get_present_voltage(self, device): return self.read_register(device, self.reg.PRESENT_VOLTAGE) def get_present_temperature(self, device): return self.read_register(device, self.reg.PRESENT_TEMPERATURE) def get_registered_instruction(self, device): return self.read_register(device, self.reg.REGISTERED_INSTRUCTION) def set_registered_instruction(self, device, value): return self.write_register(device, self.reg.REGISTERED_INSTRUCTION, value) def get_moving(self, device): return self.read_register(device, self.reg.MOVING) def get_lock(self, device): return self.read_register(device, self.reg.LOCK) def set_lock(self, device, value): return self.write_register(device, self.reg.LOCK, value) def get_punch(self, device): return self.read_register(device, self.reg.PUNCH_L) def set_punch(self, device, value): return self.write_register(device, self.reg.PUNCH_L, value) # helpers def read_register(self, device, register): """ :type device: int the motor device number (ID) :type register: register object containing address, and size """ self.port.write(self.instructions.read_data(device, register.address, register.size)) return self.port.read() def write_register(self, device, register, value): if register.mode == 'rw': if register.size == 2: [l, h] = self.dec2hex_lh(value) self.port.write(self.instructions.write_data_batch(device, register.address, [l, h])) return self.port.read() elif register.size == 1: self.port.write(self.instructions.write_data(device, register.address, value)) return self.port.read() else: return False else: return False def set_boolean(self, device, register, enabled): if enabled: package = self.write_register(device, register, 1) else: package = self.write_register(device, register, 0) return package @staticmethod def dec2hex_lh(value): lh = "{0:0{1}X}".format(value, 4) return [int(lh[2:4], 16), int(lh[0:2], 16)] # batch sequences def set_position_speed(self, device, position, speed): [position_l, position_h] = self.dec2hex_lh(position) [speed_l, speed_h] = self.dec2hex_lh(speed) self.port.write(self.instructions.write_data_batch(device, self.reg.GOAL_POSITION_L.address, [position_l, position_h, speed_l, speed_h])) return self.port.read()