class Shiny:
"""main class for shiny UI"""
def __init__(self, screen, fonts=None, colors=None):
self.screen = screen
if fonts is None:
self.fonts = Fonts()
else:
self.fonts = fonts
if colors is None:
self.colors = Colors()
else:
self.colors = colors
def _handle_event(self, ev, event_type):
pos = ev.pos
mpos = self.screen.grid.map_pos_inv(pos)
if mpos is not None:
sev = Event(event_type, mpos)
return self.screen.handle_event(sev)
else:
return False
def run(self, framerate=60):
pygame.init()
self.main_surface = pygame.display.set_mode(self.screen.size)
self.fonts.setup()
self.screen.setup(self)
clock = pygame.time.Clock()
done = False
dirty = False
init = True
while not done:
# handle events
for ev in pygame.event.get():
if ev.type == pygame.QUIT:
done = True
elif ev.type == pygame.KEYDOWN and ev.key == pygame.K_ESCAPE:
done = True
elif ev.type == pygame.MOUSEBUTTONDOWN:
dirty = self._handle_event(ev, Event.BUTTON_DOWN)
elif ev.type == pygame.MOUSEBUTTONUP:
dirty = self._handle_event(ev, Event.BUTTON_UP)
elif ev.type == pygame.MOUSEMOTION:
dirty = self._handle_event(ev, Event.MOUSE_MOVE)
if dirty or init:
self.screen.draw()
pygame.display.flip()
dirty = False
init = False
clock.tick(framerate)
class Shiny:
"""main class for shiny UI"""
def __init__(self, screen, fonts=None, colors=None):
self.screen = screen
if fonts is None:
self.fonts = Fonts()
else:
self.fonts = fonts
if colors is None:
self.colors = Colors()
else:
self.colors = colors
def _handle_event(self, ev, event_type):
pos = ev.pos
mpos = self.screen.grid.map_pos_inv(pos)
if mpos is not None:
sev = Event(event_type, mpos)
return self.screen.handle_event(sev)
else:
return False
def run(self, framerate=60):
pygame.init()
self.main_surface = pygame.display.set_mode(self.screen.size)
self.fonts.setup()
self.screen.setup(self)
clock = pygame.time.Clock()
done = False
dirty = False
init = True
while not done:
# handle events
for ev in pygame.event.get():
if ev.type == pygame.QUIT:
done = True
elif ev.type == pygame.KEYDOWN and ev.key == pygame.K_ESCAPE:
done = True
elif ev.type == pygame.MOUSEBUTTONDOWN:
dirty = self._handle_event(ev, Event.BUTTON_DOWN)
elif ev.type == pygame.MOUSEBUTTONUP:
dirty = self._handle_event(ev, Event.BUTTON_UP)
elif ev.type == pygame.MOUSEMOTION:
dirty = self._handle_event(ev, Event.MOUSE_MOVE)
if dirty or init:
self.screen.draw()
pygame.display.flip()
dirty = False
init = False
clock.tick(framerate)
def __init__(self, screen, fonts=None, colors=None):
self.screen = screen
if fonts is None:
self.fonts = Fonts()
else:
self.fonts = fonts
if colors is None:
self.colors = Colors()
else:
self.colors = colors
def __init__(self, master, max_lines, *args, **kwargs):
'''Override of ttk.Frame's initialization function'''
# Initialize root frame
ttk.Frame.__init__(self, master, *args, **kwargs)
self.columnconfigure(0, weight=1) # Entry widget
self.columnconfigure(1, weight=0) # AutoScrollbar
self.rowconfigure(0, weight=1)
self.MAX_LINES = max_lines # Max number of lines entry will resize to
# Initialize multiline entry widget
self.entry = me.MultilineEntry(self,
self.MAX_LINES,
font=Fonts.get('EntryText'),
relief=tk.FLAT,
wrap='word',
highlightbackground="light grey",
highlightthickness=2,
height=1)
self.entry.grid(column=0, row=0, sticky=tk.EW)
# Initialize scrollbar
self.vsb = asb.AutoScrollbar(self, 1, 0, orient=tk.VERTICAL)
self.entry.configure(yscrollcommand=self.vsb.set)
self.bind('<Configure>', self.entry.on_configure)
self.entry.bind('<Return>', self.__on_enter)
self.entry.bind('<Shift-Return>', self.__on_newline)
def write_to_print_excel(bills: List[Bill]):
to_print_workbook = xlsxwriter.Workbook(output_path + "zum_drucken.xlsx")
fonts = Fonts(to_print_workbook)
bill_writer = BillWriter(fonts)
for bill in bills:
worksheet = to_print_workbook.add_worksheet()
bill_writer.write_bill(worksheet, bill)
to_print_workbook.close()
def main():
start = time.time()
board = Grid(Meta.board_height, Meta.board_width)
fonts = Fonts(Meta.board_height)
key = None
run = True
mistakes = 0
while run:
clock.tick(FPS)
play_time = time.time() - start
for event in pygame.event.get():
if event.type == pygame.QUIT:
run = False
# If the mouse was clicked somewhere on board
if event.type == pygame.MOUSEBUTTONDOWN:
pos = pygame.mouse.get_pos()
board.click(pos)
# A key was pressed
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_1:
key = 1
elif event.key == pygame.K_2:
key = 2
elif event.key == pygame.K_3:
key = 3
elif event.key == pygame.K_4:
key = 4
elif event.key == pygame.K_5:
key = 5
elif event.key == pygame.K_6:
key = 6
elif event.key == pygame.K_7:
key = 7
elif event.key == pygame.K_8:
key = 8
elif event.key == pygame.K_9:
key = 9
else:
key = None
board.place(key)
if board.isFinished():
print("Game Over")
run = False
# Delete the incorrect selected entry
if event.key == pygame.K_DELETE:
board.delete()
# Visualize Backtracking algorithm
if event.key == pygame.K_SPACE:
visualize(board, win, fonts, play_time, clock)
run = False
board.draw(win, fonts, play_time)
def write_individual_bill_excels(bills: List[Bill], title_additive: str):
for bill in bills:
excel_title = bill.get_bill_nbr_string() + " Eier " + bill.customer_nickname + " " + title_additive + ".xlsx"
workbook = xlsxwriter.Workbook(output_path + excel_title)
fonts = Fonts(workbook)
bill_writer = BillWriter(fonts)
worksheet = workbook.add_worksheet()
bill_writer.write_bill(worksheet, bill)
workbook.close()
def draw(self):
self.screen.blit(self.background, (0, 0))
if self.state == "in game":
Fonts.render(self.screen, str(self.score), (0, 0))
self.player.draw()
for plasma in self.player.all_plasma:
plasma.draw()
for monster_ in self.all_monsters:
monster_.move()
if not monster_.is_dead:
monster_.draw_rects()
self.all_monsters.draw(self.screen)
elif self.state == "game over":
width, height = self.screen.get_size()
self.screen.blit(Fonts.game_over, (width//2 - Fonts.game_over.get_width() // 2, height // 2 - Fonts.game_over.get_height() // 2))
self.screen.blit(Fonts.help_screen, (width//2 - Fonts.help_screen.get_width() // 2, height // 2 - Fonts.help_screen.get_height() // 2 + 40))
Fonts.help_screen.set_alpha(next(self.cycle_alpha))
if self.state == "title screen":
self.screen.blit(self.banner, (260, 115))
self.play_button.draw(self.screen)
def __init__(self):
pygame.init()
self.imgs = Images()
self.canvas = Canvas()
self.netw = Network()
self.fonts = Fonts()
self.events = PCEvents()
self.buttons = Buttons()
self.screen = pygame.display.set_mode(SCREEN_SIZE)
class LabArm():
def __init__(self):
pygame.init()
self.imgs = Images()
self.canvas = Canvas()
self.netw = Network()
self.fonts = Fonts()
self.events = PCEvents()
self.buttons = Buttons()
self.screen = pygame.display.set_mode(SCREEN_SIZE)
def run(self):
while True:
self.events.handle(self.screen, self.netw)
self.canvas.draw(self.screen)
self.buttons.draw(self.screen)
self.fonts.draw(self.screen)
self.netw.draw(self.screen)
pygame.display.flip()
def __init__(self, screen, fonts=None, colors=None):
self.screen = screen
if fonts is None:
self.fonts = Fonts()
else:
self.fonts = fonts
if colors is None:
self.colors = Colors()
else:
self.colors = colors
def __init__(self, master, timestamp_lbl, *args, **kwargs):
ttk.Frame.__init__(self, master, *args, **kwargs)
self.author_guid = b''
self.author_name = ''
self.is_host = False
self.visible = False
self.wtype = WidgetType.WTYPE_ROOT_CONTAINER
self.depth = 0
# Initialize root grid
self.columnconfigure(0, weight=1)
self.rowconfigure(0, weight=0)
self.rowconfigure(1, weight=0)
# Main message area
# NOTE Default height to 1 so that it does not attempt to fill up
# available space causing screen flicker and grid calculation lag
self.text = ResizableText(self,
font=Fonts.get('MessageText'),
relief=tk.FLAT,
wrap=tk.WORD,
highlightbackground="light grey",
highlightthickness=2,
height=1)
self.text.wtype = WidgetType.WTYPE_LEAF
self.text.depth = self.text.master.depth + 1
# Frame containing author, timestamp, etc...
self.metadata_frame = ttk.Frame(self)
self.metadata_frame.wtype = WidgetType.WTYPE_LEAF
self.metadata_frame.depth = self.metadata_frame.master.depth + 1
self.metadata_frame.grid(column=0, row=0, sticky=tk.EW)
# Author ID
self.author_lbl = ttk.Label(self.metadata_frame)
self.author_lbl.wtype = WidgetType.WTYPE_LEAF
self.author_lbl.depth = self.author_lbl.master.depth + 1
# Timestamp
self.timestamp_lbl = ttk.Label(self.metadata_frame,
text=timestamp_lbl,
style='MsgTimestamp.TLabel')
self.timestamp_lbl.wtype = WidgetType.WTYPE_LEAF
self.timestamp_lbl.depth = self.timestamp_lbl.master.depth + 1
def runGame():
"""Runs the game, duh!"""
#initialize window and such
settings = Settings()
game.init()
game.font.init()
screen = game.display.set_mode(
(settings.screenWidth, settings.screenHeight))
game.display.set_caption(settings.title)
character = boy(screen)
game.display.set_icon(character.image)
font = Fonts(character)
total = 2
#create a path
pathList = []
for i in range(0, 20):
path = Tile('OverworldPath.png',
screen.get_rect().centerx,
screen.get_rect().bottom - (i * 32), screen, 0)
pathList.append(path)
#create a wall
wallList = []
for i in range(0, 8):
for j in range(0, 8, 2):
wall = Tile('OverworldWall.png',
(screen.get_rect().centerx * 1.5) + (i * 32),
(screen.get_rect().centery * 1.5) + (j * 32), screen,
1)
wallList.append(wall)
for i in range(0, 15):
wall = Tile('OverworldWall.png', 240, 0 + (32 * i), screen, 1)
wallList.append(wall)
for i in range(0, 4):
wall = Tile('OverworldWall.png', 272 + (32 * i), 96 + (32 * i), screen,
1)
wallList.append(wall)
#generate some rocks
rockList = []
for i in range(0, total):
randX = randint(0, 1200 - 32)
randY = randint(0, 800 - 32)
rock = Tile('OverworldRock.png', randX, randY, screen, 1)
rockList.append(rock)
usedMinerals = []
mineral = -1
bossPresent = False
bossCounter = 0
#main loop for game
while True:
if len(usedMinerals) % total == 0 and bossPresent == False and len(
usedMinerals) != 0:
boss1 = Tile('BossRock.png', 583, 120, screen, 1)
bossPresent = True
bossCounter += 1
while len(rockList) > 0:
rockList.pop()
rockList.append(boss1)
if character.stage == "OVERWORLD":
character.walkAnimate()
character.checkCollision(wallList)
if character.checkCollision(rockList) == True:
while True:
mineral = randint(1, 10)
if mineral not in usedMinerals:
break
if bossPresent == True:
enemy = Rock(11 * bossCounter, screen)
else:
enemy = Rock(mineral, screen)
character.stage = "BATTLE"
character.setBattleImage("Battle.png")
character.updatePos()
if character.stage == "BATTLE":
gf.checkEvents(character, font, enemy, rockList, mineral,
usedMinerals, bossPresent)
gf.updateScreen(settings, screen, character, pathList, wallList,
rockList, font, enemy)
else:
gf.checkEvents(character, font)
gf.updateScreen(settings, screen, character, pathList, wallList,
rockList, font)
def main():
path = os.path.dirname(sys.argv[0])
imagesFolderPath = path + "/" + imagesFolder
animationFolderPath = path + "/" + animationFolder
fontFullPath = path + "/" + fontPath
parser = argparse.ArgumentParser(description='Process some integers.')
parser.add_argument('--show', default=False, type=bool, help='Show animation')
parser.add_argument('--update', default=False, type=bool, help='Re-create structures from existing images (default: False). True if images should be re-created')
parser.add_argument('--delay', default=1000, type=int, help='Set delay in ms between animation frames - image, text, and effect (dafault: 1000)')
parser.add_argument('--colour', default=[255, 255, 255], type=int, nargs=3, help='Set font colour in RGB format - 3 values between 0 and 255 (default: 255 255 255)')
parser.add_argument('--parameters', default=[255, 255, 255], type=int, nargs='*', help='Set parameters for effect. For snakes use colour in RGB format. For rainbow use colour increment speed(integer) and number of frames')
parser.add_argument('--font_size', default='large', help='Enter size of the font: small or large and effect: static or scroll')
parser.add_argument('--font_effect', default='static', help='Enter effect for font: static or scroll')
parser.add_argument('--image', help='Enter image name to get animation. Required option is delay')
parser.add_argument('--text', help='Enter text to get animation. Required options are: colour, font and delay')
parser.add_argument('--effect', help='Enter effect name to get animation. Required options are: parameters and delay')
parser.add_argument('--images', help='Get list of all available image names to be used in image option')
parser.add_argument('--effects', help='Get list of all available effect names to be used in effect option')
parser.add_argument('--test', help='Get test matrix (only one frame)')
# parser.print_help()
args = parser.parse_args()
args.colour = (args.colour[0], args.colour[1], args.colour[2])
if args.update == True:
# http://www.iconarchive.com/show/arcade-saturdays-icons-by-mad-science/Bashfull-Inky-icon.html
# http://www.iconarchive.com/show/square-animal-icons-by-martin-berube.html
for filename in os.listdir(imagesFolderPath):
pixels = Pixels(imagesFolderPath, filename)
pixels.save(resolution, animationFolderPath)
if args.images != None:
images = []
for filename in os.listdir(animationFolderPath):
file, ext = os.path.splitext(filename)
name = file.split("_")[0]
if name not in images:
images.append(name)
print(images)
exit(0)
if args.effects != None:
effects = Effects()
print(effects.list())
exit(0)
if args.image != None:
animationObject = Animation(animationFolderPath, args.image)
animation = animationObject.get(args.delay)
animationJson = json.dumps(animation)
print(animationJson)
if args.show == True:
animationObject.show(animation, resolution)
exit(0)
if args.text != None:
fonts = Fonts(fontFullPath, args.font_size, args.font_effect, resolution)
letterImages = fonts.getText(args.text, args.colour)
animationObject = Animation(letterImages)
animation = animationObject.get(args.delay)
animationJson = json.dumps(animation)
print(animationJson)
if args.show == True:
animationObject.show(animation, resolution)
exit(0)
if args.effect != None:
effects = Effects(args.effect, resolution)
pixelsArray = effects.get(args.parameters)
animationObject = Animation(pixelsArray)
animation = animationObject.get(args.delay)
animationJson = json.dumps(animation)
print(animationJson)
if args.show == True:
animationObject.show(animation, resolution)
exit(0)
if args.test != None:
test = Test(resolution)
pixelsArray = test.get()
animationObject = Animation(pixelsArray)
animation = animationObject.get(args.delay)
animationJson = json.dumps(animation)
print(animationJson)
if args.show == True:
animationObject.show(animation, resolution)
exit(0)
def __init__(self):
super().__init__()
self.iterations = 10000
self.ro = 0.5
self.alpha = 0.5
self.fonts = Fonts(3)
fonts_used = self.fonts.fonts
self.fonts.load()
self.network = Network(neurons=(35, 25, len(Constants.symbols)),
input_size=21 * 14)
self.formula = Formula()
self.file_path = ""
self.network_ready = False
self.setWindowTitle("MathReader")
self.setWindowIcon(QIcon('res/icon.png'))
grid = QGridLayout()
self.setFixedSize(730, 500)
label_math_reader = QLabel("MathReader")
label_math_reader.setFont(QFont("Ink Free", 20, QFont.Bold))
label_math_reader.setMaximumHeight(50)
label_math_reader.setAlignment(Qt.AlignCenter)
self.btn_save_weights = QPushButton("Save weights")
self.btn_save_weights.clicked.connect(self.save_weights)
self.btn_load_weights = QPushButton("Load weights")
self.btn_load_weights.clicked.connect(self.load_weights)
self.btn_train = QPushButton("Train")
self.btn_train.clicked.connect(self.open_training_dialog)
self.btn_browse = QPushButton("Browse")
self.btn_browse.clicked.connect(self.open_file)
self.btn_solve = QPushButton("Solve!")
self.btn_solve.setEnabled(False)
self.btn_solve.clicked.connect(self.solve_formula)
label_file = QLabel("Chosen image directory: ")
label_open_image = QLabel(
"Use the 'Browse' button to select graphic file, you would like me to read from :)"
)
label_open_image.setAlignment(Qt.AlignCenter)
self.label_image = QLabel("Your graphic file will load here!")
self.label_image.setStyleSheet("background-color: white")
self.label_image.setAlignment(Qt.AlignCenter)
self.browsed_file = QLineEdit()
self.browsed_file.setReadOnly(True)
self.browsed_file.setMaximumWidth(300)
self.solved_formula = QLineEdit()
self.solved_formula.setReadOnly(True)
self.solved_formula.setFont(QFont("Bahnschrift", 12))
self.solved_formula.setAlignment(Qt.AlignCenter)
label_solved = QLabel("I think it is...")
label_solved.setMaximumHeight(20)
label_solved.setAlignment(Qt.AlignBottom)
self.loading = QProgressBar()
label_loading = QLabel("Training state: ")
self.separator_h = QFrame()
self.separator_h.setFrameShape(QFrame.HLine)
self.separator_h.setFrameShadow(QFrame.Sunken)
separator_v = QFrame()
separator_v.setFrameShape(QFrame.VLine)
separator_v.setFrameShadow(QFrame.Sunken)
start_state = "Loaded " + str(fonts_used) + " fonts"
start_state += ("\nInitializing network with layers of sizes " +
str(self.network.neurons))
self.label_state = QLabel(start_state)
self.label_state.setStyleSheet("background-color: white")
self.label_state.setAlignment(Qt.AlignCenter)
self.training_dialog = QDialog()
self.training_params = QLabel(
"Here you can specify training parameters: ")
self.choose_iterations_label = QLabel("Iterations number: ")
self.choose_alpha_label = QLabel("\u03B1 value: ")
self.choose_rho_label = QLabel("\u03C1 value: ")
self.choose_iterations_input = QLineEdit()
self.choose_iterations_input.setText("10000")
self.choose_alpha_input = QLineEdit()
self.choose_alpha_input.setText("0.5")
self.choose_rho_input = QLineEdit()
self.choose_rho_input.setText("0.5")
self.btn_apply = QPushButton("Apply")
self.btn_apply.setMaximumWidth(80)
grid.addWidget(label_math_reader, 0, 0, 1, 1)
grid.addWidget(self.btn_train, 1, 0)
grid.addWidget(self.btn_save_weights, 2, 0)
grid.addWidget(self.btn_load_weights, 3, 0)
grid.addWidget(self.btn_solve, 5, 0)
grid.addWidget(separator_v, 0, 1, 10, 1)
grid.addWidget(label_open_image, 0, 2, 1, 3)
grid.addWidget(label_file, 1, 2, 1, 1)
grid.addWidget(self.browsed_file, 1, 3, 1, 1)
grid.addWidget(self.btn_browse, 1, 4, 1, 1)
grid.addWidget(self.label_image, 2, 2, 7, 3)
grid.addWidget(label_loading, 9, 2, Qt.AlignCenter)
grid.addWidget(self.loading, 9, 3, 1, 2)
grid.addWidget(label_solved, 10, 0, 1, 1)
grid.addWidget(self.solved_formula, 11, 0, 1, 5)
grid.addWidget(self.label_state, 12, 0, 1, 5)
grid.setSpacing(10)
self.setLayout(grid)
self.training_dialog.setModal(True)
self.training_dialog.setWindowTitle("Training Dialog")
self.training_dialog.setWindowIcon(QIcon('res/icon.png'))
grid = QGridLayout()
self.btn_apply.clicked.connect(self.get_training_params)
self.training_dialog.setFixedSize(230, 150)
grid.addWidget(self.training_params, 0, 0, 1, 2)
grid.addWidget(self.separator_h, 1, 0, 1, 2)
grid.addWidget(self.choose_iterations_label, 2, 0)
grid.addWidget(self.choose_iterations_input, 2, 1)
grid.addWidget(self.choose_alpha_label, 3, 0)
grid.addWidget(self.choose_alpha_input, 3, 1)
grid.addWidget(self.choose_rho_label, 4, 0)
grid.addWidget(self.choose_rho_input, 4, 1)
grid.addWidget(self.btn_apply, 5, 0, 1, 2, Qt.AlignCenter)
self.training_dialog.setLayout(grid)
class MathReader(QWidget):
def __init__(self):
super().__init__()
self.iterations = 10000
self.ro = 0.5
self.alpha = 0.5
self.fonts = Fonts(3)
fonts_used = self.fonts.fonts
self.fonts.load()
self.network = Network(neurons=(35, 25, len(Constants.symbols)),
input_size=21 * 14)
self.formula = Formula()
self.file_path = ""
self.network_ready = False
self.setWindowTitle("MathReader")
self.setWindowIcon(QIcon('res/icon.png'))
grid = QGridLayout()
self.setFixedSize(730, 500)
label_math_reader = QLabel("MathReader")
label_math_reader.setFont(QFont("Ink Free", 20, QFont.Bold))
label_math_reader.setMaximumHeight(50)
label_math_reader.setAlignment(Qt.AlignCenter)
self.btn_save_weights = QPushButton("Save weights")
self.btn_save_weights.clicked.connect(self.save_weights)
self.btn_load_weights = QPushButton("Load weights")
self.btn_load_weights.clicked.connect(self.load_weights)
self.btn_train = QPushButton("Train")
self.btn_train.clicked.connect(self.open_training_dialog)
self.btn_browse = QPushButton("Browse")
self.btn_browse.clicked.connect(self.open_file)
self.btn_solve = QPushButton("Solve!")
self.btn_solve.setEnabled(False)
self.btn_solve.clicked.connect(self.solve_formula)
label_file = QLabel("Chosen image directory: ")
label_open_image = QLabel(
"Use the 'Browse' button to select graphic file, you would like me to read from :)"
)
label_open_image.setAlignment(Qt.AlignCenter)
self.label_image = QLabel("Your graphic file will load here!")
self.label_image.setStyleSheet("background-color: white")
self.label_image.setAlignment(Qt.AlignCenter)
self.browsed_file = QLineEdit()
self.browsed_file.setReadOnly(True)
self.browsed_file.setMaximumWidth(300)
self.solved_formula = QLineEdit()
self.solved_formula.setReadOnly(True)
self.solved_formula.setFont(QFont("Bahnschrift", 12))
self.solved_formula.setAlignment(Qt.AlignCenter)
label_solved = QLabel("I think it is...")
label_solved.setMaximumHeight(20)
label_solved.setAlignment(Qt.AlignBottom)
self.loading = QProgressBar()
label_loading = QLabel("Training state: ")
self.separator_h = QFrame()
self.separator_h.setFrameShape(QFrame.HLine)
self.separator_h.setFrameShadow(QFrame.Sunken)
separator_v = QFrame()
separator_v.setFrameShape(QFrame.VLine)
separator_v.setFrameShadow(QFrame.Sunken)
start_state = "Loaded " + str(fonts_used) + " fonts"
start_state += ("\nInitializing network with layers of sizes " +
str(self.network.neurons))
self.label_state = QLabel(start_state)
self.label_state.setStyleSheet("background-color: white")
self.label_state.setAlignment(Qt.AlignCenter)
self.training_dialog = QDialog()
self.training_params = QLabel(
"Here you can specify training parameters: ")
self.choose_iterations_label = QLabel("Iterations number: ")
self.choose_alpha_label = QLabel("\u03B1 value: ")
self.choose_rho_label = QLabel("\u03C1 value: ")
self.choose_iterations_input = QLineEdit()
self.choose_iterations_input.setText("10000")
self.choose_alpha_input = QLineEdit()
self.choose_alpha_input.setText("0.5")
self.choose_rho_input = QLineEdit()
self.choose_rho_input.setText("0.5")
self.btn_apply = QPushButton("Apply")
self.btn_apply.setMaximumWidth(80)
grid.addWidget(label_math_reader, 0, 0, 1, 1)
grid.addWidget(self.btn_train, 1, 0)
grid.addWidget(self.btn_save_weights, 2, 0)
grid.addWidget(self.btn_load_weights, 3, 0)
grid.addWidget(self.btn_solve, 5, 0)
grid.addWidget(separator_v, 0, 1, 10, 1)
grid.addWidget(label_open_image, 0, 2, 1, 3)
grid.addWidget(label_file, 1, 2, 1, 1)
grid.addWidget(self.browsed_file, 1, 3, 1, 1)
grid.addWidget(self.btn_browse, 1, 4, 1, 1)
grid.addWidget(self.label_image, 2, 2, 7, 3)
grid.addWidget(label_loading, 9, 2, Qt.AlignCenter)
grid.addWidget(self.loading, 9, 3, 1, 2)
grid.addWidget(label_solved, 10, 0, 1, 1)
grid.addWidget(self.solved_formula, 11, 0, 1, 5)
grid.addWidget(self.label_state, 12, 0, 1, 5)
grid.setSpacing(10)
self.setLayout(grid)
self.training_dialog.setModal(True)
self.training_dialog.setWindowTitle("Training Dialog")
self.training_dialog.setWindowIcon(QIcon('res/icon.png'))
grid = QGridLayout()
self.btn_apply.clicked.connect(self.get_training_params)
self.training_dialog.setFixedSize(230, 150)
grid.addWidget(self.training_params, 0, 0, 1, 2)
grid.addWidget(self.separator_h, 1, 0, 1, 2)
grid.addWidget(self.choose_iterations_label, 2, 0)
grid.addWidget(self.choose_iterations_input, 2, 1)
grid.addWidget(self.choose_alpha_label, 3, 0)
grid.addWidget(self.choose_alpha_input, 3, 1)
grid.addWidget(self.choose_rho_label, 4, 0)
grid.addWidget(self.choose_rho_input, 4, 1)
grid.addWidget(self.btn_apply, 5, 0, 1, 2, Qt.AlignCenter)
self.training_dialog.setLayout(grid)
def open_file(self) -> None:
"""
Opens a file dialog used to load image with a mathematical expression
"""
file_name, _ = QFileDialog.getOpenFileName(self, 'Open file')
self.browsed_file.setText(file_name)
self.file_path = file_name
self.w = min(530, QPixmap(file_name).width())
self.h = min(270, QPixmap(file_name).height())
self.label_image.setPixmap(
QPixmap(file_name).scaled(self.w, self.h, Qt.KeepAspectRatio))
self.label_state.setText("Loaded formula from file " + file_name)
self.btn_solve.setEnabled(True)
def save_weights(self) -> None:
"""
Opens a file dialog used to save network parameters to a .csv file
"""
file_name, _ = QFileDialog.getSaveFileName(self,
'Save file',
filter="csv(*.csv)")
if file_name != '':
file = open(file_name, 'w')
with open(file_name):
self.network.save(file_name)
file.close()
self.label_state.setText("Saving weights to file " + file_name)
def load_weights(self) -> None:
"""
Opens a file dialog used to load network parameters from a .csv file
"""
file_name, _ = QFileDialog.getOpenFileName(self,
'Open file',
filter="csv(*.csv)")
if file_name != '':
self.network.load(file_name)
self.label_state.setText("Loaded weights from file " + file_name)
self.network_ready = True
def solve_formula(self) -> None:
"""
Solves the formula recognized in the image by the neural network
"""
if self.network_ready:
self.label_state.setText(
"Evaluating formula using neural network.")
self.formula.load(self.file_path)
self.solved_formula.setText(self.formula.evaluate(self.network))
self.label_image.setPixmap(
QPixmap("data/_output.png").scaled(self.w, self.h,
Qt.KeepAspectRatio))
else:
self.label_state.setText(
"Please train network or load weights first.")
def open_training_dialog(self) -> None:
"""
Opens the dialog before training in which the user sets the number of iterations and additional parameters.
"""
self.training_dialog.exec()
def get_training_params(self) -> None:
"""
Retrieves the training parameters from closed dialog and starts training with
"""
self.iterations = int(self.choose_iterations_input.text())
self.ro = float(self.choose_rho_input.text())
self.alpha = float(self.choose_alpha_input.text())
self.training_dialog.close()
t = threading.Thread(target=self.network.fit,
args=(self.iterations, self.fonts.data,
self.fonts.labels, self.ro, self.alpha,
self.set_progress_bar))
t.start()
self.label_state.setText("Training network for " +
str(self.iterations) + " iterations and " +
str(len(self.fonts.data)) + " samples.")
self.network_ready = True
def set_progress_bar(self, progress) -> None:
"""
Updates the training progress bar with data from neural network
@param progress: Integer in range from 0 to 100 representing training progress in percentage
"""
self.loading.setValue(round(float(progress)))
value = self.loading.value()
if value < 100:
self.btn_train.setEnabled(False)
self.btn_load_weights.setEnabled(False)
self.btn_save_weights.setEnabled(False)
self.btn_browse.setEnabled(False)
else:
self.label_state.setText("Network successfully trained.")
self.btn_train.setEnabled(True)
self.btn_load_weights.setEnabled(True)
self.btn_save_weights.setEnabled(True)
self.btn_browse.setEnabled(True)
import pygame
from TheGame import TheGame
from random import randint
from time import time
from fonts import Fonts
from pygame import mixer
pygame.init()
WIDTH = 800
HEIGHT = 600
font = Fonts(WIDTH, HEIGHT)
pygame.display.set_caption("War In Space 2D")
icon = pygame.image.load("data\\warinspaceicon.png")
pygame.display.set_icon(icon)
mixer.music.load("data\\warinspaceriff.ogg")
mixer.music.play(-1)
screen = pygame.display.set_mode((WIDTH, HEIGHT))
run_game = True
def background_stars(stars_list):
for star in stars_list:
background_stars_list.append([[star[0], star[1]],
[randint(0, 10) - 5,
randint(0, 10) - 5],
randint(1, 2)])
for particle in background_stars_list:
def game_scene(screen, images, profile_id, save_jdat, save_filenm, buildings, upgrades, xupgrades):
lifetime = save_jdat["profiles"][profile_id]["lifetime"]
current = save_jdat["profiles"][profile_id]["current"]
timing = save_jdat["profiles"][profile_id]["timing"]
golden = ex1.GoldenModel(current["golden"])
# Must do startup() to handle background accumulation.
ex1.startup(timing, lifetime, current, buildings, upgrades, xupgrades)
background_widget = BackgroundWidget()
fps_widget = FPSWidget()
hud_widget = HUDWidget()
donut_widget = DonutWidget()
# buildings_widget = TheBuildings(buildings)
buildings_widget = BuildingsWidget(buildings)
upgrades_widget = TheUpgrades(upgrades, buildings, images)
rollover_widget = RolloverWidget()
golden_widget = GoldenWidget()
stats_widget = StatsWidget()
credits_widget = CreditsWidget()
reset_widget = ResetWidget()
golden_widget.update(golden)
credits_button_widget = ButtonWidget(BUTTON_CREDITS_IMAGE)
tmp = credits_button_widget.box
tmp.centerx = SCREEN_WIDTH//2 + 30
tmp.top = 0
credits_button_widget.box = tmp
reset_button_widget = ButtonWidget(BUTTON_RESET_IMAGE)
tmp = reset_button_widget.box
tmp.right = credits_button_widget.box.left - 5
reset_button_widget.box = tmp
stats_button_widget = ButtonWidget(BUTTON_STATS_IMAGE)
tmp = stats_button_widget.box
tmp.right = reset_button_widget.box.left - 5
stats_button_widget.box = tmp
profiles_button_widget = ButtonWidget(BUTTON_PROFILES_IMAGE)
tmp = profiles_button_widget.box
tmp.right = stats_button_widget.box.left - 5
profiles_button_widget.box = tmp
font_set_idx = 0
Fonts.activate_font_set(font_set_idx)
ticks = 0
running = True
clock = pygame.time.Clock()
ms_elapsed = 0.0
do_quit = False
while running:
ticks += 1
if android:
if android.check_pause():
print "@@@@ pausing"
running = False
## Save the game state to a file.
#with open(save_filenm, "w") as fp:
# json.dump(save_jdat, fp, indent=4)
#android.wait_for_resume()
#print "@@@@ resuming"
for event in pygame.event.get():
if event.type == pygame.QUIT:
do_quit = True
running = False
elif event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
do_quit = True
running = False
elif event.type == pygame.KEYDOWN and event.key == pygame.K_1:
stats_widget.showing = True
elif event.type == pygame.KEYDOWN and event.key == pygame.K_2:
golden_widget.golden.data["timer"] = 0.1
elif event.type == pygame.KEYDOWN and event.key == pygame.K_c:
credits_widget.showing = True
elif event.type == pygame.KEYDOWN and event.key == pygame.K_3:
background_widget._load_images()
donut_widget._load_images()
buildings_widget._load_images()
elif event.type == pygame.KEYDOWN and event.key == pygame.K_f:
font_set_idx = (font_set_idx + 1) % len(Fonts.font_sets)
Fonts.activate_font_set(font_set_idx)
elif event.type == pygame.KEYDOWN and event.key == pygame.K_g:
from fmt import fmt as xxfmt
xxfmt.next()
elif event.type == pygame.KEYDOWN and event.key == pygame.K_p:
# Removing this key action will also disable the Android "back" button.
do_quit = False
running = False
elif event.type == pygame.KEYDOWN and event.key == pygame.K_a:
current["cookies"] += 100000000000000000
current["game_cookies"] += 100000000000000000
lifetime["cookies"] += 100000000000000000
elif event.type == pygame.KEYDOWN and event.key == pygame.K_r:
ex1.soft_reset(save_jdat["profiles"], profile_id, buildings, upgrades)
# save_jdat["profiles"]["current"] has been replaced; need to update pointer
current = save_jdat["profiles"][profile_id]["current"]
elif event.type == pygame.MOUSEBUTTONDOWN and event.button == LEFTBUTTON:
# Note that the on_click() methods do their own click detection and
# return True when the click was on the owning object.
if stats_widget.on_click(event.pos):
pass
elif credits_widget.on_click(event.pos):
pass
elif golden_widget.on_click(event.pos):
pass
elif donut_widget.on_click(event.pos):
# FINISH: put a function in ex1 to do this type of thing
current["cookies"] += current["cpc"]
current["game_cookies"] += current["cpc"]
lifetime["cookies"] += current["cpc"]
elif credits_button_widget.on_click(event.pos):
credits_widget.showing = True
elif stats_button_widget.on_click(event.pos):
stats_widget.showing = True
elif profiles_button_widget.on_click(event.pos):
do_quit = False
running = False
elif buildings_widget.on_click(event.pos):
pass
elif upgrades_widget.on_click(event.pos):
pass
elif reset_button_widget.on_click(event.pos):
ex1.soft_reset(save_jdat["profiles"], profile_id, buildings, upgrades)
current = save_jdat["profiles"][profile_id]["current"]
elif event.type == pygame.MOUSEMOTION:
buildings_widget.on_mouseover(event.pos, rollover_widget)
upgrades_widget.on_mouseover(event.pos, rollover_widget)
golden_widget.on_mouseover(event.pos, rollover_widget)
# FINISH: make functions in ex1 which do all this work.
# ex1.update_state(lifetime, current, elapsed)
# ex1.calc_aux(lifetime, current) -> building_status, upgrade_status, golden_status?
elapsed = ms_elapsed/1000.0
ex1.update_state(elapsed, timing, lifetime, current, buildings, upgrades, xupgrades)
golden.update(elapsed)
donut_widget.update(elapsed)
stats_widget.update(lifetime, current, timing)
reset_widget.update(ex1.get_shard_value(save_jdat["profiles"], profile_id))
credits_button_widget.update(elapsed)
reset_button_widget.update(elapsed)
stats_button_widget.update(elapsed)
profiles_button_widget.update(elapsed)
building_costs = ex1.current_costs(current, buildings)
# FINISH: make a HUDWidget.update() method. Rename HUDWidget.
hud_widget.cps = current["cps"]
hud_widget.cpc = current["cpc"]
hud_widget.cookies = current["cookies"]
hud_widget.game_cookies = current["game_cookies"]
buildings_widget.update(current, building_costs)
upgrades_widget.update(current)
golden_widget.update(golden)
if MODE==2:
#screen.fill(THECOLORS["black"])
background_widget.draw(screen)
else:
background_widget.draw(screen)
hud_widget.draw(screen)
buildings_widget.draw(screen)
upgrades_widget.draw(screen)
donut_widget.draw(screen)
rollover_widget.draw(screen)
if DEBUG:
fps_widget.draw(screen)
credits_button_widget.draw(screen)
reset_button_widget.draw(screen)
stats_button_widget.draw(screen)
profiles_button_widget.draw(screen)
golden_widget.draw(screen)
stats_widget.draw(screen)
credits_widget.draw(screen)
reset_widget.draw(screen)
pygame.display.flip()
ms_elapsed = clock.tick(TICK)
fps_widget.update(clock.get_fps())
# timer.update((ms_elapsed/1000.0)*TICK) # FINISH: does flip() returns the elapsed ti
# finish_timer.update((ms_elapsed/1000.0)*TICK) # FINISH: does flip() returns the ela
pygame.event.pump()
# Must do shutdown() to prep for background accumulation.
ex1.shutdown(timing)
# Save the game state to a file.
with open(save_filenm, "w") as fp:
json.dump(save_jdat, fp, indent=4)
return do_quit
def __init__(self, master, in_q, *args, **kwargs):
'''
:param in_q: Queue for data coming from backend to GUI
'''
# Initialize root window
ttk.Frame.__init__(self, master, *args, **kwargs)
master.title(f'Endpoints')
master.configure(background='gray95')
# Configure fonts
Fonts.init()
# Configure Styles
style = ttk.Style()
# MessageFrame styles
style.configure('MsgAuthor.TLabel',
foreground='dark gray',
font=Fonts.get('MessageAuthor'))
style.configure('MsgAuthorHost.TLabel',
foreground='tomato',
font=Fonts.get('MessageAuthor'))
style.configure('MsgTimestamp.TLabel',
foreground='gray',
font=Fonts.get('MessageTimestamp'))
style.configure('EntryArea.TFrame', background='gray95')
style.configure('EmptyArea.TLabel',
foreground='gray',
anchor=tk.CENTER,
font=Fonts.get('EmptyArea'))
style.configure('Sidebar.TFrame', background='white')
style.configure('Listbox.TFrame', background='white')
style.configure('ConnectionWidget.TFrame', background='white')
style.configure('Unselected.ConnectionWidget.TFrame',
background='white')
style.configure('Selected.ConnectionWidget.TFrame',
background='light sky blue')
style.configure('ConnectionWidget.TLabel',
background='white',
anchor=tk.W,
padding=(5, 15))
style.configure('Unselected.ConnectionWidget.TLabel',
background='white')
style.configure('Selected.ConnectionWidget.TLabel',
background='light sky blue')
style.configure('AboutMain.TLabel', font=Fonts.get('AboutMain'))
self.poll_id = None
# Configure root window
master.eval('tk::PlaceWindow %s center' % master.winfo_toplevel())
# master.protocol('WM_DELETE_WINDOW', self.__window_close_callback)
# Initialize root window grid
master.columnconfigure(0, weight=1)
master.rowconfigure(0, weight=1)
master.minsize(width=600, height=300)
# Root frame grid
self.columnconfigure(0, weight=1)
self.rowconfigure(0, weight=1)
# Place root frame
self.grid(column=0, row=0, sticky=tk.NSEW)
# Configure window menu
self.menu = mb.MenuBar(master, master.destroy)
master.configure(menu=self.menu)
# Paned window to hold the conversation area
self.paned_window = ttk.PanedWindow(self, orient=tk.HORIZONTAL)
self.paned_window.grid(column=0, row=0, sticky=tk.NSEW)
# Configure main area
self.convo_mgr = cf.ConversationFrame(self)
# Configure side bar
self.side_panel = sb.SideBar(self,
self.convo_mgr.add_conversation,
self.convo_mgr.activate_conversation,
self.convo_mgr.remove_conversation,
style='Sidebar.TFrame')
# Place sidebar in left pane and conversation area in right pane
self.paned_window.add(self.side_panel)
self.paned_window.add(self.convo_mgr)
# Place window in the center of the screen
self.master.update_idletasks()
w = self.master.winfo_width()
h = self.master.winfo_height()
wscreen = self.winfo_screenwidth()
hscreen = self.winfo_screenheight()
x = (wscreen / 2) - (w / 2)
y = (hscreen / 2) - (h / 2)
self.master.geometry(f'{int(w)}x{int(h)}+{int(x)}+{int(y)}')
# Begin polling of queues
self.__poll(in_q)
