def main():
args = parse_args()
tile_sprite = TileBuilder(TileSheets(args.tile_sprite))
score_sprite = ScoreBuilder(ScoreSheets(args.score_sprite))
face_sprite = FaceBuilder(FaceSheets(args.face_sprite))
if args.sprite != None:
tile_sprite = TileBuilder(TileSheets(args.sprite))
score_sprite = ScoreBuilder(ScoreSheets(args.sprite))
face_sprite = FaceBuilder(FaceSheets(args.sprite))
if args.difficulty == "basic":
game(
UserInterface(
10,
10,
10,
lambda x: HighScoreUpdate("basic", x),
tile_sprite=tile_sprite,
score_sprite=score_sprite,
face_sprite=face_sprite,
))
elif args.difficulty == "intermediate":
game(
UserInterface(
16,
16,
40,
lambda x: HighScoreUpdate("intermediate", x),
tile_sprite=tile_sprite,
score_sprite=score_sprite,
face_sprite=face_sprite,
))
elif args.difficulty == "expert":
game(
UserInterface(
16,
30,
99,
lambda x: HighScoreUpdate("expert", x),
tile_sprite=tile_sprite,
score_sprite=score_sprite,
face_sprite=face_sprite,
))
else:
game(
UserInterface(
args.rows,
args.cols,
args.mines,
lambda x: HighScoreUpdate(
f"custom {args.rows}x{args.cols}:{args.mines}", x),
tile_sprite=tile_sprite,
score_sprite=score_sprite,
face_sprite=face_sprite,
))
def load_timesheet(self, name, only_data=False):
"""
Loads a timesheet and sets all the parameters of this class to deal with the new timesheet
:param name: name of Timesheet
:return: False if file not found error, True if loaded, or data if asking for data
"""
if name != "":
path = pathjoin(self.path, "{}.pkl".format(name))
if not only_data:
try:
self.data = pickle.load(open(path, "rb"))
self.name = name
self.working_start = None
self.work_day_allocated = 0
self.UI = UserInterface(name, False, self.today, VERSION)
self.init_configs()
print("{} Timesheet loaded.".format(name))
if ".state-{}".format(name) in os.listdir(STATE_PATH):
task, start = self.load_state()
self.start_task_from_state(task, start)
if ".state-{}-workday".format(name) in os.listdir(
STATE_PATH):
self.working_start, self.work_day_allocated = self.load_workday_state(
)
except FileNotFoundError:
return False
else:
try:
return pickle.load(open(path, "rb"))
except FileNotFoundError:
return False
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 __init__(self, player, game_map):
self.user_interface = UserInterface()
self.game_map = game_map
self.move = Move(game_map)
self.merchant = Merchant(game_map, self.move)
self.player = player
self.errors = 0
def __init__(self, task):
self.running = False
self.ui = UserInterface()
self.task = task
self.first_start = time.time()
self.start = time.time()
self.recorded_time = 0
self.paused = False
def main():
print('initializing role based resource access system')
dao = DataAccessObject()
dao.load_data()
authorization = Authorization(dao)
ui = UserInterface(authorization)
ui.start()
def __init__(self, game_map, task=TASKS.MINE):
self.user_interface = UserInterface()
self.backpack = Backpack()
self.mine = Mine(self, game_map)
self.smelt = Smelt(self, game_map)
self.forge = Forge(self, game_map)
# Set the default initial task
self.task = task
self.action_count = 0
def main(file_name):
file_io = FileIO(file_name)
corpus = file_io.read()
tc = TextCleanser()
corpus_words = tc.clean_text(corpus) # Get a list of every words in corpus
text_gen = TextGenerator(corpus_words)
ui = UserInterface(text_gen)
ui.runProgram() # Starts the program
def run_game():
# Initialize pygame, settings, and screen object.
pygame.init()
settings = Settings()
'''
full_screen = pygame.display.set_mode((0, 0), pygame.FULLSCREEN)
screen = pygame.Surface((settings.screen_width, settings.screen_height))
After everything has been blit onto screen use:
full_screen.blit(pygame.transform.scale(screen, (1980, 1080)), (0, 0))
pygame.display.flip()
'''
screen = pygame.display.set_mode(
(settings.screen_width, settings.screen_height))
ui = UserInterface(settings, screen)
pygame.display.set_caption("Super Mario Bros")
# Create our timers
timers = Timers()
# Create a group to hold all enemies
enemies = Group()
# Create our Hero
mario_ = Mario(settings, screen, ui, timers)
# Create a group to hold all objects and background
objects = Group()
background = Group()
items = Group()
# Create first level
curlevel = Level1_1(settings, screen, enemies, objects, background, mario_,
ui, timers)
while True:
timers.curtime = pygame.time.get_ticks()
gf.check_events(settings, mario_)
if curlevel.active:
gf.update_pos(settings, timers, enemies, objects, background,
curlevel, items, mario_, ui)
gf.update_animations(enemies, timers, objects, mario_)
gf.update_level_timer(ui, timers, mario_)
gf.update_screen(screen, ui, enemies, timers, objects, background,
curlevel, mario_, items)
if ui.lives == 0:
curlevel.active = False
ui.lives = 3
settings.level_num = 0
else:
objects.empty()
background.empty()
items.empty()
enemies.empty()
curlevel = gf.change_level(settings, screen, enemies, objects,
background, mario_, ui, timers)
def __init__(self, update_server):
self.temperature_controller = TemperatureController(set_temperature=20,
mode=Mode.COOLER)
self.sensor_controller = SensorController()
self.mqtt_controller = DataController()
self.user_interface = UserInterface()
self.unit_controller = UnitController()
self.update_server = update_server
self.command_subscriber = CommandSubscriber("192.168.3.2",
self.handle_command)
self.current_display_data = None
def __init__(self, player, game_map):
self.move = Move(game_map)
self.user_interface = UserInterface()
self.merchant = Merchant(game_map, self.move)
self.player = player
self.mining_coords = None
# Load templates
self.templates = dict()
template = cv2.imread('./ui_elements/nothingToMine.png')
self.templates['nothingToMine'] = cv2.cvtColor(template, cv2.COLOR_BGR2GRAY)
template = cv2.imread('./ui_elements/cannotMineThere.png')
self.templates['cannotMineThere'] = cv2.cvtColor(template, cv2.COLOR_BGR2GRAY)
def main():
# Define class
detection = Detection()
user_interface = UserInterface()
# Define var
layout_crowd_detection = user_interface.layout_crowd_detection()
layout_define_threshold = user_interface.layout_define_threshold()
# Define threshold
threshold = define_threshold(layout_define_threshold)
# Crowd detection
if not threshold == 'exit':
detection.crowd_detection(threshold, layout_crowd_detection)
print("Exit system")
def user_interface():
user_interface = UserInterface()
p1_name = get_player_name(user_interface)
p2_name = get_player_name(user_interface)
p1_symbol = get_player_symbol(p1_name, user_interface)
p2_symbol = get_player_symbol(p2_name, user_interface)
user_interface.print_symbol(p1_name, p1_symbol)
user_interface.print_symbol(p2_name, p2_symbol)
scores = {p1_name: 0, p2_name: 0}
rounds = 1
play_game(p1_name, p2_name, user_interface, scores, rounds)
def main():
"""
user can input any natural number for the upper limit.
they can set the value and quantity of numbers from which they would like to find multiples
"""
interface = UserInterface()
interface.show_welcome()
upper_limit = interface.get_upper_limit()
if upper_limit == False:
interface.show_tries_reached()
else:
numbers = interface.get_numbers(upper_limit)
master_set = Set(numbers, upper_limit)
multiples_sum = master_set.get_set_sum()
interface.show_solution(multiples_sum)
def get_UserGoal(skipWelcome=False):
global userInterface
## The way it reinits the user interface depends on wether it was initialized before (To skip welcome)
userInterface = UserInterface(skipWelcome=skipWelcome)
userGoal = None
userInterfaceOutput = iter(userInterface)
while not rospy.is_shutdown():
try:
userGoal = next(userInterfaceOutput)
except StopIteration:
listen_bot_status()
dealWithUserGoal(goal=userGoal)
time.sleep(1)
return
def __init__(self):
self.ui = UserInterface()
self.gs = GameSession()
self.view = View()
self.game_file = ''
self.users_data = {} # initialize users data
self.get_users_data() # actualise users data
# main menu components:
self.main_menu_lst = [
('L', 'Login', self.login),
('R', 'Register', self.register),
('Q', 'Quit Game', self.quit)]
self.main_menu_dict = self.ui.make_menu(self.main_menu_lst)
def make_game_choice(self, options: list):
"""
Args:
options (list): - list of game options
ex: ['rock', 'paper', etc.]
Returns:
npc_choice (str): - npc choice
ex: 'rock'
"""
ui = UserInterface()
self._choice = ui.ask_usr_and_validate_int(options)
def main():
config = ConfigParser()
config.read("config.ini")
cm_config = {
"host": config.get("SQL", "host_address"),
"port": config.getint("SQL", "port"),
"user": "",
"passwd": "",
"database": config.get("SQL", "database"),
}
cm = ConnectionManager(cm_config)
ui = UserInterface(cm)
try:
ui.start()
except Exception as e:
print(e)
def create_new_timesheet(self, name):
"""
Creates a new timesheet with specified name
:param name: Name of new timesheet
"""
self.UI.banner()
if "{}.pkl".format(name) in os.listdir(self.path):
print("Timesheet '{}' already exists.".format(name))
self.UI.user_return()
else:
if name != "":
self.name = name
new = True
self.tasks = None
self.data = pd.DataFrame(index=self.tasks)
self.UI = UserInterface(name, new, self.today, VERSION)
self.working_start = None
self.init_configs()
print("New Timesheet with the name '{}' loaded.".format(name))
self.UI.user_return()
def __init__(self):
self.user_interface = UserInterface()
self.computer_player = Computer()
self.human_player = Human()
self.menu_choice_msg = (
"\nTIC TAC TOE MENU \n1. Player vs Computer \n2. Player vs Player \n3. Computer vs Computer \n4. Display Rules \n5. Quit"
)
self.invalid_entry_msg = (
"This is not a valid entry, please try again: ")
self.input_choice_msg = ("""Please pick menu choice(1-5): """)
self.catgame_msg = ("CAT GAME! Better luck next time!")
self.pvp_prompt_msg = ("X goes first, O goes second.")
self.x_win_msg = ("Player X wins")
self.o_win_msg = ("Player O wins")
self.placeholder_board = [0, 0, 0, 0, 0, 0, 0, 0, 0]
self.win_combos = ((0, 1, 2), (3, 4, 5), (6, 7, 8), (0, 3, 6),
(1, 4, 7), (2, 5, 8), (0, 4, 8), (2, 4, 6))
self.game_running = True
self.turns = 0
self.x_moves = 0
self.o_moves = 0
def __init__(self):
self.version = version
self.records_file = 'records.csv' #默认记录保存位置
self.ongoing_file = 'ongoing.csv' #默认正在进行的经期信息保存位置
self.window_width = 600 #默认窗口宽
self.window_height = 600 #默认窗口高
self.dpi_adapt = True #默认开启高分屏缩放适配
try: #加载设置
with open('config.json') as file_obj:
settings = json.load(file_obj)
self.records_file = settings['records_file']
self.ongoing_file = settings['ongoing_file']
self.window_width = settings['window_width']
self.window_height = settings['window_height']
self.dpi_adapt = settings['dpi_adapt']
except FileNotFoundError:
self.save_settings()
self.load_error = False #文件读取是否异常（决定是否弹窗警告）
self.add_error = False #添加记录是否异常（决定是否弹窗警告）
self.count = 0 #记录条数(int)
self.average_interval = None #总平均周期(int)
self.average_interval_last_six = None #近六次平均周期(int)
self.next_date = None #预计下次经期开始(date)
self.Ovulation = None #预计排卵日(date)
self.average_duration = None #平均经期持续天数(int)
self.ongoing_date = None #正在进行中的经期开始日期(date)
self.records = [] #存放从文件读取的经期记录，并且加上间隔天数
# 结构范例: （持续天数指(结束日期-开始日期+1)）
# [{‘from_date': '2015-10-28', 'duration': 6, 'interval': None},
# {‘from_date': '2015-11-30', 'duration': 6, 'interval': 33}]
self.load() #从文件读取全部经期记录
ui = UserInterface(self) #启动图形界面
ui.window.mainloop()
def load_from_file(file_path=None):
if file_path is None:
file_path = "input_graph.txt"
graph = None
with open(file_path) as f:
for line in f:
try:
if line == '\n': continue
op, args = parse_line(line)
if op == SET_NUM_OF_VERTICES:
num_of_vertices = args
graph = UserInterface(num_of_vertices)
elif op == SET_EDGE_WEIGHT:
graph.set_edge(args[0], args[1], args[2], args[3])
elif op == SET_VERTIX_INFO:
if args[1] == "F":
graph.set_vertex_flood(args[0], args[2])
else:
raise Exception("Unknown input")
elif op == SET_DEADLINE:
deadline = args
except:
print(line)
return graph
def __init__(self):
self.frequency = 4e3
self.speed = 343
self.scale = 1
self.spacing = 0.5
self.width = 8
self.height = 1
self.offset_horizontal = math.pi / 3
self.offset_vertical = 0
self.color_range = 100
self.z = 0
self.plane = 'XY'
self.user_interface = UserInterface(self)
self.backend = GLBackend(self.user_interface.display,
self.user_interface.keyboard)
self.sources = []
self.offsets = []
self.generate_array()
self.generate_offsets()
self.upload_all()
self.user_interface.start()
def test_update_set_temperature():
temp_controller = TemperatureController()
interface = UserInterface(TemperatureUnits.C)
interface.update_set_temperature(70, temp_controller)
user_interface.render()
text_to_speech(chatbot_response)
history.exit()
return user_name
if __name__ == "__main__":
input_sentence = ""
current_emotion = ""
meeting_emotion = ""
top_words = []
# Enter a Mircosoft Speech token into the SpeechRecognition constructor
speech = SpeechRecognition("")
user_interface = UserInterface(window)
context = ContextRecognition()
context.load_corpus("corpus/")
context.load_model()
emotion = EmotionRecognition(user_interface)
emotion.start()
# The chatbot will start listening to the user after they say "computer"
# The bot will then read your emotion via webcam
while input_sentence != "computer":
user_interface.update_sprites("Listening...", "Emotion: None", "User: Unknown", "Primary Topics: ")
user_interface.render()
emotion.run()
import cv2
import pyautogui
from game_map import GameMap
import utilities as utils
from user_interface import UserInterface
from player import Player
# Set defaults
task = Player.TASKS.MINE
if len(sys.argv) > 1:
task = Player.TASKS[sys.argv[1].upper()]
# Initialize classes
game_map = GameMap()
player = Player(game_map, task)
user_interface = UserInterface()
utils.log("INIT", "====================================================")
utils.log("INIT", "Initializing...")
utils.log("INIT", F"Default task set to {task}")
# Find blocking window in screenshot
screenshot = utils.take_screenshot(False)
result = cv2.matchTemplate(screenshot, user_interface.templates['sponsored'], cv2.TM_CCORR_NORMED)
_, max_val, _, max_loc = cv2.minMaxLoc(result)
# Found the blocking window window with high confidence
if max_val > 0.9:
click_at = (max_loc[0] + 428, max_loc[1] + 144)
utils.log("INIT", "Closed blocking window")
pyautogui.moveTo(click_at[0], click_at[1], 0.15)
def main():
UI = UserInterface()
UI.discuss()
def __init__(self):
self.user_interface = UserInterface()
self.stored_moves = []
self.num_board = [1, 2, 3, 4, 5, 6, 7, 8, 9]
from card import Card
from user_interface import UserInterface
UI = UserInterface()
class Hand:
"""Defines a single hand. Also stores bets placed on a given hand, and who placed those bets."""
def __init__(self, cards=None, bet=None):
"""'cards' is a list of cards (card objects) in the hand.
'bets' is a tuple as follows: (bet_value, bet_owner).
'split' indicates whether a hand should be split when possible."""
if cards == None:
self.cards = []
else:
self.cards = cards
self.bet = bet
self.folded = False
self.split = False
def __str__(self):
"""Returns a reasonable string representation of the hand."""
output = ""
card_string_list = [str(card) for card in self.cards]
output = "\n".join(card_string_list)
return output
def add_card(self, new_card):
"""Adds a card to a hand."""
self.cards.append(new_card)
def __init__(self, fullscreen=False):
self.camera = Camera()
self.printer = Printer()
self.ui = UserInterface(fullscreen=fullscreen)
self.setup()
