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
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
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
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")
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
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
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
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
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)
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
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
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
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
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
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
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
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...")
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
def print_help():
h = Help()
print h.help_message()
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 [])
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)
def help(self):
helpRoot = Tk()
helpRoot.title("HELP")
helpApp = Help(helpRoot)
def OnMenuUserHelp(self, event): # wxGlade: Home.<event_handler>
help = Help(None, -1, "")
help.Show()
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.")
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
def _parse_fun_h(argv):
""" Parser function [-h]: print help """
# Print help
Help().print_help()
def createHelp(self, *args, **kwargs):
h = Help()
h.createWindow()
def print_help():
h = Help()
print h.help_message()
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)
def clickHelp(self):
self.modApp.help_params = Help.get_params()
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)
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
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)
