Пример #1
0
 def check_whether_is_THREE_OF_A_KIND(self, list1):
     return_value,number_list = [],[]
     number_list  = Help.get_number_list(self,list1)
     number_dict = Help.count_numbers(self,list1)
     testcase_is_three_of_a_kind = False
     testcase_has_three_pair = False
     card_number_occurr_three_times  = constant.ZERO
     for key in number_dict:
         if number_dict.get(key) == constant.LENGTH_THREE:
             testcase_has_three_pair = True
             card_number_occurr_three_times = key
     if testcase_has_three_pair:
         testcase_is_three_of_a_kind = True
     
     return_value.append(testcase_is_three_of_a_kind)
     return_value.append(card_number_occurr_three_times)
     temp_number_list = []
     for key in number_list:
         if key == card_number_occurr_three_times:
             pass
         else:
             temp_number_list.append(key)
     return_value.append(temp_number_list[1])
     return_value.append(temp_number_list[0])
     return return_value
Пример #2
0
 def check_whether_is_STRAIGHT(self, list1):
     return_value,number_list = [],[]
     number_list = Help.get_number_list(self,list1)
     testcase_is_straight = Help.check_is_straight(self,list1)
     return_value.append(testcase_is_straight)
     return_value.append(number_list[-1])
     return return_value
Пример #3
0
    def _search_images_sub(self):
        """ Search for all images into current directory and subdirectories"""
        # List all files into current directory and subdirectories
        if os.path.exists(self._input_dir):
            for (root, _, files) in os.walk(self._input_dir):
                for file in files:
                    (name, ext) = os.path.splitext(file)
                    if ext in self._allowed_file_extension:
                        # Get the absolute path of each file
                        abs_path = (root + '/' + file)
                        relroot = root.replace(self._input_dir, '', 1)
                        self._image_list.append({'file': file,
                                                 'name': name,
                                                 'ext': ext,
                                                 'relroot': relroot,
                                                 'abspath': abs_path,
                                                 'size': round(os.path.getsize(abs_path) / (1024 ** 2), 2)
                                                 })
                    else:
                        # Nothing
                        pass

            # If there's no images into directory
            if not self._image_list:
                Help().warning_message("No image into directory")
            else:
                # Nothing
                pass
        else:
            Help().error_message("Input directory not valid")
        pass
Пример #4
0
    def parse_input_args(self):
        """ Main function """
        input_arg_dict = {}
        key_index_list = []

        # First key argument must init with '-'
        if self._input_args:
            if self._input_args[0][0] != '-':
                Help().error_message("First key argument must init with '-' ")
            else:
                pass

        # Store index of key arguments which init with '-'
        for count, input_arg in enumerate(self._input_args):
            if input_arg[0] == '-':
                key_index_list.append(count)
            if count == len(self._input_args)-1:
                # Store a fake index in order to have the length of array into key_index_list
                key_index_list.append(count+1)

        # Create dictionary with input "key" and "value" arguments
        for curr_index, next_index in zip(key_index_list, key_index_list[1:]):
            input_arg_dict.update({self._input_args[curr_index]: self._input_args[curr_index+1:next_index]})

        # Search into parser dictionary
        for arg in list(input_arg_dict.keys()):
            if arg in self._parse_dict:
                # Execute function of dictionary at arg key
                self._parse_dict[arg](input_arg_dict[arg])
            else:
                Help().error_message("'" + arg + "'" + " is not a valid argument")
Пример #5
0
 def check_whether_is_STRAIGHT_FLUSH(self, list1):
     return_value = []
     if Help.check_whether_is_the_same_color(self,list1) == False \
       or Help.check_is_straight(self,list1) == False:
         return_value.append(False)
         return return_value
     else:
         list_sorted = sorted(list1,key = lambda x:(x[1],x[0].lower()))
         return_value.append(True)
         return_value.append(list_sorted[-1][-1])
         return return_value
Пример #6
0
 def check_whether_is_HIGH_CARD(self, list1):
     return_value = []
     number_dict = Help.count_numbers(self,list1)
     testcase_is_high_card = False
     if len(number_dict) == constant.LENGTH_FIVE:
         testcase_is_high_card = True
     return_value.append(testcase_is_high_card)
     number_list = Help.get_number_list(self,list1)
     number_list.reverse()
     for key in number_list:
         return_value.append(key)
     return return_value
Пример #7
0
 def check_whether_is_FLUSH(self, list1):
     return_value,number_list = [],[]
     number_list  = Help.get_number_list(self,list1)
     color_dict =  Help.count_color(self,list1)
     testcase_is_flush = False
     if len(color_dict) == constant.LENGTH_ONE:
         testcase_is_flush = True
     return_value.append(testcase_is_flush)
     return_value.append(number_list[-1])
     return_value.append(number_list[-2])
     return_value.append(number_list[-3])
     return_value.append(number_list[-4])
     return_value.append(number_list[-5])
     return return_value
Пример #8
0
 def check_whether_is_TWO_PAIRS(self, list1):
     return_value = []
     number_dict = Help.count_numbers(self,list1)
     temp_record_number_occurs_two_times = []
     temp_record_number_occurs_only_one_time = constant.ZERO
     number_equals_two_when_has_two_pairs = constant.ZERO
     for key in number_dict:
         if number_dict.get(key) == constant.LENGTH_TWO:
             number_equals_two_when_has_two_pairs = \
               number_equals_two_when_has_two_pairs + 1
             temp_record_number_occurs_two_times.append(key)
         else:
             temp_record_number_occurs_only_one_time = key
     
     if number_equals_two_when_has_two_pairs == constant.LENGTH_TWO:
         return_value.append(True)
         if temp_record_number_occurs_two_times[0] > temp_record_number_occurs_two_times[1]:
             return_value.append(temp_record_number_occurs_two_times[0])
             return_value.append(temp_record_number_occurs_two_times[1])
         else:
             return_value.append(temp_record_number_occurs_two_times[1])
             return_value.append(temp_record_number_occurs_two_times[0])
         return_value.append(temp_record_number_occurs_only_one_time)
     else:
         return_value.append(False)
     return return_value
Пример #9
0
    def initializeClasses(self):

        self.mainMenu = MainMenu(self)
        self.storeFront = StoreFront(self)
        self.inputDepartment = InputDepartment(self)
        self.inputBudget = InputBudget(self)
        self.inputShoppingList = InputShoppingList(self)
        self.overallStoreMap = OverallStoreMap(self)
        self.winCards = WinCards(self)
        self.help = Help(self)
Пример #10
0
    def move(self, num, infoText, listL):

        adj = globals.map.adjacency
        ctrl = globals.map.control
        numList = globals.map.troopNum
        self.me = num
        if (num == 1):
            self.troops = globals.map.player1Available
            self.enemy = 2

        if (num == 2):
            self.troops = globals.map.player2Available
            self.enemy = 1

        helper = Help()

        parent = globals.map

        best_score = 99999999999
        self.cost += 1

        while (1):
            children = helper.make_children(num, parent)
            if children.__len__() != 0:
                best = helper.best_child(children)
                score = helper.calc_heurestic(best) + self.cost
            else:
                break

            if (best_score <= score):
                break
            best_score = score

            parent = best

            children.clear()

        globals.map.troopNum = parent.troopNum.copy()
        globals.map.adjacency = parent.adjacency.copy()
        globals.map.control = parent.control.copy()
        globals.map.player1Available = parent.player1Available
        globals.map.player2Available = parent.player2Available
Пример #11
0
 def check_whether_is_ONE_PAIR(self, list1):
     return_value = []
     testcase_has_one_one_pair = False
     temp_record_number_occurs_twice = constant.ZERO
     number_dict = Help.count_numbers(self,list1)
     if len(number_dict) == constant.LENGTH_FOUR:
         testcase_has_one_one_pair = True
     for key in number_dict:
         if number_dict.get(key) == constant.LENGTH_TWO:
             temp_record_number_occurs_twice = key
     return_value.append(testcase_has_one_one_pair)
     return_value.append(temp_record_number_occurs_twice)
     number_list = Help.get_number_list(self,list1)
     if testcase_has_one_one_pair == True:
         number_list.remove(temp_record_number_occurs_twice)
         number_list.remove(temp_record_number_occurs_twice)
     number_list.reverse()
     for key in number_list:
         return_value.append(key)
     return return_value
Пример #12
0
 def _resize_images(self):
     """ Resize images """
     if self._input_files is None or len(self._input_files) == 0:
         Help().error_message("No input file specified")
     # Parse all images
     elif 'all' in self._input_files:
         for image in self._image_list:
             self._resizing_algorithm(image)
     # Parse specified images only
     else:
         for file in self._input_files:
             for count, image in enumerate(self._image_list):
                 if file == image['file']:
                     self._resizing_algorithm(image)
                     break
                 elif count == len(self._image_list)-1:
                     Help().warning_message(file + ' is not in the directory')
                 else:
                     # nothing
                     pass
             pass
Пример #13
0
    def _search_images(self):
        """ Search for all images into current directory """
        # List all files into current directory
        files_into_dir = []
        if os.path.exists(self._input_dir):
            files_into_dir = os.listdir(self._input_dir)
        else:
            Help().error_message("Input directory not valid")
            pass

        # Search for each file with allowed extension and store them into list of dictionaries
        for file in files_into_dir:
            (name, ext) = os.path.splitext(file)

            if ext in self._allowed_file_extension:
                # Get the absolute path of each file
                abs_path = os.path.abspath(self._input_dir + '/' + file)
                size = round(os.path.getsize(abs_path) / (1024 ** 2), 2)
                if size > self._output_image_size:
                    self._image_list.append({'file': file,
                                             'name': name,
                                             'ext': ext,
                                             'abspath': abs_path,
                                             'relroot': '',
                                             'size': size
                                             })
                else:
                    # Nothing
                    pass
            else:
                # Nothing
                pass

        # If there's no images into directory
        if not self._image_list:
            Help().error_message("No image into directory")
        else:
            # Nothing
            pass
Пример #14
0
    def run():
        print(
            "Hello, please welcome to the game \"Who Wants To Be A Millionaire\""
        )
        i = 0
        question = Question()
        my_money = Money()
        my_helps = Help(1, 1, 1)

        while i <= Constant.TOTAL_QUESTIONS:
            if i == Constant.TOTAL_QUESTIONS:
                print("Congratulations you just have won a million!!!!")
                break

            print("You have: %s EUR" % my_money.get_curr_amount(i))
            answer = raw_input(
                "Press any key if you want to play\nPress Q if you want to take the money and quit\n"
            )
            if str(answer).upper() == "Q":
                print("Thank you for playing! See you next time..")
                break
            guess = question.ask_question(i)
            if str(guess).upper() == "H":
                help = my_helps.choose_help()
                if help == "J":
                    print("You skipped the question, the right answer was %s" %
                          Constant.CORRECT_ANSWERS[i])
                    i = i + 1
                    continue
                elif help in ("A", "R"):
                    my_helps.apply_help(help, i)
                guess = raw_input("Please choose your answer:\n")
            if not question.validate_guess(i, guess):
                print("You have: %s EUR" %
                      my_money.get_current_amount(i, False))
                print("Thank you for playing! See you next time..")
                break
            else:
                i = i + 1
Пример #15
0
 def check_whether_is_FOUR_OF_A_KIND(self, list1):
     return_value = []
     number_dict = {}
     number_dict = Help.count_numbers(self,list1)
     testcase_is_four_of_a_kind = False
     temp_record_number_occurs_four_times = constant.ZERO
     for  key in number_dict:
         if(number_dict.get(key) == constant.LENGTH_FOUR):
             testcase_is_four_of_a_kind = True
             temp_record_number_occurs_four_times = key
     
     return_value.append(testcase_is_four_of_a_kind)
     return_value.append(temp_record_number_occurs_four_times)
     return return_value
Пример #16
0
    def check_whether_is_FULL_HOUSE(self, list1):
        return_value = []
        number_dict = {}
        number_dict = Help.count_numbers(self,list1)
        testcase_is_full_house  = False
        card_number_occurr_three_times = constant.ZERO
        card_number_occurr_two_times = constant.ZERO
        for  key in number_dict:
            if number_dict.get(key) == constant.LENGTH_THREE:
                testcase_is_full_house = True
                card_number_occurr_three_times = key
            if number_dict.get(key) == constant.LENGTH_TWO:
                card_number_occurr_two_times = key

        return_value.append(testcase_is_full_house)
        return_value.append(card_number_occurr_three_times)
        return_value.append(card_number_occurr_two_times)
        return return_value
Пример #17
0
from Menu import Menu
from Integrals import Integrals
from History import History
from InputReader import InputReader
from Help import Help

# creating necessary objects
log = History()
menu = Menu()
reader = InputReader()
sub = Integrals()
myHelp = Help()

while True:

    selection = menu.select()           #

    if selection == 'q':                # Quiting the main menu
        break
    elif selection == '1':              # choosing single integral option
        result = sub.singleIntegral()
        log.add(result)
    elif selection == '2':              # choosing many integrals
        results = sub.manyIntegrals()
        log.add(results)
    elif selection == '3':              # choosing history
        log.show()
        raw_input("Press any key to close...")
    elif selection == '4':              # choosing help
        myHelp.show()
        raw_input("Press any key to close...")
Пример #18
0
    def make_children(self, num, parents):

        adj = parents.adjacency
        ctrl = parents.control
        numList = parents.troopNum
        self.me = num
        if (num == 1):
            self.troops = parents.player1Available
            self.enemy = 2

        if (num == 2):
            self.troops = parents.player2Available
            self.enemy = 1

        helper = Help()

        parent = parents

        best_score = 99999999999
        self.cost += 1
        best_children = []
        number = 0
        children = []
        visited = []
        children.append(parent)
        while (1):
            children.remove(parent)
            current_children = helper.make_children(num, parent)

            for mapA in current_children:
                for mapB in visited:
                    if (mapA.control == mapB.control
                            and mapA.troopNum == mapB.troopNum):
                        current_children.remove(mapA)
                        break

            if (current_children.__len__() != 0):
                visited = visited + current_children.copy()
                children = children + current_children.copy()

            if children.__len__() != 0:

                best = helper.best_child(children)
                best_children.append(helper.deep_copy(best))
                score = helper.calc_heurestic(best) + self.cost
            else:
                break

            best_score = score
            parent = best

            if (helper.calc_heurestic(parent) <= -50 or number >= 21):
                break

            number += 1

        l_best = []
        q = 0
        while (q < best_children.__len__() and q < 2):
            l_best.append(helper.deep_copy(helper.best_child(best_children)))
            best_children.remove(helper.best_child(best_children))
            q += 1

        return l_best
Пример #19
0
def print_help():
    h = Help()
    print h.help_message()
Пример #20
0
 def get_submodules(self):
     return [UnitTest(), Debug(), Clean(), CleanAll(), Run(), OnDemand(), Standalone(), CI(), Findbugs(),
             ApiCheck(), Idea(), Qunit(), AutoComplete(self.parser), JmakeUnitTest(), Help(self.parser),
             EhMetrics(), EhMetricsInvestigate(), Install(), Clustered(), Postgresql(), Mysql()] + (
             [Manager()] if self.is_manager() else [])
Пример #21
0
from Help import Help
from Taskmaster import Taskmaster


def determinePrefix(bot: commands.Bot, message: discord.Message):
    if isinstance(message.channel, discord.DMChannel):
        if message.content.startswith("bel."):
            return "bel."
        return ""
    else:
        return "bel."


client = commands.Bot(command_prefix=determinePrefix,
                      case_insensitive=True,
                      help_command=Help(verify_checks=False))
cogTask = CogTask(client)
client.add_cog(cogTask)


@client.event
async def on_ready():
    print(f"Logged in as {client.user}.")


@client.event
async def on_message(message: discord.Message):
    if message.author == client.user:
        return

    await client.process_commands(message)
Пример #22
0
 def help(self):
     helpRoot = Tk()
     helpRoot.title("HELP")
     helpApp = Help(helpRoot)
Пример #23
0
 def OnMenuUserHelp(self, event):  # wxGlade: Home.<event_handler>
     help = Help(None, -1, "")
     help.Show()
Пример #24
0
def mainControlFlow():
    while True:
        temp = None
        currCommand = []
        for i in input("Please input a command: \n").split():
            currCommand.append(i)
        if currCommand[0] == 'help':
            temp = Help(currCommand[0])
            temp.execute()
        elif currCommand[0] == 'add':
            if currCommand[1] == 'toRead':
                temp = Add(currCommand[0])
                temp.execute(currCommand[1], currCommand[2])
            elif currCommand[1] == 'currentlyReading':
                temp = Add(currCommand[0])
                temp.execute(currCommand[1], currCommand[2])
            else:
                print("Command not recognized, please type help for more information.")
        elif currCommand[0] == 'list':
            if currCommand[1] == 'genre':
                temp = List(currCommand[0] + currCommand[1])
                temp.execute(currCommand[2])
            elif currCommand[1] == 'toRead':
                temp = List(currCommand[0] + currCommand[1])
                temp.execute(currCommand[1])
            elif currCommand[1] == 'currentlyReading':
                temp = List(currCommand[0] + currCommand[1])
                temp.execute(currCommand[1])
        else:
            print("Command not recognized, please type help for more information.")
Пример #25
0
    def minimax(self, me, enemy, depth, state, alpha, beta):
        helper = Help()
        helper.enemy = self.enemy
        helper.me = self.me

        if (depth == 0 or helper.calc_heurestic2(state, me, enemy) >= 50):
            score = helper.calc_heurestic2(state, me, enemy)
            return score

        if (me == self.me):

            num = me
            chosen_map = None
            max = -9999
            helper2 = Help2()
            children = helper2.make_children(self.me, state)

            for child in children:
                if (me == 1):
                    num = child.control.count(1)

                    num = int(num / 3)

                    if (num < 3):
                        num = 3
                    child.player1Available += num

                else:
                    num = child.control.count(2)
                    num = int(num / 3)
                    if (num < 3):
                        num = 3
                    child.player2Available += num

                next = self.minimax(self.enemy, self.me, depth - 1, child,
                                    alpha, beta)

                if (next > max):
                    max = next
                    child.player1Available -= num
                    chosen_map = helper.deep_copy(child)

                if (next > alpha):
                    alpha = next

                if (alpha >= beta):
                    break

            if (children.__len__() == 0):
                chosen_map = helper.deep_copy(state)
                min = helper.calc_heurestic2(state, me, enemy)

            if (depth == 4):
                return chosen_map

            return max

        if (me == self.enemy):

            num = me
            chosen_map = None
            min = 999999
            helper2 = Help2()
            children = helper2.make_children(self.enemy, state)

            for child in children:
                if (me == 1):
                    num = child.control.count(1)

                    num = int(num / 3)

                    if (num < 3):
                        num = 3
                    child.player1Available += num

                else:
                    num = child.control.count(2)
                    num = int(num / 3)
                    if (num < 3):
                        num = 3
                    child.player2Available += num

                next = self.minimax(self.me, self.enemy, depth - 1, child,
                                    alpha, beta)

                if (next < min):
                    min = next
                    child.player1Available -= num
                    chosen_map = helper.deep_copy(child)

                if (next < beta):
                    beta = next

                if (alpha >= beta):
                    break

            if (children.__len__() == 0):
                chosen_map = helper.deep_copy(state)
                min = helper.calc_heurestic2(state, me, enemy)

            if (depth == 4):
                return chosen_map
            return min
Пример #26
0
 def _parse_fun_h(argv):
     """ Parser function [-h]: print help """
     # Print help
     Help().print_help()
 def createHelp(self, *args, **kwargs):
     h = Help()
     h.createWindow()
Пример #28
0
def print_help():
    h = Help()
    print h.help_message()
Пример #29
0
    def __init__(self):
        Gtk.Window.__init__(self, title="Magic Mirror")

        self.state_list = [
            "HOME", "WEATHER", "TIME", "QUOTE", "CALENDAR", "HELP", "INFO",
            "MIRROR"
        ]
        self.state = ""

        # Data classes which update from subscriber
        input_data = InputData()
        weather_data = WeatherData()
        quote_data = QuoteData()
        calendar_data = EventData()
        message_data = MessageData()
        home_data = HomeData()
        self.auth_data = AuthData()
        pin_data = PinData()

        # Screen objects that are cycled in the window
        self.home_screen = Home(weather_data, calendar_data, home_data,
                                self.auth_data)
        self.auth_screen = Auth(self.auth_data, pin_data)
        self.weather_screen = Weather(weather_data)
        self.time_screen = TimeDate()
        self.message_screen = Messages(message_data)
        self.quote_screen = Quote(quote_data)
        self.calendar_screen = Calendar(calendar_data)
        self.help_screen = Help()
        self.info_screen = Info()
        self.mirror_screen = Mirror()

        # Starts the MQTT subscriber
        self.data_thread = threading.Thread(target=subscriber.run,
                                            args=([
                                                input_data, weather_data,
                                                quote_data, calendar_data,
                                                home_data, self.auth_data,
                                                pin_data
                                            ], ))
        self.data_thread.daemon = True
        self.data_thread.start()

        # Updates the value on the screens in separate threads
        GObject.timeout_add(1000, self.auth_screen.update)
        GObject.timeout_add(1000, self.weather_screen.update_weather)
        GObject.timeout_add(1000, self.time_screen.update_clock)
        GObject.timeout_add(1000, self.quote_screen.update)
        GObject.timeout_add(1000, self.calendar_screen.update_events)
        GObject.timeout_add(1000, self.message_screen.update_screen)
        GObject.timeout_add(1000, self.home_screen.update_home)

        self.app_stack = Gtk.Stack()
        self.app_stack.set_transition_type(
            Gtk.StackTransitionType.SLIDE_LEFT_RIGHT)
        self.app_stack.set_transition_duration(500)

        self.app_stack.add_named(self.auth_screen, "Auth")
        self.app_stack.add_named(self.home_screen, "Home")
        self.app_stack.add_named(self.weather_screen, "Weather")
        self.app_stack.add_named(self.time_screen, "Time")
        self.app_stack.add_named(self.message_screen, "Message")
        self.app_stack.add_named(self.quote_screen, "Quote")
        self.app_stack.add_named(self.calendar_screen, "Calendar")
        self.app_stack.add_named(self.help_screen, "Help")
        self.app_stack.add_named(self.info_screen, "Info")
        self.app_stack.add_named(self.mirror_screen, "Mirror")

        # Meant to add the default screen
        self.add(self.app_stack)

        self.fullscreen()
        self.modify_bg(Gtk.StateType.NORMAL, Gdk.Color(255, 0, 255))
        self.set_icon(IMG.iconpix)
Пример #30
0
 def clickHelp(self):
     self.modApp.help_params = Help.get_params()
Пример #31
0
import sys
import os

cur_dir = os.path.abspath(os.path.dirname(__file__))
sys.path.append(os.path.join(cur_dir, "ImageEditor"))
sys.path.append(os.path.join(cur_dir, "Input"))

from BatchImageEditor import BatchImageEditor
from Args import Args
from BatchJob import BatchJob
from Help import Help

if len(sys.argv) < 2:
    Help.print_help()

args = Args(sys.argv[1:])

options = args.get_options()

job = BatchJob(options)
editor = BatchImageEditor()

editor.process_images(job)
Пример #32
0
    def move(self, num, infoText, listL):

        adj = globals.map.adjacency
        ctrl = globals.map.control
        numList = globals.map.troopNum
        self.me = num
        if (num == 1):
            self.troops = globals.map.player1Available
            self.enemy = 2

        if (num == 2):
            self.troops = globals.map.player2Available
            self.enemy = 1

        helper = Help()

        parent = globals.map

        best_score = 99999999999
        self.cost += 1
        best_children = []
        number = 0
        children = []
        visited = []
        children.append(parent)
        while (1):
            children.remove(parent)
            current_children = helper.make_children(num, parent)

            for mapA in current_children:
                for mapB in visited:
                    if (mapA.control == mapB.control
                            and mapA.troopNum == mapB.troopNum):
                        current_children.remove(mapA)
                        break

            if (current_children.__len__() != 0):
                visited = visited + current_children.copy()
                children = children + current_children.copy()

            if children.__len__() != 0:

                best = helper.best_child(children)
                best_children.append(helper.deep_copy(best))
                score = helper.calc_heurestic(best) + self.cost
            else:
                break

            best_score = score
            parent = best

            if (helper.calc_heurestic(parent) <= -50 or number >= 99):
                break

            number += 1

        parent = helper.best_child(best_children)
        if (parent != None):
            globals.map.troopNum = parent.troopNum.copy()
            globals.map.adjacency = parent.adjacency.copy()
            globals.map.control = parent.control.copy()
            globals.map.player1Available = parent.player1Available
            globals.map.player2Available = parent.player2Available
Пример #33
0
    def loop(self):
        """
        The main loop

        	@param self -- the JogoDoPiano
	    
        """
        sc = Screen()
        screen = sc.getScreen()

        statusBar = Label(10, 805, [(0, 0), (1, 1), (0, 1)])
        statusBarRight = Label(1100, 805, [(0, 0), (1, 1), (0, 1)])
        #statusBar = Label(10, 10, [(0,0), (1,1), (0,1)])

        lampCursor = Cursor("lamp", 0, 0, [(0, 0), (1, 1), (0, 1)])
        earCursor = Cursor("ear", 0, 0, [(0, 0), (1, 1), (0, 1)])
        lamp = Lamp("lamp", 825, 709, [(836, 721), (868, 721), (836, 779),
                                       (868, 779)], lampCursor)
        #lamp = Lamp("lamp", 825, 709, [(0, 0), (0, 20), (20, 20), (20, 0)], lampCursor)
        game = Game()

        buttons = [
            Key("1", -36, 507, [(28, 508), (0, 566), (0, 639), (31, 649),
                                (49, 602), (30, 595), (58, 514)], game),
            Key("2", 31, 510, [(60, 512), (30, 595), (58, 603), (89, 518)],
                game),
            Key("3", 19, 516, [(89, 518), (59, 603), (49, 602), (34, 649),
                               (88, 664), (100, 615), (84, 610), (104, 520)],
                game),
            Key("4", 85, 517, [(106, 520), (84, 610), (113, 615), (133, 524)],
                game),
            Key("5", 75, 524, [(134, 524), (113, 615), (100, 614), (87, 663),
                               (137, 672), (158, 527)], game),
            Key("6", 131, 527, [(160, 527), (138, 671), (196, 677), (200, 624),
                                (184, 621), (196, 532)], game),
            Key("7", 187, 529, [(194, 532), (184, 621), (213, 623),
                                (221, 536)], game),
            Key("8", 190, 535, [(221, 536), (215, 623), (201, 624), (196, 680),
                                (254, 677), (253, 628), (232, 626),
                                (237, 538)], game),
            Key("9", 234, 534, [(236, 536), (232, 625), (263, 626),
                                (262, 539)], game),
            Key("10", 243, 538,
                [(262, 539), (263, 626), (252, 627), (254, 676), (303, 675),
                 (296, 627), (284, 626), (279, 538)], game),
            Key("11", 282, 532, [(279, 538), (285, 625), (312, 625),
                                 (301, 538)], game),
            Key("12", 295, 540, [(302, 540), (312, 625), (297, 627),
                                 (301, 676), (344, 670), (317, 539)], game),
            Key("13", 320, 537, [(317, 539), (344, 671), (389, 662),
                                 (378, 625), (367, 624), (342, 538)], game),
            Key("14", 342, 532, [(342, 538), (367, 623), (387, 621),
                                 (358, 535)], game),
            Key("15", 358, 535,
                [(358, 535), (387, 620), (378, 625), (389, 661), (432, 651),
                 (418, 618), (407, 619), (376, 534)], game),
            Key("16", 377, 526, [(376, 534), (406, 618), (424, 614),
                                 (394, 530)], game),
            Key("17", 393, 529, [(394, 531), (424, 613), (418, 618),
                                 (431, 653), (473, 639), (411, 529)], game),
            Key("18", 413, 524, [(413, 530), (474, 639), (511, 628),
                                 (496, 603), (484, 605), (434, 525)], game),
            Key("19", 436, 516, [(435, 526), (483, 604), (503, 599),
                                 (456, 521)], game),
            Key("20", 455, 520,
                [(455, 522), (503, 599), (496, 603), (511, 629), (548, 615),
                 (532, 592), (522, 593), (474, 520)], game),
            Key("21", 475, 508, [(473, 520), (522, 592), (542, 585),
                                 (493, 514)], game),
            Key("22", 494, 512,
                [(493, 514), (541, 585), (532, 591), (548, 616), (585, 600),
                 (568, 579), (559, 580), (507, 512)], game),
            Key("23", 510, 502, [(508, 512), (559, 580), (577, 574),
                                 (526, 507)], game),
            Key("24", 526, 506, [(527, 508), (577, 574), (569, 582),
                                 (585, 602), (621, 586), (538, 504)], game),
            Key("25", 539, 496, [(538, 504), (622, 588), (661, 571),
                                 (639, 550), (626, 553), (572, 496)], game),
            Key("26", 572, 485, [(572, 496), (627, 553), (644, 546),
                                 (595, 494)], game),
            Key("27", 595, 492,
                [(596, 493), (645, 546), (639, 551), (662, 572), (698, 562),
                 (672, 538), (664, 539), (610, 491)], game),
            Key("28", 611, 481, [(610, 492), (664, 539), (679, 534),
                                 (632, 488)], game),
            Key("29", 632, 488, [(633, 489), (679, 534), (672, 539),
                                 (698, 562), (729, 553), (646, 488)], game),
            Key("30", 647, 485, [(645, 488), (731, 556), (763, 550),
                                 (739, 531), (728, 531), (671, 485)], game),
            Key("31", 672, 478, [(670, 485), (728, 530), (742, 527),
                                 (690, 484)], game),
            Key("32", 690, 483,
                [(693, 484), (742, 528), (739, 532), (763, 551), (796, 545),
                 (778, 530), (769, 529), (714, 482)], game),
            Key("33", 715, 474, [(714, 483), (770, 529), (784, 525),
                                 (734, 481)], game),
            Key("34", 735, 481,
                [(736, 481), (784, 524), (777, 529), (797, 547), (829, 543),
                 (810, 527), (802, 525), (748, 481)], game),
            Key("35", 746, 472, [(749, 481), (802, 525), (817, 521),
                                 (771, 480)], game),
            Key("36", 771, 482, [(773, 481), (818, 522), (810, 527),
                                 (830, 543), (869, 541), (793, 481)], game),
            Key("37", 794, 481, [(793, 481), (869, 540), (902, 539),
                                 (879, 520), (866, 518), (821, 480)], game),
            Key("38", 823, 472, [(820, 480), (866, 519), (881, 516),
                                 (843, 480)], game),
            Key("39", 843, 480,
                [(843, 480), (881, 518), (878, 520), (902, 539), (936, 537),
                 (909, 515), (899, 516), (852, 480)], game),
            Stick("2", _("Aleluia - Handel - 4 notes"), 892,
                  241, [(1022, 330), (1017, 325), (1011, 327), (1005, 319),
                        (1008, 315), (1010, 301), (1008, 296), (1004, 289),
                        (993, 284), (984, 277), (983, 257), (988, 248),
                        (998, 247), (1007, 247), (1013, 249), (1018, 257),
                        (1020, 269), (1016, 277), (1010, 282), (1007, 285),
                        (1009, 295), (1016, 295), (1021, 326)], game),
            Stick("1", _("Silent Night - Christmas Song - 4 notes"), 885,
                  271, [(1006, 343), (1001, 338), (1006, 330), (1000, 322),
                        (994, 325), (984, 324), (976, 319), (970, 308),
                        (973, 296), (982, 288), (992, 285), (1003, 290),
                        (1008, 299), (1009, 309), (1004, 321), (1010, 327),
                        (1017, 325), (1038, 351)], game),
            Stick("3", _("Save me - Hanson - 4 notes"), 917, 222,
                  [(1039, 351), (1027, 338), (1024, 278), (1031, 276),
                   (1030, 265), (1026, 262), (1019, 256), (1015, 246),
                   (1016, 233), (1026, 229), (1036, 226), (1046, 231),
                   (1049, 238), (1049, 252), (1044, 262), (1036, 266),
                   (1037, 276), (1046, 276), (1049, 352), (1037, 352)], game),
            Stick("4", _("Every breath you take - Sting - 5 notes"), 944, 213,
                  [(1050, 233), (1054, 223), (1063, 218), (1071, 218),
                   (1084, 223), (1087, 235), (1083, 247), (1079, 253),
                   (1070, 250), (1061, 249), (1055, 249), (1053, 248)], game),
            Stick("5", _("Aquarela - Toquinho - 6 notes"), 950, 247,
                  [(1061, 353), (1055, 302), (1063, 299), (1062, 289),
                   (1055, 283), (1048, 276), (1047, 263), (1053, 254),
                   (1059, 250), (1070, 250), (1082, 257), (1086, 271),
                   (1081, 278), (1074, 282), (1070, 289), (1070, 299),
                   (1078, 301), (1081, 351)], game),
            Stick("6", _("Wedding March - Felix Mendelssohn - 7 notes"), 969,
                  202, [(1091, 233), (1091, 239), (1094, 248), (1100, 257),
                        (1108, 257), (1116, 257), (1125, 252), (1128, 242),
                        (1129, 234), (1128, 226), (1122, 222), (1111, 219),
                        (1102, 221), (1096, 226)], game),
            Stick("7", _("Amor Maior - Jota Quest - 8 notes"), 977, 251,
                  [(1081, 352), (1079, 324), (1086, 304), (1093, 308),
                   (1097, 296), (1094, 291), (1090, 283), (1089, 275),
                   (1091, 267), (1096, 263), (1104, 261), (1109, 260),
                   (1114, 262), (1119, 266), (1126, 272), (1126, 279),
                   (1124, 290), (1119, 295), (1108, 298), (1102, 299),
                   (1101, 303), (1098, 311), (1105, 313), (1091, 351)], game),
            Stick("8", _("Greenleaves - Anonymous - 9 notes"), 1014, 211,
                  [(1108, 346), (1118, 296), (1124, 292), (1125, 286),
                   (1127, 279), (1127, 274), (1124, 266), (1129, 267),
                   (1133, 257), (1127, 252), (1128, 251), (1129, 242),
                   (1130, 238), (1130, 230), (1128, 222), (1133, 219),
                   (1136, 217), (1144, 217), (1149, 220), (1155, 226),
                   (1158, 234), (1158, 245), (1152, 252), (1143, 258),
                   (1136, 263), (1135, 267), (1133, 271), (1136, 286),
                   (1134, 278), (1138, 291), (1140, 293), (1140, 301),
                   (1132, 301), (1129, 301), (1126, 316), (1120, 328),
                   (1114, 339), (1111, 344)], game),
            Stick("9", _("Velha Infancia - Tribalistas - 5 notes"), 985, 219,
                  [(1113, 344), (1130, 303), (1139, 303), (1143, 294),
                   (1139, 288), (1136, 282), (1135, 273), (1138, 266),
                   (1140, 262), (1146, 259), (1157, 259), (1167, 260),
                   (1170, 269), (1173, 278), (1171, 286), (1165, 293),
                   (1157, 295), (1149, 297), (1148, 298), (1146, 307),
                   (1151, 309), (1139, 339), (1113, 345)], game),
            Stick("10", _("Jingle Bells - Christmas Song - 11 notes"), 883,
                  496, [(1009, 604), (1002, 560), (1009, 558), (1009, 547),
                        (1004, 545), (996, 543), (991, 533), (990, 526),
                        (995, 513), (997, 510), (1007, 507), (1016, 507),
                        (1021, 511), (1025, 518), (1027, 528), (1024, 536),
                        (1019, 545), (1014, 546), (1014, 557), (1023, 557),
                        (1028, 609)], game),
            Stick("11", _("Habanera - Georges Bizet - 8 notes"), 927, 479,
                  [(1039, 612), (1034, 536), (1040, 533), (1040, 521),
                   (1034, 519), (1029, 515), (1024, 509), (1024, 499),
                   (1026, 490), (1030, 487), (1039, 485), (1048, 484),
                   (1059, 490), (1062, 498), (1062, 509), (1056, 515),
                   (1047, 521), (1046, 523), (1047, 534), (1054, 534),
                   (1059, 612)], game),
            Stick("12", _("Yellow Submarine - Beatles - 10 notes"), 954, 497,
                  [(1060, 609), (1059, 589), (1062, 571), (1066, 552),
                   (1071, 551), (1074, 541), (1068, 537), (1062, 526),
                   (1064, 513), (1071, 504), (1085, 503), (1087, 504),
                   (1096, 512), (1099, 520), (1096, 532), (1089, 539),
                   (1080, 543), (1078, 553), (1086, 556), (1074, 614)], game),
            Stick("13",
                  _("Jesu, Joy of Man's Desiring - J. S. Bach - 12 notes"),
                  995, 495,
                  [(1087, 612), (1105, 549), (1113, 550), (1114, 538),
                   (1110, 533), (1104, 522), (1105, 515), (1112, 506),
                   (1118, 504), (1126, 501), (1134, 503), (1139, 509),
                   (1143, 519), (1139, 533), (1129, 541), (1122, 543),
                   (1117, 553), (1126, 554), (1108, 608)], game),
            Stick("14", _("Symphony No. 9 - Beethoven - 15 notes"), 1027, 515,
                  [(1113, 605), (1133, 566), (1138, 569), (1145, 560),
                   (1142, 551), (1139, 544), (1139, 536), (1145, 529),
                   (1152, 525), (1160, 526), (1169, 529), (1176, 539),
                   (1174, 553), (1169, 560), (1158, 565), (1151, 564),
                   (1146, 572), (1151, 578), (1138, 600)], game), lampCursor,
            earCursor, lamp, statusBar, statusBarRight
        ]

        helps = [
            Help("re", 370, 500, [(0, 0), (1, 1), (0, 1)]),
            Help("re_sust", 380, 458, [(0, 0), (1, 1), (0, 1)]),
            Help("mi", 415, 490, [(0, 0), (1, 1), (0, 1)]),
            Help("fa", 450, 478, [(0, 0), (1, 1), (0, 1)]),
            Help("fa_sust", 455, 435, [(0, 0), (1, 1), (0, 1)]),
            Help("sol", 490, 470, [(0, 0), (1, 1), (0, 1)]),
            Help("sol_sust", 490, 425, [(0, 0), (1, 1), (0, 1)]),
            Help("la", 525, 460, [(0, 0), (1, 1), (0, 1)]),
            Help("la_sust", 530, 417, [(0, 0), (1, 1), (0, 1)]),
            Help("si", 565, 445, [(0, 0), (1, 1), (0, 1)]),
            Help("do", 595, 430, [(0, 0), (1, 1), (0, 1)]),
            Help("do_sust", 600, 395, [(0, 0), (1, 1), (0, 1)]),
            Help("re", 640, 420, [(0, 0), (1, 1), (0, 1)]),
            Help("re_sust", 630, 380, [(0, 0), (1, 1), (0, 1)]),
            Help("mi", 675, 405, [(0, 0), (1, 1), (0, 1)]),
            Help("fa", 708, 402, [(0, 0), (1, 1), (0, 1)]),
            Help("fa_sust", 695, 370, [(0, 0), (1, 1), (0, 1)]),
            Help("sol", 742, 398, [(0, 0), (1, 1), (0, 1)])
        ]

        game.setButtons(buttons, helps)

        stones = [
            Stone("stone", 115, 187, [(116, 188), (159, 188), (159, 234),
                                      (116, 234)], game),
            Stone("stone", 163, 187, [(164, 188), (207, 188), (207, 234),
                                      (164, 234)], game),
            Stone("stone", 211, 187, [(212, 188), (255, 188), (255, 234),
                                      (212, 234)], game),
            Stone("stone", 259, 187, [(260, 188), (303, 188), (303, 234),
                                      (260, 234)], game),
            Stone("stone", 307, 187, [(308, 188), (351, 188), (351, 234),
                                      (308, 234)], game),
            Stone("stone", 355, 187, [(356, 188), (399, 188), (399, 234),
                                      (356, 234)], game),
            Stone("stone", 403, 187, [(404, 188), (447, 188), (447, 234),
                                      (404, 234)], game),
            Stone("stone", 451, 187, [(452, 188), (495, 188), (495, 234),
                                      (452, 234)], game),
            Stone("stone", 498, 187, [(500, 188), (543, 188), (543, 234),
                                      (500, 234)], game),
            Stone("stone", 546, 187, [(548, 188), (591, 188), (591, 234),
                                      (548, 234)], game),
            Stone("stone", 594, 187, [(596, 188), (639, 188), (639, 234),
                                      (596, 234)], game),
            Stone("stone", 642, 187, [(644, 188), (687, 188), (687, 234),
                                      (644, 234)], game),
            Stone("stone", 690, 187, [(692, 188), (735, 188), (735, 234),
                                      (692, 234)], game),
            Stone("stone", 738, 187, [(740, 188), (783, 188), (783, 234),
                                      (740, 234)], game),
            Stone("stone", 786, 187, [(788, 188), (831, 188), (831, 234),
                                      (788, 234)], game)
        ]

        animation = [
            Ball("bar", 80, 287, [(0, 0), (1, 1), (0, 1)], game),
            Ball("redBall", 10, 247, [(8, 247), (100, 247), (100, 338),
                                      (8, 338)], game),
            Ball("greenBall", 10, 247, [(8, 247), (100, 247), (100, 338),
                                        (8, 338)], game),
            Ball("blueBall", 10, 247, [(8, 247), (100, 247), (100, 338),
                                       (8, 338)], game),
            Ball("yellowBall", 10, 247, [(8, 247), (100, 247), (100, 338),
                                         (8, 338)], game),
            Ball("rightBall", 850, 267, [(0, 0), (1, 1), (0, 1)], game)
        ]

        game.addChallenge(
            Challenge("noitefeliz", [20, 22, 20, 17], buttons[40], stones,
                      [5, 7, 5, 2], animation[1], animation[0], animation[5],
                      "easy", game))
        game.addChallenge(
            Challenge("aleluia", [27, 22, 24, 22], buttons[39], stones,
                      [12, 7, 9, 7], animation[3], animation[0], animation[5],
                      "easy", game))
        game.addChallenge(
            Challenge("saveme", [16, 17, 24, 17], buttons[41], stones,
                      [1, 2, 9, 2], animation[2], animation[0], animation[5],
                      "easy", game))
        game.addChallenge(
            Challenge("everybreath", [26, 27, 26, 24, 22], buttons[42], stones,
                      [11, 12, 11, 9, 7], animation[3], animation[0],
                      animation[5], "easy", game))
        game.addChallenge(
            Challenge("aquarela", [15, 15, 20, 20, 19, 17], buttons[43],
                      stones, [0, 0, 5, 5, 4, 2], animation[4], animation[0],
                      animation[5], "easy", game))
        game.addChallenge(
            Challenge("marchanupcial", [25, 24, 19, 22, 20, 18, 15],
                      buttons[44], stones, [10, 9, 4, 7, 5, 3, 0],
                      animation[1], animation[0], animation[5], "easy", game))
        game.addChallenge(
            Challenge("amormaior", [22, 23, 22, 25, 27, 22, 20, 18],
                      buttons[45], stones, [7, 8, 7, 10, 12, 7, 5, 3],
                      animation[2], animation[0], animation[5], "easy", game))
        game.addChallenge(
            Challenge("greenleaves", [17, 20, 22, 24, 25, 24, 22, 19, 15],
                      buttons[46], stones, [], animation[4], animation[0],
                      animation[5], "easy", game))
        game.addChallenge(
            Challenge("velhainfancia", [19, 22, 19, 22, 29], buttons[47],
                      stones, [4, 7, 4, 7, 14], animation[1], animation[0],
                      animation[5], "easy", game))
        game.addChallenge(
            Challenge("jinglebells",
                      [24, 24, 24, 24, 24, 24, 24, 27, 20, 22, 24],
                      buttons[48], stones, [9, 9, 9, 9, 9, 9, 9, 12, 5, 7, 9],
                      animation[1], animation[0], animation[5], "difficult",
                      game))
        game.addChallenge(
            Challenge("habanera", [27, 26, 25, 25, 25, 24, 23, 22],
                      buttons[49], stones, [12, 11, 10, 10, 10, 9, 8, 7],
                      animation[2], animation[0], animation[5], "difficult",
                      game))
        game.addChallenge(
            Challenge("yellow", [27, 27, 27, 27, 29, 24, 22, 22, 22, 22],
                      buttons[50], stones, [12, 12, 12, 12, 14, 9, 7, 7, 7, 7],
                      animation[3], animation[0], animation[5], "difficult",
                      game))
        game.addChallenge(
            Challenge("jesusalegria",
                      [20, 22, 24, 27, 25, 25, 29, 27, 27, 32, 31, 32],
                      buttons[51], stones,
                      [5, 7, 9, 12, 10, 10, 14, 12, 12, 17, 16, 17],
                      animation[0], animation[4], animation[5], "difficult",
                      game))
        game.addChallenge(
            Challenge(
                "nonasinfonia",
                [19, 19, 20, 22, 22, 20, 19, 17, 15, 15, 17, 19, 19, 17, 17],
                buttons[52], stones,
                [4, 4, 5, 7, 7, 5, 4, 2, 0, 0, 2, 4, 4, 2, 2], animation[3],
                animation[0], animation[5], "difficult", game))

        keyboard = pygame.image.load("image/keyboard.png")

        bigBar = pygame.image.load("image/bigBar.png")
        bigBar.set_alpha(None)  # disable alpha.
        bigBar.convert()
        bigBar.set_colorkey((255, 0, 255))  # magenta

        frame = pygame.image.load("image/frame.png")
        frame.set_alpha(None)  # disable alpha.
        frame.convert()
        frame.set_colorkey((255, 0, 255))  # magenta

        bucket1 = pygame.image.load("image/bucket1.png")
        bucket1.set_alpha(None)  # disable alpha.
        bucket1.convert()
        bucket1.set_colorkey((255, 0, 255))  # magenta

        bucket2 = pygame.image.load("image/bucket2.png")
        bucket2.set_alpha(None)  # disable alpha.
        bucket2.convert()
        bucket2.set_colorkey((255, 0, 255))  # magenta

        clock = pygame.time.Clock()
        FPS = 20

        while self.run:
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    sys.exit()
                else:
                    for button in buttons:
                        button.parseEvent(event)
                    for stone in stones:
                        stone.parseEvent(event)
                    for help in helps:
                        help.parseEvent(event)
                    for thing in animation:
                        thing.parseEvent(event)
                    if event.type == MOUSEMOTION:
                        posicao = (event.pos[0], event.pos[1])
                        #pygame.display.set_caption(str(posicao[0])+" x "+str(posicao[1]))

            screen.blit(keyboard, (0, -1))

            for button in buttons:
                button.draw(screen)

            for stone in stones:
                stone.draw(screen)

                for thing in animation:
                    thing.draw(screen)

            screen.blit(frame, (-39, 470))
            screen.blit(bigBar, (114, 274))

            for help in helps:
                help.draw(screen)

            screen.blit(bucket1, (988, 338))
            screen.blit(bucket2, (987, 597))

            lampCursor.draw(screen)
            earCursor.draw(screen)

            #update the surface in the screen
            pygame.display.flip()

            #control number of frames per second
            clock.tick(FPS)