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()
