예제 #1
0
class Game:
    def quit(self):
        self._user_interface.print("Bye!")
        exit()

    def __init__(self):
        self._world = World()
        directions = resources.load_directions()
        resources.load_rooms(self._world, directions)
        self._player = Player(self._world.starting_room, directions)
        commands = resources.load_commands(self)
        self._user_interface = UserInterface(commands)

        aliases = resources.load_aliases()
        errors = resources.load_errors()
        parser = Parser(directions, commands, aliases, errors)

        while True:
            self._user_interface.describe_room(self._player.room)
            (cmd, *args) = parser.get_input()
            result = cmd(*args)
            if result:
                result.show()

    @property
    def world(self):
        return self._world

    @property
    def user_interface(self):
        return self._user_interface

    @property
    def player(self):
        return self._player
예제 #2
0
 def __init__(self, game_map, move):
     self.user_interface = UserInterface()
     self.backpack = Backpack()
     self.move = move
     self.game_map = game_map
예제 #3
0
class Merchant:
    """
        This class handles all merchant related actions including
        buying and selling as well as depositing gold
        """
    MERCHANTS = Enum('Merchants',
                     'WEAPONS, BLACKSMITH, POTIONS, ITEMS, BANKER')

    def __init__(self, game_map, move):
        self.user_interface = UserInterface()
        self.backpack = Backpack()
        self.move = move
        self.game_map = game_map

    def move_to_merchant(self, merchant_type):
        """
            Move to a merchant
            """
        # Move to the appropriate merchant
        merchant_tile = None
        # Weapons shopkeeper
        if merchant_type == self.MERCHANTS.WEAPONS:
            merchant_tile = self.game_map.TILES.WEAPON_SHOPKEEPER.value
            self.move.move_to(self.move.WEAPON_SHOPKEEPER)
        # Blacksmith
        elif merchant_type == self.MERCHANTS.BLACKSMITH:
            merchant_tile = self.game_map.TILES.BLACKSMITH.value
            self.move.move_to(self.move.FURNACE)
        # Potions shopkeeper
        elif merchant_type == self.MERCHANTS.POTIONS:
            merchant_tile = self.game_map.TILES.POTIONS_SHOPKEEPER.value
            self.move.move_to(self.move.POTIONS_SHOPKEEPER)
        # Items shopkeeper
        elif merchant_type == self.MERCHANTS.ITEMS:
            merchant_tile = self.game_map.TILES.ITEM_SHOPKEEPER.value
            self.move.move_to(self.move.ITEMS)
        # Banker
        elif merchant_type == self.MERCHANTS.BANKER:
            merchant_tile = self.game_map.TILES.BANKER.value
            self.move.move_to(self.move.BANKER)
        else:
            utils.log("SEVERE",
                      "Invalid merchant_type supplied to move_to_merchant")
            utils.quit_game()

        # Update map so merchant's position will be current
        self.game_map.update_map()

        # Get the 5x5 matrix of tiles surrounding the player
        clickable_tiles = self.game_map.game_map[(
            self.game_map.player_position[0] -
            2):(self.game_map.player_position[0] +
                3), (self.game_map.player_position[1] -
                     2):(self.game_map.player_position[1] + 3)]

        # Find the index where merchant is located
        merchant_indices = np.argwhere(clickable_tiles == merchant_tile)
        if merchant_indices.size == 0:
            return False

        # Get the merchant index
        merchant_index = merchant_indices[0]

        # Calculate where to click (2 because player is in center of 5x5 matrix that is 0 indexed)
        x_coord = merchant_index[0] - 2
        y_coord = merchant_index[1] - 2
        return (176 + (x_coord * 16), 176 + (y_coord * 16))

    def click_on_merchant(self, merchant_type):
        """
            Move to the specified merchant type and double click them
            """
        # Move to the merchant
        attempts = 0
        while attempts < 10:
            # Find where to click on the merchant
            click_at = self.move_to_merchant(merchant_type)

            if not click_at:
                continue

            # Click on the merchant
            pyautogui.moveTo(click_at[0], click_at[1], 0.15)
            pyautogui.doubleClick()

            # Check that the buy or sell window was opened
            buy_or_sell = self.user_interface.wait_for_ui_element(
                'buyOrSell', exit_on_fail=False)

            # Buy and sell window is open
            if buy_or_sell:
                return True

            # Still not open
            sleep(1)
            attempts += 1

        # Never opened
        return False

    def open_merchant_window(self, merchant_type):
        """
            Open the "Buy or Sell" window or return False is unable to
            """
        attempts = 0
        while attempts < 10:
            # Try and click on the merchant
            window_is_open = self.click_on_merchant(merchant_type)

            if window_is_open:
                return window_is_open

            sleep(1)
            attempts += 1

        return False

    def buy_item(self, item, merchant_type):
        """
            Move to a merchant and buy an item
            """
        # Open the "Buy or Sell" window
        buy_or_sell = self.open_merchant_window(merchant_type)
        if not buy_or_sell:
            utils.log(
                "SEVERE",
                F"Failed to click on {merchant_type} and open 'Buy or Sell' after 10 attempts"
            )
            utils.quit_game()

        # Click the buy button
        buy_button = self.user_interface.wait_for_ui_element('buy')
        pyautogui.moveTo(buy_button[0] + 10, buy_button[1] + 10, 0.15)
        pyautogui.click()

        # Wait for the buy menu to open
        self.user_interface.wait_for_ui_element('buyMenu')

        # Find the item to buy
        item_loc = self.user_interface.wait_for_ui_element(item)
        pyautogui.moveTo(item_loc[0] + 6, item_loc[1] + 6, 0.15)
        pyautogui.doubleClick()

        # Confirm the sale
        check_mark = self.user_interface.wait_for_ui_element('checkMark')
        pyautogui.moveTo(check_mark[0] + 5, check_mark[1] + 5, 0.15)
        pyautogui.click()

        # Click cancel to leave the window
        cancel = self.user_interface.wait_for_ui_element('cancel')
        pyautogui.moveTo(cancel[0] + 5, cancel[1] + 5, 0.15)
        pyautogui.click()

        pyautogui.moveTo(400, 400)
        utils.log("INFO", F"Bought a {item}")

    def sell_item(self, item, merchant_type):
        """
            Move to a merchant and sell an item
            """
        # Open the "Buy or Sell" window
        buy_or_sell = self.open_merchant_window(merchant_type)
        if not buy_or_sell:
            utils.log(
                "SEVERE",
                F"Failed to click on {merchant_type} and open 'Buy or Sell' after 10 attempts"
            )
            utils.quit_game()

        # Click the sell button
        sell_button = self.user_interface.wait_for_ui_element('sell')
        pyautogui.moveTo(sell_button[0] + 10, sell_button[1] + 10, 0.15)
        pyautogui.click()

        # Wait for the sell menu to open
        self.user_interface.wait_for_ui_element('sellMenu')

        # Offer up to 12 items
        items_sold = 0
        for _ in range(12):
            # Move the cursor away so it will register an "hover" event when move back
            pyautogui.moveTo(330, 206)

            # Find a item to sell
            item_loc = self.user_interface.get_ui_element(item,
                                                          exit_on_fail=False)

            # No item_locs left to sell
            if not item_loc:
                utils.log("INFO", F"No {item} left to offer shopkeeper")
                break

            items_sold += 1
            pyautogui.moveTo(item_loc[0] + 6, item_loc[1] + 12, 0.15)
            pyautogui.doubleClick()
            sleep(0.5)

        # Confirm the sale
        check_mark = self.user_interface.wait_for_ui_element('checkMark')
        pyautogui.moveTo(check_mark[0] + 5, check_mark[1] + 5, 0.15)
        pyautogui.click()

        # Click cancel to leave the window
        cancel = self.user_interface.wait_for_ui_element('cancel')
        pyautogui.moveTo(cancel[0] + 5, cancel[1] + 5, 0.15)
        pyautogui.click()

        utils.log("INFO", F"Sold {items_sold} {item}(s)")
        return items_sold
예제 #4
0
class Player():
    """
        This class handles everything relating to the player
        """
    LOW_HEALTH = 150
    TASKS = Enum('Task', 'MINE, SMELT, FORGE')

    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 perform_task(self):
        """
            Checks health, organizes backpack and then performs
            one of the following tasks: mine, smelt, or forge
            """
        # Do pre-task checks
        self.action_count += 1

        # Only check health every 25 turns (it is a slow process)
        if self.action_count % 25 == 0:
            self.action_count = 0
            self.check_health()

        # Perform task
        if self.task == self.TASKS.MINE:
            self.task = self.mine.mine()
            delay = 0
        elif self.task == self.TASKS.SMELT:
            self.task = self.smelt.smelt()
            delay = 1.4
        elif self.task == self.TASKS.FORGE:
            self.task = self.forge.forge()
            delay = 2.1

        # Give the task time to complete
        sleep(delay)

        # Organize backpack now that items have been potentially added
        self.organize_backpack()

    def check_health(self):
        """
            Checks player's HP and uses a potion if it is low.
            If no potions are found, game will quit
            """
        # Check if HP is low
        if self.user_interface.get_health() < self.LOW_HEALTH:
            # Attempt to use a potion
            utils.log("INFO", F"Health dropped below {self.LOW_HEALTH}")
            used_potion = self.backpack.use_item('potion', offset=(4, 9))

            # No potions were found
            if not used_potion:
                # Potions may be obscurred by items, try selling
                self.forge.sell_items()
                # Try using a potion again
                used_potion = self.backpack.use_item('potion', offset=(4, 9))

                # Still can't use potions, likely do not have any
                if not used_potion:
                    utils.log("SEVERE", "No potions found")
                    utils.quit_game()

            # Sleep so that there is no issue using the next item
            utils.log("INFO", F"Used a potion")
            sleep(6)

    def is_weight_below_threshold(self, threshold):
        # Calculate how much more weight the player can carry
        current_weight, max_weight = self.user_interface.get_weight()
        difference = max_weight - current_weight

        # Check if the weight the player can carry is below the threshold
        if difference < threshold:
            utils.log("INFO", F"Weight is {difference} from max, threshold was set to {threshold}")
            return True

        return False

    def organize_backpack(self):
        """
            Move all items to the correct areas of the backpack
            """
        self.backpack.move_item('ore', self.backpack.ORE_LOC, (8, 6))
        self.backpack.move_item('gem', self.backpack.GEM_LOC, (4, 2))
        self.backpack.move_item('jewel', self.backpack.GEM_LOC, (4, 2))
        self.backpack.move_item('galantine', self.backpack.GEM_LOC, (5, 4))
        self.backpack.move_item('pickaxe', self.backpack.PICKAXE_LOC, (9, 4))
        self.backpack.move_item('dagger', self.backpack.DAGGER_LOC, (4, 6))
        self.backpack.move_item('hammer', self.backpack.HAMMER_LOC, (7, 3))
        self.backpack.move_item('gold', self.backpack.GEM_LOC, (6, 5))
        self.backpack.move_item('ingot', self.backpack.INGOT_LOC)
예제 #5
0
import sys
sys.path.append("../src/")

from user_interface import UserInterface
from camera import Camera

camera = Camera()
camera.start()

ui = UserInterface()

ui.setup_screen("con", "not con")
ui.wait_for_input()

ui.opening_screen()
ui.wait_for_input()

ui.x_of_y_screen(1, 3)
ui.wait_for_input()

ui.countdown_screen(camera)

ui.image_screen("../images/photobooth_opening.png")
ui.wait_for_input()

ui.print_screen("../images/photobooth_opening.png")
ui.wait_for_input()
예제 #6
0
from user_interface import UserInterface

UserInterface().main()
예제 #7
0
파일: display.py 프로젝트: benjdelt/tracker
class Feeder:
    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 run(self):
        self.running = True
        self.ui.win.addstr(11, 1, f"Task: ")
        self.ui.win.addstr(11, 7, f"{self.task}", curses.color_pair(2))
        self.feed()

    def quit(self):
        self.running = False
        self.ui.quit_ui()
        if self.paused:
            self.start = time.time() + 1
        task = f" in {self.task}" if self.task != "None" else ""
        exit(
            f"Time{task}: {timer.get_time_string(self.start, self.recorded_time)}"
        )

    def feed(self):
        try:
            while self.running:
                while sys.stdin in select([sys.stdin], [], [], 0)[0]:
                    line = sys.stdin.read(1)
                    if line.strip().lower() == "q":
                        if config.autosave_q:
                            save = Save(self.first_start, self.paused,
                                        self.recorded_time, self.start,
                                        self.task)
                            save.save_to_csv()
                        self.quit()
                        break
                    elif line.strip().lower() == "p":
                        if self.paused:
                            self.start = time.time()
                            self.ui.win.addstr(14, 29, "          ")
                            self.paused = False
                        else:
                            self.recorded_time = timer.compute_time(
                                self.start, self.recorded_time)
                            self.ui.win.addstr(14, 29, "**PAUSED**",
                                               curses.color_pair(1))
                            self.paused = True
                    elif line.strip().lower() == "s":
                        save = Save(self.first_start, self.paused,
                                    self.recorded_time, self.start, self.task)
                        save.save_to_csv()
                if not self.paused:
                    self.ui.win.addstr(
                        9, 33,
                        timer.get_time_string(self.start, self.recorded_time),
                        curses.A_BOLD)
                if not config.autosave_delay == 0:
                    if int(time.time()) != int(self.start):
                        if (int(time.time()) -
                                int(self.start)) % config.autosave_delay == 0:
                            save = Save(self.first_start, self.paused,
                                        self.recorded_time, self.start,
                                        self.task)
                            save.save_to_csv()

                self.ui.refresh()
                time.sleep(0.1)
        except KeyboardInterrupt:
            if config.autosave_c:
                save = Save(self.first_start, self.paused, self.recorded_time,
                            self.start, self.task)
                save.save_to_csv()
            self.quit()
예제 #8
0
class TimesheetManager:
    def __init__(self, name=None, path=os.getcwd()):
        self.__version__ = VERSION
        self.path = pathjoin(path, "timesheets")
        os.makedirs(self.path, exist_ok=True)
        os.makedirs(CONFIG_PATH, exist_ok=True)
        if "config.data" not in os.listdir(CONFIG_PATH):
            self.create_config()
        default, tz = self.load_config()
        self.tz = tz
        if name is None:
            if default != "":
                name = default
            else:
                clear()
                print(
                    "[SETUP] There is no default Timesheet set.  A temporary Timesheet will be created."
                )
                print(
                    "\nIf you have not yet created a timesheet, or need to set your default timesheet,"
                )
                print("please do so in the 'Timesheet Management' menu.")
                _ = input("\nPress ENTER to continue...")
                name = "TEMPORARY"
        self.name = name
        self.today = pendulum.today(tz=self.tz)
        new = False
        loaded = self.load_timesheet(self.name)
        if not loaded:
            clear()
            print(
                "[SETUP] The current default Timesheet does not exist.\nA temporary Timesheet will be created."
            )
            print(
                "\nPlease change your default timesheet in the 'Timesheet Management' menu."
            )
            _ = input("\nPress ENTER to continue...")
            name = "TEMPORARY"
            new = True
            self.tasks = None
            self.data = pd.DataFrame(index=self.tasks)
        self.init_configs()
        self.working_start = None
        self.work_day_allocated = 0
        self.UI = UserInterface(name, new, self.today, VERSION)

        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(
            )
            self.UI.working = True

        while True:
            code, string = self.UI.ask_generic_input()

            if code == '1':
                self.start_task(string)
            elif code == '2':
                if string == 'start':
                    self.start_workday()
                else:
                    self.add_workday()
            elif code == '31':
                self.time_per_task(string)
            elif code == '32':
                self.time_per_day(string)
            elif code == '33':
                self.time_per_taskday(*string)
            elif code == '34':
                self.total_time()
            elif code == "35":
                self.weekly_report()
            elif code == '41':
                self.list_tasks()
            elif code == '43':
                self.delete_task(string)
            elif code == '42':
                self.add_task(string)
            elif code == '43':
                self.delete_task(string)
            elif code == '51':
                self.list_timesheets()
            elif code == '52':
                self.create_new_timesheet(string)
            elif code == '53':
                loaded = self.load_timesheet(string)
                if not loaded:
                    print("Timesheet '{}' does not exist.".format(name))
                self.UI.user_return()
            elif code == '54':
                self.delete_timesheet(string)
            elif code == '55':
                self.backup_timesheet(string)
            elif code == '56':
                self.save_config_default(string)
            elif code == '59':
                self.export()
            elif code == '57':
                self.set_baseline(string)
            elif code == '58':
                self.set_workweek(string)
            elif code == '7':
                if self.working_start is not None:
                    self.UI.banner()
                    print(
                        "[WARNING] The workday is still running!  Please stop it before exiting."
                    )
                    self.UI.user_return()
                else:
                    sys.exit()
            elif code == 'debug':
                self.debug()

            self.UI.banner()  # places banner at top of each new page

    ################ File Management Functions ################

    def save_timesheet(self, path, name, data):
        """
        Saves current active timesheet at specified path.
        :param path: path to save
        :param name: name of Timesheet
        :param data: data of timesheet
        """
        path = pathjoin(path, "{}.pkl".format(name))
        pickle.dump(data, open(path, "wb"))

    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 delete_timesheet(self, name):
        """
        Deletes a timesheet.  Has a confirmation to make sure a file isn't deleted when not wanted to
        Will not delete backups!  This is a safety feature.
        :param name: name of timesheet to delete
        """
        self.UI.banner()
        if name != "":
            decision = None
            while decision not in ["y", "n"]:
                decision = input(
                    "[WARNING] Confirm DELETION of Timesheet '{}' [y/n]: ".
                    format(name)).lower()
            if decision == "y":
                if "{}.pkl".format(name) in os.listdir(self.path):
                    if name == self.name:
                        os.remove(pathjoin(self.path, name + ".pkl"))
                        print(
                            "[WARNING] Deleting current Timesheet, new current Timesheet will be the default."
                        )
                        _ = input("\nPress ENTER to continue...")
                        loaded = self.load_timesheet(self.load_config()[0])
                        if not loaded:
                            self.UI.banner()
                            print(
                                "[WARNING] No default Timesheet set, creating a temporary..."
                            )
                            _ = input("\nPress ENTER to acknowledge...")
                            self.create_new_timesheet("TEMPORARY")
                    self.UI.banner()
                    print("'{}' deleted.".format(name))
                    self.UI.user_return()
                else:
                    print(
                        "There exists no Timesheet with the name '{}'.".format(
                            name))
                    self.UI.user_return()
            else:
                print("'{}' not deleted.".format(name))
                self.UI.user_return()

    def list_timesheets(self):
        """
        Lists Timesheets saved
        """
        self.UI.banner()
        print("List of Timesheets:\n")
        i = 1  # need this because it will also pick up non .pkls if using enumerate
        for timesheet in os.listdir(self.path):
            if timesheet[-4:] == '.pkl':
                print("\t({}) {}".format(
                    i,
                    timesheet.split(
                        '.')[0]))  # remove the .pkl extension in printing
                i += 1
        self.UI.user_return()

    def backup_timesheet(self, name):
        """
        Backups a timesheet by saving it in another folder.  First loads it, then saves it in the
        backup folder
        :param name: name of timesheet to backup
        """
        path = pathjoin(self.path, ".backup")
        os.makedirs(path, exist_ok=True)
        data = self.load_timesheet(name, only_data=True)
        if type(data) == bool:
            print("Timesheet '{}' does not exist.".format(name))
        else:
            self.save_timesheet(path, name, data)

            if "{}-config.data".format(self.name) in os.listdir(CONFIG_PATH):
                os.makedirs(pathjoin(path, ".config"), exist_ok=True)
                copyfile(
                    pathjoin(CONFIG_PATH, "{}-config.data".format(self.name)),
                    pathjoin(path, ".config",
                             "{}-config.data".format(self.name)))

            print("'{}' successfully backed up.".format(name))
        self.UI.user_return()

    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 export(self):
        """
        Exports data to csv after confirmation dialog
        """
        self.UI.banner()
        export = input(
            "[WARNING] Exporting times from the current Timesheet will allow \n"
            "anyone to view the data without the need for unpickling.\n\n"
            "Do you wish to continue? [y/n]...")
        if export.lower() == 'y':
            self.UI.banner()
            print("Exporting Timesheet '{}' to '{}.csv'".format(
                self.name, self.name))
            self.data.to_csv("{}.csv".format(self.name))
            print("\nExport successful.")
            self.UI.user_return()
        elif export.lower() == 'n':
            self.UI.banner()
            print("Exporting canceled.")
            self.UI.user_return()
        else:
            self.UI.banner()
            print("[WARNING] Invalid input...not exporting.")
            self.UI.user_return()

    ################ State Functions ################

    def create_state(self, task, start):
        """
        Creates a hidden state file with the current task and time being recording so it can be started again in
        case of failure.  No need to check for existence since it will always be deleted on startup.
        :param task: task being recorded
        :param start: starting time of task
        """
        with open(pathjoin(STATE_PATH, ".state-{}".format(self.name)),
                  "w") as state:
            state.write("{}={}".format(task, start))

    def create_workday_state(self):
        """
        Creates a hidden state file with the time the workday was started and also allocated time so the workday
        can be started again in case of failure.  No need to check for existence since it will always be deleted on
        startup.
        """
        with open(pathjoin(STATE_PATH, ".state-{}-workday".format(self.name)),
                  "w") as state:
            state.write("{}={}".format(self.working_start,
                                       self.work_day_allocated))

    def load_workday_state(self):
        """
        Loads the workday information in the saved state file
        :return: workday time and allocated time
        """
        with open(pathjoin(STATE_PATH, ".state-{}-workday".format(self.name)),
                  "r") as state:
            old = state.read().split("=")
            workday = float(old[0])
            allocated = float(old[1])
        return workday, allocated

    def load_state(self):
        """
        Loads the information in the saved state file
        :return: the task and start time of the info in the file
        """
        with open(pathjoin(STATE_PATH, ".state-{}".format(self.name)),
                  "r") as state:
            old = state.read().split("=")
            task = old[0]
            start = float(old[1])
        return task, start

    def delete_state(self):
        """
        Deletes the state file
        """
        os.remove(pathjoin(STATE_PATH, ".state-{}".format(self.name)))

    def delete_workday_state(self):
        """
        Deletes the workday state file
        """
        os.remove(pathjoin(STATE_PATH, ".state-{}-workday".format(self.name)))

    ################ Configuration Functions ################

    def create_config(self):
        """
        Creates a config with all parameters empty
        """
        with open(pathjoin(CONFIG_PATH, "config.data"), "w") as config:
            config.write("default_timesheet=")
            config.write("\ntz=local")

    def save_config_default(self, default):
        """
        Saves default timesheet in a text file for later usage.
        :param default: name of timesheet to set as default
        """
        self.UI.banner()
        with open(pathjoin(CONFIG_PATH, "config.data"), "r") as config:
            lines = config.readlines()
        with open(pathjoin(CONFIG_PATH, "config.data"), 'w') as config:
            config.seek(0)  # rewind
            config.write(
                "default_timesheet={}\n".format(default))  # write the new line
            for line in lines[1:]:  # paste all future lines
                config.write(line)
        print("'{}' set as default Timesheet.".format(default))
        self.UI.user_return()

    def save_config_timesheet(self, workweek_hours, baseline):
        """
        Saves timesheet specific configurations
        Format:
        [NAME]
        workweek=40
        baseline=23h17m

        [NAME]
        workweek=
        baseline=
        :param workweek_hours: what the workweek hours are; defaults to what is loaded at start
        :param baseline: imported already worked times; defaults to what is loaded at start
        """
        if "{}-config.data".format(self.name) not in os.listdir(
                CONFIG_PATH):  # create it if it doesn't exist
            with open(
                    pathjoin(CONFIG_PATH, "{}-config.data".format(self.name)),
                    "w") as config:
                config.write("[{}]".format(self.name))
        with open(pathjoin(CONFIG_PATH, "{}-config.data".format(self.name)),
                  "w") as config:
            if workweek_hours == None:
                workweek_hours = ""
            if baseline == None:
                baseline = ""
            config.write("[{}]".format(self.name))
            config.write("\nworkweek={}".format(workweek_hours))
            config.write("\nbaseline={}".format(baseline))

    def load_config_timesheet(self):
        """
        Loads in timesheet specific config information
        """
        with open(pathjoin(CONFIG_PATH, "{}-config.data".format(self.name)),
                  "r") as config:
            for line in config.readlines():
                if line[:8] == "workweek":
                    workweek_line = line
                elif line[:8] == "baseline":
                    baseline_line = line
            workweek = workweek_line.split("=")[1]
            baseline = baseline_line.split("=")[1]
        return workweek[:-1], baseline  # to -2 to avoid \n

    def load_config(self):
        """
        Loads config file
        """
        with open(pathjoin(CONFIG_PATH, "config.data"), "r") as config:
            for line in config.readlines():
                if line[:7] == "default":
                    default_line = line
                elif line[:2] == "tz":
                    tz_line = line
            default = default_line.split("=")[1]
            tz = tz_line.split("=")[1]
        return default[:-1], tz  # to -2 to avoid \n

    def set_baseline(self, baseline):
        """
        Sets baseline by rewriting file and keeping everything the same except baseline
        :param baseline: the baseline to write
        """
        self.UI.banner()
        self.save_config_timesheet(self.workweek, baseline)
        print("Baseline saved for Timesheet '{}'.".format(self.name))
        self.baseline = baseline
        self.UI.user_return()

    def set_workweek(self, workweek):
        """
        Sets workweek by rewriting file and keeping everything the same except workweek
        :param workweek: the workweek to write
        """
        self.UI.banner()
        if workweek != "":
            self.workweek = int(workweek)
        else:
            self.workweek = ""
        self.save_config_timesheet(workweek, self.baseline)
        print("Workweek saved for Timesheet '{}'.".format(self.name))
        self.UI.user_return()

    def init_configs(self):
        """
        Just a function to help keep the code clean since this will appear multiple times.
        """
        try:
            workweek, baseline = self.load_config_timesheet()
            if workweek != "":
                self.workweek = int(workweek)
            else:
                self.workweek = ""
            self.baseline = baseline
        except FileNotFoundError:
            self.workweek = ""
            self.baseline = ""

    ################ Logging Functions ################

    def start_task(self, task_name):
        """
        Starts the recording process.  Quietly calls _end_task when done, to record the time into the data.  Creates a
        new task if provided task is not already existing.
        :param task_name: task to record
        """
        go_on = True
        if task_name != "":
            if task_name not in self.data.index:
                self.UI.banner()
                add = input(
                    "[WARNING] '{}' is not in the list of Tasks...would you like to add it? [y/n]..."
                    .format(task_name))
                if add.lower() == 'y':
                    self.add_task(task_name, suppress=True)
                    go_on = True
                elif add.lower() == 'n':
                    go_on = False
                else:
                    print(
                        "[WARNING] Invalid input...not creating new Task and returning to the main menu..."
                    )
                    go_on = False
                    self.UI.user_return()
            if go_on:
                if self.today.to_date_string() not in self.data.columns:
                    self.data[self.today.to_date_string()] = 0
                start_time = time.time()
                # Save the state in case of crashes:
                self.create_state(task_name, start_time)
                # Start the UI logging time, once stopped through the UI, record the time
                self.UI.timelogger(task_name)
                self._end_task(task_name, start_time)

    def start_task_from_state(self, task_name, start):
        """
        Starts recording time on the given task and then adds on previously recorded time.

        ASSUMES TASK WAS CONTINUED CONTINUOUSLY FROM INITIAL START
        # TODO: Allow resuming task on a different day
        :param task_name: task to resume
        :param start: old starting time
        """
        if self.today.to_date_string() not in self.data.columns:
            self.data[self.today.to_date_string()] = 0
        self.UI.timelogger(task_name, start)
        self._end_task(task_name, start)

    def _end_task(self, name, start_time):
        """
        Quietly called from start_task.  Ends the task and records the time by adding it to the time already recorded
        for that task
        :param name: task to record
        """
        self.UI.banner()
        time_worked = int(time.time() - start_time)  # do not care about ms
        self.data.at[name, self.today.to_date_string()] += time_worked
        print("Logging of Task '{}' stopped...".format(name))
        self.save_timesheet(self.path, self.name, self.data)
        print("Time successfully recorded!")
        self.delete_state()
        if self.working_start:
            if name != "General":
                self.work_day_allocated += time_worked
                self.create_workday_state()
        self.UI.user_return()
        self.UI.banner()

    def start_workday(self):
        """
        Starts recording all time until deactivated.
        """
        self.working_start = time.time()
        self.create_workday_state()

    def add_workday(self):
        """
        Adds to task "general" all the time during the workday that was not already assigned to a task.
        """
        work_time = time.time() - self.working_start
        self.UI.banner()
        if self.today.to_date_string() not in self.data.columns:
            self.data[self.today.to_date_string()] = 0
        if "General" not in self.data.index:
            print(
                "No Task exists to log general work time...creating Task 'General'"
            )
            self.add_task("General")
        workday = work_time - self.work_day_allocated
        self.work_day_allocated = 0
        self.working_start = None
        self.delete_workday_state()
        if workday < 0:
            print(
                "[ERROR] Workday length was negative time.  Did you start your workday properly?"
            )
            print("[DEBUG] workday={}, worktime={}".format(workday, work_time))
            self.UI.user_return()
        else:
            self.UI.banner()
            self.data.at["General", self.today.to_date_string()] += int(
                workday)  # do not care about ms
            work_time_mins = Converter.sec2min(work_time)
            work_time_hours, work_time_mins = Converter.min2hour(
                work_time_mins)
            work_hour_min_string = Converter.convert2string(
                int(work_time_hours), int(work_time_mins))
            mins = Converter.sec2min(workday)
            hours, mins = Converter.min2hour(mins)
            hour_min_string = Converter.convert2string(int(hours), int(mins))
            print(
                "Total hours accumulated during the this work day: {}".format(
                    work_hour_min_string))
            print("Total hours set as general tasks during this period: {}".
                  format(hour_min_string))
            print("\nWork day ended!")
            self.save_timesheet(self.path, self.name, self.data)
            self.UI.user_return()

    ################ Task Functions ################

    def list_tasks(self):
        """
        Lists the index of the data, which are the task names
        """
        self.UI.banner()
        print("List of Tasks in Timesheet {}:\n".format(self.name))
        for i, task in enumerate(self.data.index):
            print("\t({}) {}".format(i + 1, task))
        self.UI.user_return()

    def add_task(self, task_name, suppress=False):
        """
        Adds task to the dataframe by adding it to the index.  If the task already exists, it exits.
        Can take string or [str].
        :param task_name: name of task to add
        :param suppress: suppresses user blocking input
        """
        self.UI.banner()
        if task_name in self.data.index:
            print("Task '{}' already in Timesheet '{}'.".format(
                task_name, self.name))
            self.UI.user_return()
        else:
            if task_name != "":
                if type(task_name) == str:
                    task_name = [task_name]
                new_task = pd.DataFrame(index=task_name)
                self.data = self.data.append(new_task,
                                             verify_integrity=True,
                                             sort=False)
                print("Task '{}' created.".format(task_name[0]))
                self.data.fillna(0, inplace=True)
                self.save_timesheet(self.path, self.name, self.data)
                if not suppress: self.UI.user_return()

    def delete_task(self, task_name):
        """
        Deletes task from the data.  If it doesn't exist, it does nothing.
        :param task_name: task to delete
        """
        self.UI.banner()
        if task_name not in self.data.index:
            if task_name != "":
                print("'{}' task not in database.".format(task_name))
                self.UI.user_return()
        else:
            self.data.drop(task_name, inplace=True)
            self.save_timesheet(self.path, self.name, self.data)
            print("Task '{}' successfully deleted.".format(task_name))
            self.UI.user_return()

    ################ Time Functions ################  #TODO: Printing when only seconds are there

    def time_per_day(self, day):
        """
        Reports total time worked on given day
        :param day: day to report
        """
        self.UI.banner()
        if day == "today":
            day = self.today.to_date_string()
        elif day == "yesterday":
            day = pendulum.yesterday(tz=self.tz).to_date_string()
        if day not in self.data.columns:
            print("There is no data for the selected date ({}).".format(day))
        else:
            times = self.data[day].sum()
            if times == 0:
                print("No Tasks were logged on {}.".format(day))
            else:
                mins = Converter.sec2min(times)
                hours, mins = Converter.min2hour(mins)
                hour_min_string = Converter.convert2string(
                    int(hours), int(mins))
                string = "Summary for {}:".format(day)
                print(string)
                self.UI.summary_divider(string)
                if hours == 0:
                    print(hour_min_string.split(", ")[1])
                else:
                    print(hour_min_string)

                if type(self.workweek) == int:
                    per_day_minutes = (self.workweek / 5) * 60
                    per_day_hours, per_day_minutes = Converter.min2hour(
                        per_day_minutes)

                    diff_hours, diff_mins = TimeCalculator.subtract(
                        per_day_hours, per_day_minutes, hours, mins)
                    print("\nWith a workweek of {} hours, "
                          "the average daily hours equates to: {}.".format(
                              self.workweek,
                              Converter.convert2string(
                                  int(per_day_hours),
                                  int(per_day_minutes))))  # ugly lol
                    if diff_hours is not None:
                        print("{} is left remaining.".format(
                            Converter.convert2string(int(diff_hours),
                                                     int(diff_mins))))
                    else:
                        print(
                            "Sufficient hours have been worked today to meet that amount."
                        )
        self.UI.user_return()

    def time_per_task(self, task):
        """
        Reports total time worked for given task
        :param task: task to report
        """
        self.UI.banner()
        if task not in self.data.index:
            print("There is no Task named '{}'.".format(task))
        else:
            times = self.data.loc[task].sum()
            if times == 0:
                print("No time was logged for Task '{}'.".format(task))
            else:
                mins = Converter.sec2min(times)
                hours, mins = Converter.min2hour(mins)
                hour_min_string = Converter.convert2string(
                    int(hours), int(mins))
                days, hours_day = Converter.hour2day(hours)
                day_hour_min_string = Converter.convert2string_days(
                    int(days), int(hours_day), int(mins))
                string = "Summary for '{}':".format(task)
                print(string)
                self.UI.summary_divider(string)
                if hours == 0:
                    print(hour_min_string.split(", ")[1])
                else:
                    print(hour_min_string)
                if days != 0: print(day_hour_min_string)
        self.UI.user_return()

    def time_per_taskday(self, task, day):
        """
        Reports total time for a given task on a given day
        :param task: task to report
        :param day: day to report on
        """
        self.UI.banner()
        skip = False
        if day == "today":
            day = self.today.to_date_string()
        elif day == "yesterday":
            day = pendulum.yesterday(tz=self.tz).to_date_string()
        if task not in self.data.index:
            print("There is no Task named '{}'.".format(task))
            skip = True
        if day not in self.data.columns:
            print("There is no data for the selected date ({}).".format(day))
            skip = True
        if not skip:
            times = self.data[day].loc[task]
            if times == 0:
                print("No time was logged for Task '{}' on {}.".format(
                    task, day))
            else:
                mins = Converter.sec2min(times)
                hours, mins = Converter.min2hour(mins)
                hour_min_string = Converter.convert2string(
                    int(hours), int(mins))
                string = "Summary for '{}' on {}:".format(task, day)
                print(string)
                self.UI.summary_divider(string)
                if hours == 0:
                    print(hour_min_string.split(", ")[1])
                else:
                    print(hour_min_string)
        self.UI.user_return()

    def total_time(self):
        """
        Report on total time worked
        """
        self.UI.banner()
        times = self.data.values.sum()
        if times == 0:
            print("No time has been logged in this Timesheet yet.")
        else:
            mins = Converter.sec2min(times)
            hours, mins = Converter.min2hour(mins)
            hour_min_string = Converter.convert2string(int(hours), int(mins))
            days, hours_day = Converter.hour2day(hours)
            day_hour_min_string = Converter.convert2string_days(
                int(days), int(hours_day), int(mins))
            string = "Summary of all time worked stored in Timesheet '{}':".format(
                self.name)
            print(string)
            self.UI.summary_divider(string)
            if hours == 0:
                try:
                    print(hour_min_string.split(", ")[1])
                except:
                    print("Less than a minute.")
            else:
                print(hour_min_string)
            print(day_hour_min_string)
            if self.baseline != "":
                string = "Summary of all time worked including baseline:"
                print("\n" + string)
                self.UI.summary_divider(string)
                back_days, back_hours, back_mins = Converter.parse_DHM(
                    self.baseline)
                total_days = back_days + days
                total_hours = back_hours + hours_day
                total_mins = back_mins + mins
                total_worked_hours = (back_days * 24) + back_hours + hours
                print(
                    Converter.convert2string(int(total_worked_hours),
                                             int(mins)))
                print(
                    Converter.convert2string_days(int(total_days),
                                                  int(total_hours),
                                                  int(total_mins)))
            print(
                "\nSince the creation of this Timesheet, {} individual days have been worked."
                .format(len(self.data.columns.values)))
        self.UI.user_return()

    def weekly_report(self):
        self.UI.banner()
        workdays = get_current_week_days(self.today)
        summable_days = workdays
        tasks = self.data.index
        report_data = generate_day_dict(workdays, tasks)
        # Fill up dictionary with data
        deletable = []
        for day in workdays:
            for task in tasks:
                try:
                    report_data[day][task] = self.data[day].loc[task]
                except KeyError:
                    report_data[day][task] = 0
                    deletable.append(day)
        for delete in set(deletable):  # to remove duplicates
            summable_days.remove(delete)
        # Get max length of tasks so that spacing works out
        max_len = 0
        for task in tasks:
            if len(task) > max_len:
                max_len = len(task)
        # Start report
        string = "Current Week Report"
        print(string)
        self.UI.summary_divider(string)
        for day in reversed(workdays):
            day_string = day
            day = pendulum.parse(day)
            print("{}, {}".format(Converter.convert_int2day(day.day_of_week),
                                  day_string[5:]))
            print("-" * 16)  # length of Wednesday string
            values = []
            for task in tasks:
                value = report_data[day_string][task]
                values.append(value)
                if value != 0:
                    mins = Converter.sec2min(value)
                    hours, mins = Converter.min2hour(mins)
                    hour_min_string = Converter.convert2string(
                        int(hours), int(mins))
                    if len(task) < max_len:
                        string = "{}:".format(task) + (" " *
                                                       (max_len - len(task)))
                    else:
                        string = "{}:".format(task)
                    if hours == 0 and mins != 0:
                        hour_min_string = hour_min_string.split(", ")[1]
                        print("\t" + string + "\t{}".format(hour_min_string))
                    elif hours == 0 and mins == 0:
                        continue
                    else:
                        print("\t" + string + "\t{}".format(hour_min_string))

            value = sum(values)  # Daily sums
            mins = Converter.sec2min(value)
            hours, mins = Converter.min2hour(mins)
            hour_min_string = Converter.convert2string(int(hours), int(mins))
            if hours == 0 and mins != 0:
                hour_min_string = hour_min_string.split(", ")[1]
                print("\n\tDaily Total:\t\t{}\n".format(hour_min_string))
            elif hours == 0 and mins == 0:
                continue
            else:
                print("\n\tDaily Total:\t\t{}\n".format(hour_min_string))

        print("\n------------")
        print("Weekly Total")
        print("------------")
        total = int(self.data[summable_days].sum().sum())
        mins = Converter.sec2min(total)
        hours, mins = Converter.min2hour(mins)
        hour_min_string = Converter.convert2string(int(hours), int(mins))
        days, hours_day = Converter.hour2day(hours)
        day_hour_min_string = Converter.convert2string_days(
            int(days), int(hours_day), int(mins))
        if days == 0:
            if hours == 0:
                print(hour_min_string.split(", ")[1])
            else:
                print(hour_min_string)
        else:
            print(hour_min_string)
            print(day_hour_min_string)

        if type(self.workweek) == int:
            if hours > self.workweek:
                print(
                    "Sufficient hours have been worked this week to meet the workweek requirements."
                )
            else:
                diff = self.workweek - hours
                print(
                    "{} hours still need to be worked this week in order to meet workweek requirements."
                    .format(diff))
        self.UI.user_return()

    ################ Debug Functions ################

    def debug(self):
        self.UI.banner()
        print("[DEBUG] Printing head(20) of underlying dataframe...\n")
        print(self.data.head(20))
        self.UI.user_return()
예제 #9
0
class TestUserInterface(unittest.TestCase):
    class SampleReport:
        def __init__(self):
            self.clone_groups = {
                0: [
                    '/home/alexey/Downloads/masteringdjangocore-sample.pdf',
                    '/home/alexey/Downloads/paris.ps',
                    '/home/alexey/Downloads/IMG_1665.JPG'
                ],
                1: [
                    '/home/alexey/Downloads/Fluent_Python.pdf',
                    '/home/alexey/Downloads/Photos1/IMG_1670.JPG',
                    '/home/alexey/Downloads/IMG_1664.JPG'
                ]
            }
            self.unavailable_files = {
                'can not read anything!!!', 'what to do?'
            }
            self.scanned_files_num = 43
            self.scanned_folders_num = 12
            self.duplications_num = 33
            self.name_scanned_folder = '/dd/qwd/qwdw'

    sample_report = SampleReport()

    ui = UserInterface(sample_report)

    def test_general_information(self):

        self.ui.general_information()

    def test_exceptions(self):

        self.ui.exceptions_information()

    def test_show_search_report(self):

        self.ui.show_search_report()

    def test_show_cleaning_input(self):

        # we suppose that a user entered 1
        self.assertEqual(self.ui.show_cleaning_input(0), ([
            '/home/alexey/Downloads/masteringdjangocore-sample.pdf',
            '/home/alexey/Downloads/paris.ps',
            '/home/alexey/Downloads/IMG_1665.JPG'
        ], 1))

        # we suppose that a user entered 2
        self.assertEqual(self.ui.show_cleaning_input(1), ([
            '/home/alexey/Downloads/Fluent_Python.pdf',
            '/home/alexey/Downloads/Photos1/IMG_1670.JPG',
            '/home/alexey/Downloads/IMG_1664.JPG'
        ], 2))

        # we suppose that a user entered Enter

        self.assertEqual(self.ui.show_cleaning_input(1), (0, 0))

        # we suppose that a user entered 2
        self.assertEqual(self.ui.show_cleaning_input(1), ([
            '/home/alexey/Downloads/Fluent_Python.pdf',
            '/home/alexey/Downloads/Photos1/IMG_1670.JPG',
            '/home/alexey/Downloads/IMG_1664.JPG'
        ], 2))

    def test_report(self):

        cl_report1 = (['mistake1', 'mistake2'], 1, 2, 3)
        cl_report2 = (['mistake4', 'mistake5'], 6, 8, 9)

        self.ui.report(cl_report1)
        self.ui.report(cl_report2)

    def test_overall(self):

        self.ui.overall()
예제 #10
0
# encoding: utf-8
import os
import i18n
from models import Student
from user_interface import UserInterface
from logger import LoggerInterface

tanslation_path = os.getcwd() + '/locales'
i18n.load_path.append(tanslation_path)

userInterface = UserInterface()
loggerInterface = LoggerInterface.getInstance()
name = userInterface.greet_user()
student = Student(name)
loggerInterface.initialize_logging(student)

show_question = 'Y'
while show_question == 'Y':
    question, answer, time_taken = userInterface.display_question()
    is_correct = userInterface.is_answer_correct(question, answer)
    userInterface.show_feedback(is_correct)
    userInterface.update_confidence(is_correct)
    userInterface.update_difficulty_level(is_correct)

    loggerInterface.log(
        "{operand1} * {operand2},{answer},{correct},{time_taken}".format(
            operand1=question.operand1,
            operand2=question.operand2,
            answer=answer,
            correct='Yes' if is_correct else 'No',
            time_taken=time_taken))
예제 #11
0
from user_interface import UserInterface
from hand import Hand

UI = UserInterface()

class Game:
    def __init__(self, deck, dealer = None, players = None):
        """Set up game object. Define min/max bets, whether the game is over or
        not, the deck, players, and dealer, and the maximum number of
        players."""
        self.min_bet = 10
        self.max_bet = 100
        self.turn_limit = 1000
        self.over = False
        self.deck = deck
        self.max_players = 2
        self.dealer = dealer

        if players == None:
            self.players = []
        else:
            self.players = players

    def end_game(self):
        """Simply set the game state to be over."""
        self.over = True

    def start_turn(self):
        """Deal new hands, and take initial user bets (minimum). Perform any
        other start-of-turn actions.  Boot players if they do not have enough
        chips for a minimum bet. End the game if there are no more players."""
예제 #12
0
def main():
    c = Controller(View(), UserInterface(), GameSession(), Menu(),
                   HumanPlayer(), Player())
    c.play_game()
예제 #13
0
from game import Game
from user_interface import UserInterface

# It is import that an imported player imported as 'Player' if you're using
# only the one player.
from ai_players import SplitDoublePlayer, HitPlayer, RandomPlayer
from card_counting_ai import SimpleBeatTheDealerPlayer as CardCounterPlayer

"""This file exists to start the game and help the Game class to direct the flow. 
It initializes the game object and runs the primary game loop. The primary game loop, in short, does the following:
1. receive input actions from each player.
2. Let the dealer have an action.
3. If everybody is done, the dealer does actions until he/she is finished.
4. End the turn and start a new one."""

UI = UserInterface()

UI.game_instructions()

# generate initial players, dealer, and deck
deck = Deck()
deck.shuffle()
# The discard pile is a deck of size 0

# For now, create a single player. Should allow for more.
# @TODO Ask for number of players and their names.

# UNCOMMENT THE FOLLOWING LINE LINE TO EXPERIMENT WITH PRE-BUILT AI SCRIPTS
#players = [SplitDoublePlayer("Human 1"), HitPlayer("Human 2"), RandomPlayer("Human 3")]
#players = [Player('Team Twitter')]
players = [CardCounterPlayer("BeatTheDealer01")]
예제 #14
0
CONNECTION_IP = '10.0.0.138'
DEFAULT_CAM = 0

#incomingVideoStream = VideoListener(CONNECTION_IP)
incomingAudioStream = None  # not implemented
outgoingVideoStream = VideoStream(src=DEFAULT_CAM).start()
#outgoingAudioStream = AudioStream()
#get = GetSingleVideoFrame
#get.GetFrame(get,outgoingVideoStream)
#videoServer = VideoServer(CONNECTION_IP, outgoingVideoStream)
#audioSender = None # not implemented

# start the app
#userInterface = UserInterface(incomingVideoStream, incomingAudioStream)
userInterface = UserInterface(outgoingVideoStream,
                              incomingAudioStream)  # troubleshooting
#userInterface.StartGui();
#this might be better
#https://stackoverflow.com/questions/14140495/how-to-capture-a-video-and-audio-in-python-from-a-camera-or-webcam
"""
SOURCE ELEMENTS:

Audio Source Microphone block captures real-world audio samples at a  sampling rate Fs
Amplitude Control: Use this to reduce the dynamic range of the audio signal.
Uniform Encoder: Uniformly quantize and encode the input into specified number of bits (nbits). The input is saturated at positive and negative Peak value. Output datatype is either 8, 16, or 32-bit signed or unsigned integer, based on the least number of bits needed.
Apply Fixed delay: Models the propagation delay in the network
Apply Random Delay: Models the effect of jittering in the network.
UDP send: Transmit audio packets over the IP network with user data gram protocol (UDP)

DESTINATION ELEMENTS: 
         7. Receive UDP packets from the the other PC and fill up the Buffer.
예제 #15
0
def main():
    game = Game()
    ui = UserInterface(game)

    ui.run_game()
예제 #16
0
from user_interface import UserInterface

if __name__ == '__main__':
    interface = UserInterface()
    interface.run()
예제 #17
0
class Menu:

    ui: UserInterface
    gs: GameSession
    view: View
    game_files: str
    users_data: dict

    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 get_users_data(self):
        self.users_data = cu.get_users_data()

    def print_and_chose_main_menu(self):
        self.view.prt_menu_all('Main Menu:', self.main_menu_dict)
        self.ui.chose_menu(self.main_menu_dict.keys(),
                           self.main_menu_dict)
        return

    def login(self):
        # verify if username - in database
        while True:
            username = cu.ask_for_username_password(password=False)
            if username in ['q', 'Q']:
                self.print_and_chose_main_menu()
                return
            elif username in self.users_data.keys():
                break  # continue to next while
            else:  # if username - not in database => unknown user message
                self.view.unknown_user_message()

        # verify password:
        while True:
            password = cu.ask_for_username_password()
            print('password ', password, type(password))
            print('passwords: ', self.users_data[username],
                  type(self.users_data[username]))
            if password in ['q', 'Q']:
                # back to main menu:
                self.print_and_chose_main_menu()
                return
            # password does not correspond to user
            elif password != self.users_data[username]:
                self.view.invalid_password_message()
            else:
                break  # continue to print welcome back message

        self.view.print_old_user_message(username)
        return

    def register(self):
        pass

    @staticmethod
    def quit():
        exit()
예제 #18
0
파일: engine.py 프로젝트: suguby/robopycode
def start_ui(name, child_conn):
    ui = UserInterface(name)
    ui.run(child_conn)
예제 #19
0
from drone import Drone
from map import Map
from repository import Repository
from controller import Controller
from user_interface import UserInterface

if __name__ == '__main__':
    drone = Drone()
    n = 20
    map = Map(n, n)
    repository = Repository(drone, map)
    controller = Controller(repository)
    ui = UserInterface(controller)
    ui.run()