Ejemplo n.º 1
0
	def select_random_differences(self) :

		# the differences which will have to be found by the user
		self.differences_to_find = []

		# the differences which will be masked (copy the rect from the original image)
		self.differences_to_mask = []

		self.differences = common.randomize_list(self.differences)
		
		self.amount_differences = self.min_differences + random.randint(0, self.max_differences-self.min_differences)

		if (len(self.differences) < self.amount_differences) :
			common.error("Not enough differences available. Please check your XML setup : the value of the 'max_differences' tag is too high.")

			raise common.BadXMLException()


		for i in range(self.amount_differences) :

			difference = self.differences[0]

			self.differences.remove(self.differences[0])

			self.differences_to_find.append(difference)

		# at this point, only differences which have to be masked are yet in the self.differences list
		self.differences_to_mask = self.differences
Ejemplo n.º 2
0
    def __init__(self, game, score):

        self.globalvars = game.globalvars

        # creation of a new game
        common.Game.__init__(self, self.globalvars, game.xml_game_node,
                             game.level, score)

        self.score.enable_record_time()

        if (self.xml_game_node != None):

            # reading global parameters
            xml_global_parameters_node = self.xml_game_node.getElementsByTagName(
                "global_parameters")[0]

            # the amount of identical cards to find
            self.amount_identical_cards = xml_funcs.getInt(
                xml_global_parameters_node.getElementsByTagName(
                    "identical_cards")[0])

            # Grid setup
            grid_node = xml_global_parameters_node.getElementsByTagName(
                "grid")[0]

            self.grid_box = xml_funcs.get_box(grid_node)

            self.grid_amount_x = xml_funcs.getInt(
                grid_node.getElementsByTagName("amount_x")[0])
            self.grid_amount_y = xml_funcs.getInt(
                grid_node.getElementsByTagName("amount_y")[0])

            self.amount_different_cards = int(
                (1.0 * self.grid_amount_x * self.grid_amount_y) /
                self.amount_identical_cards)

            if (self.amount_different_cards != round(
                    self.amount_different_cards)):
                common.error(
                    "the amount of cards is not a multiple of the amount of cards to group"
                )
                raise common.BadXMLException()

            spacing_x_nodes = grid_node.getElementsByTagName("spacing_x")
            spacing_y_nodes = grid_node.getElementsByTagName("spacing_y")

            if (len(spacing_x_nodes) > 0):
                self.spacing_x = xml_funcs.getFloat(spacing_x_nodes[0])
            else:
                self.spacing_x = 0

            if (len(spacing_y_nodes) > 0):
                self.spacing_y = xml_funcs.getFloat(spacing_y_nodes[0])
            else:
                self.spacing_y = 0

            # card setup
            card_node = xml_global_parameters_node.getElementsByTagName(
                "card")[0]

            front_card_node = card_node.getElementsByTagName("front")[0]
            self.front_card_file = xml_funcs.getText(front_card_node)

            back_card_node = card_node.getElementsByTagName("back")[0]
            self.back_card_file = xml_funcs.getText(back_card_node)

            image_area_nodes = xml_global_parameters_node.getElementsByTagName(
                "image_area")
            if (len(image_area_nodes) > 0):
                image_area_node = image_area_nodes[0]

                ratio_x_node = image_area_node.getElementsByTagName(
                    "ratio_x")[0]
                self.ratio_x = xml_funcs.getFloat(ratio_x_node)

                ratio_y_node = image_area_node.getElementsByTagName(
                    "ratio_y")[0]
                self.ratio_y = xml_funcs.getFloat(ratio_y_node)
            else:
                self.ratio_x = 100.0
                self.ratio_y = 100.0

            # reading associations
            # (here, only images with associated sounds are supported)

            associations_node = self.xml_game_node.getElementsByTagName(
                "associations")[0]

            associations = associations_node.getElementsByTagName(
                "association")

            self.associations = []

            for association_node in associations:

                association = Association(self)

                image_nodes = association_node.getElementsByTagName("image")

                for image_node in image_nodes:

                    image_filename = xml_funcs.getText(image_node)

                    association.images.append(image_filename)

                    sound_nodes = image_node.getElementsByTagName("sound")

                    for sound_node in sound_nodes:
                        association.append_image_sound(
                            image_filename, xml_funcs.getText(sound_node))

                self.associations.append(association)

            if (len(self.associations) < self.amount_different_cards):
                common.error("The XML file contains " +
                             str(len(self.associations)) + " associations")
                common.error("But at least " +
                             str(self.amount_different_cards) +
                             " associations are required")
                raise common.BadXMLException()

            self.associations = common.randomize_list(self.associations)
Ejemplo n.º 3
0
    def get_random_associations(self):

        # we position images and texts which might be displayed
        # (in case there would be more than one in some associations)
        for association in self.associations:
            association.select_random_items()

        # the amount of draggable items will be a random value between min_draggable and max_draggable
        if (self.score.get_arcade_mode() == False):
            amount_draggable = self.min_draggable + random.randint(
                0, self.max_draggable - self.min_draggable)
        else:
            # in arcade mode, we force the maximum amount of drag objects
            amount_draggable = self.max_draggable

        # taking a random association
        # those will be the "good" answers
        good_associations = []

        if (cmp(self.type_to_associate, "image_on_map") == 0):
            goals_to_find = amount_draggable

        else:
            goals_to_find = len(self.goals)

        for i in range(goals_to_find):

            for association in self.associations:
                if (association.done == False):
                    if (association not in good_associations):
                        good_associations.append(association)

                        break
            else:
                # if all the associations were found, there's nothing more to associate !

                common.info(
                    "Not enough associations left to find. Activity ended")

                return (None, None)

        # select other "wrong" associations

        all_associations = copy.copy(good_associations)

        for i in range(amount_draggable - len(self.goals)):

            found = False

            if (len(all_associations) >= len(self.associations)):
                # we won't be able to find other associations (all are already selected)
                # so we have to stop, to avoid an infinite while loop below
                common.info(
                    "Not enough associations available for 'bad' choices.")
                common.info(
                    "Please check your xml file to add more associations or lower 'max_draggable' parameter"
                )

                return (None, None)

            while (found == False):
                other_association = self.associations[random.randint(
                    0,
                    len(self.associations) - 1)]

                if (other_association not in all_associations):
                    all_associations.append(other_association)

                    found = True

        # eventually sorting the entries
        if (self.sort == True):
            all_associations.sort()
        else:
            all_associations = common.randomize_list(all_associations)

        return (good_associations, all_associations)
Ejemplo n.º 4
0
    def __init__(self, game, main_language, score):

        xml_game_node = game.xml_game_node

        self.globalvars = game.globalvars

        # here we create a new game object to play with
        # thus the original game won't be altered

        common.Game.__init__(self, self.globalvars, xml_game_node, game.level,
                             score)

        self.score.enable_count_good()
        self.score.enable_count_wrong()
        self.score.enable_record_time()

        self.xml_game_node = xml_game_node

        # reading global parameters
        xml_global_parameters_node = self.xml_game_node.getElementsByTagName(
            "global_parameters")[0]

        # first of all, game setup
        xml_game_setup_node = self.xml_game_node.getElementsByTagName(
            "game_setup")[0]

        # possible values for types :
        # image
        # image_on_map (only to associate)
        # text
        self.type_to_associate = xml_funcs.getText(
            xml_game_setup_node.getElementsByTagName("type_to_associate")[0])

        type_to_drag_node = xml_game_setup_node.getElementsByTagName(
            "type_to_drag")[0]

        self.type_to_drag = xml_funcs.getText(type_to_drag_node)
        sort = type_to_drag_node.getAttribute("sort")

        if (sort == None):
            self.sort = False
        elif (cmp(sort.lower(), "yes") == 0):
            self.sort = True
        else:
            self.sort = False

        # the min and max amounts of associations (good + bad ones) which will become draggable items
        self.min_draggable = xml_funcs.getInt(
            xml_game_setup_node.getElementsByTagName("min_draggable")[0])
        self.max_draggable = xml_funcs.getInt(
            xml_game_setup_node.getElementsByTagName("max_draggable")[0])

        item_to_associate_parameters_nodes = xml_global_parameters_node.getElementsByTagName(
            "item_to_associate")

        self.item_to_associate_parameters = []
        for item_to_associate_parameters_node in item_to_associate_parameters_nodes:
            self.item_to_associate_parameters.append(
                xml_funcs.get_box(item_to_associate_parameters_node))

        draggable_items_area_nodes = xml_global_parameters_node.getElementsByTagName(
            "draggable_items_area")
        self.draggable_items_areas = []

        for draggable_items_area_node in draggable_items_area_nodes:

            spacing_x_nodes = draggable_items_area_node.getElementsByTagName(
                "spacing_x")
            spacing_y_nodes = draggable_items_area_node.getElementsByTagName(
                "spacing_y")

            if (len(spacing_x_nodes) > 0):
                spacing_x = xml_funcs.getFloat(spacing_x_nodes[0])
            else:
                spacing_x = 0

            if (len(spacing_y_nodes) > 0):
                spacing_y = xml_funcs.getFloat(spacing_y_nodes[0])
            else:
                spacing_y = 0

            draggable_items_area = (
                xml_funcs.get_box(draggable_items_area_node),
                xml_funcs.getInt(
                    draggable_items_area_node.getElementsByTagName("amount_x")
                    [0]),
                xml_funcs.getInt(
                    draggable_items_area_node.getElementsByTagName("amount_y")
                    [0]), spacing_x, spacing_y)

            # TODO: make this under each area

            text_height_nodes = draggable_items_area_node.getElementsByTagName(
                "font_height")
            if (len(text_height_nodes) > 0):
                self.text_height = xml_funcs.getInt(text_height_nodes[0])
            else:
                self.text_height = None

            self.draggable_items_areas.append(draggable_items_area)

        # global placeholders where to drag items
        # only present for non-map associations
        goal_nodes = xml_global_parameters_node.getElementsByTagName("goal")

        self.goals = []
        for goal_node in goal_nodes:

            goal = Goal(goal_node)

            self.goals.append(goal)

        # space to display text legends
        text_legend_nodes = xml_global_parameters_node.getElementsByTagName(
            "text_legend_area")

        if (len(text_legend_nodes) > 0):
            self.text_legend_area = xml_funcs.get_box(text_legend_nodes[0])
        else:
            self.text_legend_area = None

        # Map information (only present if type_to_associate is "on_map")
        map_nodes = xml_global_parameters_node.getElementsByTagName("map")

        if (len(map_nodes) > 0):
            map_node = map_nodes[0]

            (self.map_pos, self.map_size) = xml_funcs.get_box(map_node)

            map_filenames = map_node.getElementsByTagName("image")

            self.map_filename = xml_funcs.getText(map_filenames[0])

        # reading associations

        associations_node = self.xml_game_node.getElementsByTagName(
            "associations")[0]

        associations = associations_node.getElementsByTagName("association")

        self.associations = []

        for association_node in associations:

            association = Association(self)

            image_nodes = association_node.getElementsByTagName("image")

            for image_node in image_nodes:

                if (image_node.parentNode == association_node):
                    # we ignore images which are not direct children
                    # of the association (ie: images inside goal for instance)

                    image_filename = xml_funcs.getText(image_node)

                    if (cmp(image_node.getAttribute("type"), "") == 0):
                        if (cmp(self.type_to_associate, "image") == 0):
                            association.images_to_associate.append(
                                image_filename)
                        if (cmp(self.type_to_drag, "image") == 0):
                            association.images_to_drag.append(image_filename)

                    elif (cmp(image_node.getAttribute("type"),
                              "to_associate") == 0):
                        if ((cmp(self.type_to_associate, "image") == 0)
                                or (cmp(self.type_to_associate, "image_on_map")
                                    == 0)):
                            association.images_to_associate.append(
                                image_filename)

                            if (cmp(self.type_to_associate,
                                    "image_on_map") == 0):
                                association.image_to_associate_pos_size = xml_funcs.get_box(
                                    image_node)

                        else:
                            common.warn(
                                image_filename +
                                " is supposed to be associated, but the game is not supposed to associate images"
                            )

                    elif (cmp(image_node.getAttribute("type"),
                              "to_drag") == 0):
                        if ((cmp(self.type_to_drag, "image") == 0) or (cmp(
                                self.type_to_associate, "image_on_map") == 0)):
                            association.images_to_drag.append(image_filename)
                        else:
                            common.warn(
                                image_filename +
                                " is supposed to be dragged and dropped, but the game is not supposed to drag an drop images"
                            )

                    # find potential associated sounds

                    sound_nodes = image_node.getElementsByTagName("sound")

                    for sound_node in sound_nodes:
                        sound_node_lang = sound_node.getAttribute("lang")

                        if ((cmp(sound_node_lang, "") == 0)
                                or (cmp(sound_node_lang, main_language) == 0)):

                            association.append_image_sound(
                                image_filename, xml_funcs.getText(sound_node))

                    # find potential associated text legends
                    # only texts with no lang tag or with lang tag = main_language are used
                    text_legend_nodes = image_node.getElementsByTagName("text")

                    for text_legend_node in text_legend_nodes:

                        if ((cmp(text_legend_node.getAttribute("lang"),
                                 main_language) == 0)
                                or (cmp(text_legend_node.getAttribute("key"),
                                        "") != 0)):

                            association.append_image_text_legend(
                                image_filename,
                                xml_funcs.getText(text_legend_node,
                                                  self.i18n_dict,
                                                  main_language))

            text_nodes = association_node.getElementsByTagName("text")

            for text_node in text_nodes:

                if (text_node.parentNode == association_node):

                    text_lang = text_node.getAttribute("lang")

                    text_should_be_added = False

                    if (text_lang == ""):
                        # if no lang attribute defined, the text is included
                        text_should_be_added = True
                    else:
                        # if there is a lang attribute, we add the text only
                        # if this language is the main language
                        if (cmp(text_lang, main_language) == 0):
                            text_should_be_added = True

                        # the text node might be a dictionary key, in this case we also add it :
                        if (cmp(text_node.getAttribute("key"), "") != 0):
                            text_should_be_added = True

                    if (text_should_be_added == True):

                        text = xml_funcs.getText(text_node, self.i18n_dict,
                                                 main_language)

                        association.texts.append(text)

                        sound_nodes = text_node.getElementsByTagName("sound")

                        for sound_node in sound_nodes:

                            sound_node_lang = sound_node.getAttribute("lang")

                            if ((cmp(sound_node_lang, "") == 0) or
                                (cmp(sound_node_lang, main_language) == 0)):

                                association.append_text_sound(
                                    text, xml_funcs.getText(sound_node))

            # goals local to only one association

            goal_nodes = association_node.getElementsByTagName("goal")

            if (len(goal_nodes) > 0):

                # TODO : allow for more than a goal ?
                goal_node = goal_nodes[0]

                if (cmp(self.type_to_associate, "image_on_map") == 0):

                    goal = Goal(goal_node)

                    # TODO : remove from here ?
                    self.goals.append(goal)

                    # TODO : put more than one goal
                    association.associated_goal = goal

                else:
                    common.warn(
                        "<goal> found inside an association whereas type to associate is not image_on_map"
                    )

            self.associations.append(association)

        self.associations = common.randomize_list(self.associations)
Ejemplo n.º 5
0
	def find_tuxes(self) :

		tuxes = common.get_files(constants.folder_award_tuxes, constants.image_extensions)
		
		self.tuxes = common.randomize_list(tuxes)
Ejemplo n.º 6
0
    def __init__(self, globalvars):

        common.Run_Screen.__init__(self, globalvars)

        tag_defs = common.load_tag_defs()

        self.current_page = Page_menu(globalvars, tag_defs)

        self.current_page.draw_back()
        pygame.display.flip()

        common.start_music(constants.default_music_files, globalvars)

        common.info("Looking for xml activities")
        for data_folder in constants.data_folders:
            self.current_page.games_list.append_from_folder(data_folder)

        common.info("Initialize igloo")
        self.current_page.igloo_page = igloo.create(self.globalvars)

        common.info("Display main menu")
        self.current_page.display_main_menu()

        self.current_page.draw()
        pygame.display.flip()

        main_page = self.current_page

        level = None

        while self.running:

            try:

                common.Run_Screen.run_pre(self)

            except common.EndActivityException, e:

                # although we should normally end after an EndActivityException,
                # here we'll ask for user confirmation
                self.running = True

                if (cmp(self.current_page.page_type, "MAIN") == 0):

                    self.dirty_rects = self.current_page.display_quit()

                elif (cmp(self.current_page.page_type, "SELECT_LEVEL") == 0):

                    self.mouse_clicked = False

                    self.current_page = main_page
                    self.current_page.draw()

                    self.dirty_rects = [self.screen.get_rect()]

                else:

                    self.dirty_rects = self.current_page.display_main_menu()

                    self.current_page.draw()

            if (self.mouse_clicked == True):
                clicked = self.current_page.was_something_clicked(
                    self.mouse_pos, self.mousebutton)

                if (clicked != None):
                    (component_clicked, foo, some_dirty_rects) = clicked

                    self.dirty_rects = self.dirty_rects + some_dirty_rects

                    if (component_clicked != None):
                        # we try to play an associated sound (if any)
                        component_clicked.play_random_associated_sound()

                    if (cmp(self.current_page.page_type,
                            "DIALOG_BOX_QUIT") == 0):
                        if (component_clicked == self.current_page.quit_yes):
                            self.running = False

                        elif (component_clicked == self.current_page.quit_no):

                            self.dirty_rects = self.current_page.display_main_menu(
                            )

                            self.current_page.draw()

                            self.mouse_clicked = False

                    elif (cmp(self.current_page.page_type, "MAIN") == 0):

                        if (component_clicked == self.current_page.igloo_image
                            ):

                            self.current_page.run_igloo(False)

                            self.mouse_clicked = False

                            self.current_page = main_page

                            self.current_page.draw()

                            self.dirty_rects = [self.screen.get_rect()]

                        elif (component_clicked ==
                              self.current_page.language_image):

                            # changing main language

                            self.current_page.remove_all()

                            index_lang = constants.supported_languages.index(
                                self.current_page.language)

                            index_lang = index_lang + 1

                            if (index_lang >= len(
                                    constants.supported_languages)):
                                index_lang = 0

                            self.current_page.language = constants.supported_languages[
                                index_lang]

                            self.globalvars.main_language = constants.supported_languages[
                                index_lang]

                            self.dirty_rects = self.current_page.display_main_menu(
                            )

                            self.current_page.draw()

                            self.mouse_clicked = False

                        elif (component_clicked == self.current_page.quit_icon
                              ):

                            self.dirty_rects = self.current_page.display_quit()

                            self.mouse_clicked = False

                        elif (component_clicked
                              in self.current_page.tag_icons):

                            # TODO : allow multiple activities inside a game_set !

                            tag_icon = component_clicked
                            tag_def = tag_icon.associated_object

                            self.current_page.games_to_display = self.current_page.games_list.get_games_by_tag_and_language(
                                tag_def.tag, self.current_page.language)

                            self.dirty_rects = self.current_page.display_games_by_type(
                            )

                            self.mouse_clicked = False

                        elif (component_clicked ==
                              self.current_page.options_icon):

                            self.current_page.fade_out()

                            options.Run_options(globalvars)

                            self.current_page.draw()

                            pygame.display.flip()

                            self.mouse_clicked = False

                    elif (cmp(self.current_page.page_type,
                              "GAME_SELECTION") == 0):

                        if (component_clicked == self.current_page.go_back_icon
                            ):
                            self.current_page.fade_out()

                            self.dirty_rects = self.current_page.display_main_menu(
                            )
                            self.current_page.draw()

                            self.mouse_clicked = False

                        else:
                            game_set = component_clicked.associated_object

                            if (game_set != None):

                                # TODO allow more levels !!!!
                                levels = game_set.levels

                                if (len(levels) > 1):

                                    level_page = Page_level(
                                        globalvars, self.current_page.
                                        second_background_image)

                                    self.current_page = level_page

                                    self.dirty_rects = self.current_page.select_level(
                                        levels)

                                    self.mouse_clicked = False

                                else:
                                    # in case we have a single level activity
                                    level = levels[0]

                    elif (cmp(self.current_page.page_type,
                              "SELECT_LEVEL") == 0):

                        if (component_clicked == self.current_page.go_back_icon
                            ):

                            # TODO : a implementer !!!

                            self.mouse_clicked = False

                            self.current_page = main_page
                            self.current_page.draw()

                            self.dirty_rects = [self.screen.get_rect()]

                        else:
                            associated_object = component_clicked.associated_object

                            if (associated_object != None):

                                self.current_page.fade_out()

                                # TODO allow more levels !!!!
                                level = associated_object

            else:
                # mouse is not clicked
                # but it may be going over elements

                (mouse_over_new,
                 mouse_over_old) = self.current_page.components_mouse_over(
                     pygame.mouse.get_pos())

                if (mouse_over_old != None):
                    self.dirty_rects = self.dirty_rects + self.current_page.remove_legend_text(
                    )

                if (mouse_over_new != None):
                    self.dirty_rects = self.dirty_rects + self.current_page.add_legend_text(
                        mouse_over_new)

            if (level != None):

                # then we'll go back to main page when game or highscore will end
                self.current_page = main_page

                if (self.mousebutton == 3):

                    # right click means start highscore screen

                    self.current_page.run_highscore(level)

                    self.mouse_clicked = False

                else:

                    self.current_page.fade_out()

                    # the level is copied in order to change its variables
                    copy_level = copy.copy(level)

                    # shuffle the games
                    copy_level.games = common.randomize_list(
                        copy.copy(copy_level.games))

                    amount_games_played = 0

                    try:

                        total_score = common.Score(globalvars)

                        for game in copy_level.games:

                            if (amount_games_played <
                                    copy_level.game_rounds_amount):

                                if (cmp(game.game_type, "associate") == 0):
                                    # association
                                    run_activity = associate.Run_Associate(
                                        game, globalvars, total_score)

                                if (cmp(game.game_type, "puzzle") == 0):
                                    # puzzle
                                    run_activity = puzzle.Run_Puzzle_Screen(
                                        game, globalvars, total_score)

                                if (cmp(game.game_type, "memory_cards") == 0):
                                    # memory cards
                                    run_activity = memory_cards.Run_Memory_Cards_Screen(
                                        game, globalvars, total_score)

                                if (cmp(game.game_type, "differences") == 0):
                                    # differences
                                    run_activity = differences.Run_Differences_Screen(
                                        game, globalvars, total_score)

                                if (cmp(game.game_type, "transform") == 0):
                                    # image transformation
                                    run_activity = transform.Run_Transform_Screen(
                                        game, globalvars)

                                if (cmp(game.game_type, "learning") == 0):
                                    # learning cards
                                    run_activity = learning.Run_Learning_Screen(
                                        game, globalvars)

                                amount_games_played = amount_games_played + 1

                            else:
                                # if all the games were played, there's nothing more to play !

                                common.info(
                                    "Not enough games left to play. Level completed."
                                )

                        if (pygame.mixer.music.get_busy() == False):
                            common.start_music(constants.default_music_files,
                                               globalvars)

                        # we go to the highscore screen, if activated and if some score was indeed recorded
                        if ((total_score.get_arcade_mode() == True)
                                and (self.globalvars.highscore == True)):
                            self.current_page.run_highscore(
                                copy_level, total_score)

                        # After a completed game_set, we get a Tux as a reward
                        # (only in case the display_igloo global var is True
                        if (self.globalvars.display_igloo == True):
                            self.current_page.run_igloo(True)

                        self.dirty_rects = []

                    except common.EndActivityException, e:
                        common.info("Activity stopped by the user")

                    except common.BadXMLException, e:
                        common.error(
                            "Had to stop the activity because of an error in XML setup"
                        )

                    except Exception, e:
                        common.error("Exception fired", e,
                                     traceback.format_exc())
Ejemplo n.º 7
0
    def find_tuxes(self):

        tuxes = common.get_files(constants.folder_award_tuxes,
                                 constants.image_extensions)

        self.tuxes = common.randomize_list(tuxes)
Ejemplo n.º 8
0
	def __init__(self, game, lang) :

		self.globalvars = game.globalvars
		
		# creation of a new game
		common.Game.__init__(self, self.globalvars, game.xml_game_node, game.level)

		if (self.xml_game_node != None) :

			# reading global parameters
			xml_global_parameters_node = self.xml_game_node.getElementsByTagName("global_parameters")[0]
		
			# first of all, game setup
			xml_game_setup_node = self.xml_game_node.getElementsByTagName("game_setup")[0]
			
			# the default amount of pieces on x and y axis
			self.pieces_amount_x = xml_funcs.getInt(xml_game_setup_node.getElementsByTagName("pieces_amount_x")[0])
			self.pieces_amount_y = xml_funcs.getInt(xml_game_setup_node.getElementsByTagName("pieces_amount_y")[0])

			# area for image :
			image_area_node = xml_global_parameters_node.getElementsByTagName("image_area")[0]
			(self.image_pos, self.image_size) = xml_funcs.get_box(image_area_node)

			
			# reading transformation items
			
			main_transformations = self.xml_game_node.getElementsByTagName("transformations")[0]
			
			transformation_nodes = main_transformations.getElementsByTagName("transformation")
			
			self.transformations = []
			
			for transformation_node in transformation_nodes :
				
				transformation = Transformation(self)
				
				image_nodes = transformation_node.getElementsByTagName("image")


				# TODO : make this a bit more robust ?
				transformation.transformed_image_filename = xml_funcs.getText(image_nodes[0])
				transformation.original_image_filename = xml_funcs.getText(image_nodes[1])


				text_nodes = transformation_node.getElementsByTagName("text")
				
				if len(text_nodes) > 0 :
					
					for text_node in text_nodes :

						lang_attr = text_node.getAttribute("lang")
						
						if (lang_attr == "") :
							# if no "lang" attribute, we assume
							# the language of the text is the one expected
							transformation.text = xml_funcs.getText(text_node)
						
						if (cmp(lang_attr, lang) == 0) :
							# if we have the correct language, we
							# take the text and exit the loop
							transformation.text = xml_funcs.getText(text_node)
							break
					
				if (transformation.pieces_amount_x == 0) :
					transformation.pieces_amount_x = self.pieces_amount_x
				
				if (transformation.pieces_amount_y == 0) :
					transformation.pieces_amount_y = self.pieces_amount_y
					
				self.transformations.append(transformation)
				
			self.transformations = common.randomize_list(self.transformations)
Ejemplo n.º 9
0
	def __init__(self, globalvars) :

		common.Run_Screen.__init__(self, globalvars)	

		tag_defs = common.load_tag_defs()

		self.current_page = Page_menu(globalvars, tag_defs)

		self.current_page.draw_back()
		pygame.display.flip()

		common.start_music(constants.default_music_files, globalvars)

		common.info("Looking for xml activities")
		for data_folder in constants.data_folders :
			self.current_page.games_list.append_from_folder(data_folder)

		common.info("Initialize igloo")
		self.current_page.igloo_page = igloo.create(self.globalvars)

		common.info("Display main menu")
		self.current_page.display_main_menu()
	
		self.current_page.draw()
		pygame.display.flip()

		main_page = self.current_page
	
		level = None

		while self.running :

			try :

				common.Run_Screen.run_pre(self)

			except common.EndActivityException, e :

				# although we should normally end after an EndActivityException,
				# here we'll ask for user confirmation
				self.running = True

				if (cmp(self.current_page.page_type, "MAIN") == 0) :

					self.dirty_rects = self.current_page.display_quit()

				elif (cmp(self.current_page.page_type, "SELECT_LEVEL") == 0) :
		
					self.mouse_clicked = False

					self.current_page = main_page
					self.current_page.draw()

					self.dirty_rects = [self.screen.get_rect()]

		
				else :
		
					self.dirty_rects = self.current_page.display_main_menu()

					self.current_page.draw()


			if (self.mouse_clicked == True) :
				clicked = self.current_page.was_something_clicked(self.mouse_pos, self.mousebutton)
		
				if (clicked != None) :
					(component_clicked, foo, some_dirty_rects) = clicked

					self.dirty_rects = self.dirty_rects + some_dirty_rects

					if (component_clicked != None) :
						# we try to play an associated sound (if any)
						component_clicked.play_random_associated_sound()


					if (cmp(self.current_page.page_type, "DIALOG_BOX_QUIT") == 0) :
						if (component_clicked == self.current_page.quit_yes) :
							self.running = False
					
						elif (component_clicked == self.current_page.quit_no):

							self.dirty_rects = self.current_page.display_main_menu()

							self.current_page.draw()

							self.mouse_clicked = False


					elif (cmp(self.current_page.page_type, "MAIN") == 0) :
			
						if (component_clicked == self.current_page.igloo_image) :
		
							self.current_page.run_igloo(False)
					
							self.mouse_clicked = False

							self.current_page = main_page

							self.current_page.draw()

							self.dirty_rects = [self.screen.get_rect()]

						elif (component_clicked == self.current_page.language_image) :
					
							# changing main language
					
							self.current_page.remove_all()
					
							index_lang = constants.supported_languages.index(self.current_page.language)
					
							index_lang = index_lang + 1
					
							if (index_lang >= len(constants.supported_languages)) :
								index_lang = 0
						
							self.current_page.language = constants.supported_languages[index_lang]

							self.globalvars.main_language = constants.supported_languages[index_lang]
					
							self.dirty_rects =  self.current_page.display_main_menu()
					
							self.current_page.draw()

			
							self.mouse_clicked = False			
				
						elif (component_clicked == self.current_page.quit_icon) :
					
							self.dirty_rects = self.current_page.display_quit()
				
							self.mouse_clicked = False
				
						elif (component_clicked in self.current_page.tag_icons ) :

							# TODO : allow multiple activities inside a game_set !
				
							tag_icon = component_clicked
							tag_def = tag_icon.associated_object

							self.current_page.games_to_display = self.current_page.games_list.get_games_by_tag_and_language(tag_def.tag, self.current_page.language)
					
							self.dirty_rects = self.current_page.display_games_by_type()
					
							self.mouse_clicked = False

						elif (component_clicked == self.current_page.options_icon) :
							
							self.current_page.fade_out()

							options.Run_options(globalvars) 

							self.current_page.draw()
							
							pygame.display.flip()

							self.mouse_clicked = False
			
					elif (cmp(self.current_page.page_type, "GAME_SELECTION") == 0) :


						if (component_clicked == self.current_page.go_back_icon) :
							self.current_page.fade_out()

							self.dirty_rects = self.current_page.display_main_menu()	
							self.current_page.draw()

							self.mouse_clicked = False
				
						else :
							game_set = component_clicked.associated_object
				
							if (game_set != None) :

								# TODO allow more levels !!!!
								levels = game_set.levels

								if (len(levels) > 1) :

									level_page = Page_level(globalvars, self.current_page.second_background_image)

									self.current_page = level_page


									self.dirty_rects = self.current_page.select_level(levels)

									self.mouse_clicked = False

								else :
									# in case we have a single level activity
									level = levels[0]






					elif (cmp(self.current_page.page_type, "SELECT_LEVEL") == 0) :

						if (component_clicked == self.current_page.go_back_icon) :

							# TODO : a implementer !!!

							self.mouse_clicked = False

							self.current_page = main_page
							self.current_page.draw()

							self.dirty_rects = [self.screen.get_rect()]
	
						else :
							associated_object = component_clicked.associated_object
				
							if (associated_object != None) :

								self.current_page.fade_out()

								# TODO allow more levels !!!!
								level = associated_object

			else :
				# mouse is not clicked
				# but it may be going over elements

				(mouse_over_new, mouse_over_old) = self.current_page.components_mouse_over(pygame.mouse.get_pos())


				if (mouse_over_old != None) :
					self.dirty_rects = self.dirty_rects + self.current_page.remove_legend_text()


				if (mouse_over_new != None) :
					self.dirty_rects = self.dirty_rects + self.current_page.add_legend_text(mouse_over_new)


			if (level != None) :

				# then we'll go back to main page when game or highscore will end
				self.current_page = main_page	
				
				if (self.mousebutton == 3) :
				
					# right click means start highscore screen

					self.current_page.run_highscore(level)
			
					self.mouse_clicked = False

				else :


					self.current_page.fade_out()


					# the level is copied in order to change its variables
					copy_level = copy.copy(level)

	

					# shuffle the games
					copy_level.games = common.randomize_list(copy.copy(copy_level.games))

					amount_games_played = 0

					try :

						total_score = common.Score(globalvars)

						for game in copy_level.games :

							if (amount_games_played < copy_level.game_rounds_amount) :

								if (cmp(game.game_type, "associate") == 0) :
									# association
									run_activity = associate.Run_Associate(game, globalvars, total_score) 
					
								if (cmp(game.game_type, "puzzle") == 0) :
									# puzzle
									run_activity = puzzle.Run_Puzzle_Screen(game, globalvars, total_score)

								if (cmp(game.game_type, "memory_cards") == 0) :
									# memory cards
									run_activity = memory_cards.Run_Memory_Cards_Screen(game, globalvars, total_score)

								if (cmp(game.game_type, "differences") == 0) :
									# differences
									run_activity = differences.Run_Differences_Screen(game, globalvars, total_score)

								if (cmp(game.game_type, "transform") == 0) :
									# image transformation
									run_activity = transform.Run_Transform_Screen(game, globalvars)

								if (cmp(game.game_type, "learning") == 0) :
									# learning cards
									run_activity = learning.Run_Learning_Screen(game, globalvars)

								amount_games_played = amount_games_played + 1


							else :
								# if all the games were played, there's nothing more to play !
						
								common.info("Not enough games left to play. Level completed.")
		
						if (pygame.mixer.music.get_busy() == False) :
							common.start_music(constants.default_music_files, globalvars)


						# we go to the highscore screen, if activated and if some score was indeed recorded
						if ((total_score.get_arcade_mode() == True) and (self.globalvars.highscore == True)) :
							self.current_page.run_highscore(copy_level, total_score)
		
						# After a completed game_set, we get a Tux as a reward
						# (only in case the display_igloo global var is True
						if (self.globalvars.display_igloo == True) :
							self.current_page.run_igloo(True)
				
			
						self.dirty_rects = []

					except common.EndActivityException, e :
						common.info("Activity stopped by the user")
			
					except common.BadXMLException, e:
						common.error("Had to stop the activity because of an error in XML setup")

					except Exception, e :
						common.error("Exception fired", e, traceback.format_exc())				
Ejemplo n.º 10
0
	def __init__(self, game, lang, score) :

		self.globalvars = game.globalvars
		
		# creation of a new game
		common.Game.__init__(self, self.globalvars, game.xml_game_node, game.level, score)

		self.score.enable_record_time()


		if (self.xml_game_node != None) :

			# reading global parameters
			xml_global_parameters_node = self.xml_game_node.getElementsByTagName("global_parameters")[0]
		
			# first of all, game setup
			xml_game_setup_node = self.xml_game_node.getElementsByTagName("game_setup")[0]
			
			# the default amount of pieces on x and y axis
			self.pieces_amount_x = xml_funcs.getInt(xml_game_setup_node.getElementsByTagName("pieces_amount_x")[0])
			self.pieces_amount_y = xml_funcs.getInt(xml_game_setup_node.getElementsByTagName("pieces_amount_y")[0])

			# eventual setup for placeholders
			self.goal_image_file = constants.puzzle_tux_image

			goal_nodes = xml_global_parameters_node.getElementsByTagName("goal")
			if (len(goal_nodes) > 0) :
				goal_node = goal_nodes[0]
				
				image_file_nodes = goal_node.getElementsByTagName("image")
		
				if (len(image_file_nodes) > 0) :
					self.goal_image_file = xml_funcs.getText(image_file_nodes[random.randint(0, len(image_file_nodes)-1)])

								
			# reading puzzle items
			
			main_puzzles = self.xml_game_node.getElementsByTagName("puzzles")[0]
			
			puzzle_nodes = main_puzzles.getElementsByTagName("puzzle")
			
			self.puzzles = []
			
			for puzzle_node in puzzle_nodes :
				
				puzzle = Puzzle(self)
				
				image_nodes = puzzle_node.getElementsByTagName("image")
				
				puzzle.image = xml_funcs.getText(image_nodes[0])
				
				sound_nodes = puzzle_node.getElementsByTagName("sound")
					
				if len(sound_nodes) > 0 :
					puzzle.sound = xml_funcs.getText(sound_nodes[0])

				text_nodes = puzzle_node.getElementsByTagName("text")
				
				if len(text_nodes) > 0 :
					
					for text_node in text_nodes :

						lang_attr = text_node.getAttribute("lang")
						
						if (lang_attr == "") :
							# if no "lang" attribute, we assume
							# the language of the text is the one expected
							puzzle.text = xml_funcs.getText(text_node)
						
						if (cmp(lang_attr, lang) == 0) :
							# if we have the correct language, we
							# take the text and exit the loop
							puzzle.text = xml_funcs.getText(text_node)
							break
					
				if (puzzle.pieces_amount_x == 0) :
					puzzle.pieces_amount_x = self.pieces_amount_x
				
				if (puzzle.pieces_amount_y == 0) :
					puzzle.pieces_amount_y = self.pieces_amount_y
					
				self.puzzles.append(puzzle)
				
			self.puzzles = common.randomize_list(self.puzzles)
Ejemplo n.º 11
0
    def __init__(self, game, main_language):

        xml_game_node = game.xml_game_node

        self.globalvars = game.globalvars

        # here we create a new game object to play with
        # thus the original game won't be altered
        common.Game.__init__(self, self.globalvars, xml_game_node, game.level)

        self.xml_game_node = xml_game_node

        # reading global parameters
        xml_global_parameters_node = self.xml_game_node.getElementsByTagName(
            "global_parameters")[0]

        # first of all, game setup
        xml_game_setup_node = self.xml_game_node.getElementsByTagName(
            "game_setup")[0]

        # the min and max amounts of learning cards to display (which also happen to be draggable)
        self.min_draggable = xml_funcs.getInt(
            xml_game_setup_node.getElementsByTagName("min_display")[0])
        self.max_draggable = xml_funcs.getInt(
            xml_game_setup_node.getElementsByTagName("max_display")[0])

        # global placeholders where to draw learning cards

        item_area_nodes = xml_global_parameters_node.getElementsByTagName(
            "item_to_display_area")

        self.item_areas = []
        for item_area_node in item_area_nodes:
            self.item_areas.append(Item_area(item_area_node))

        # area to display text legends
        text_legend_nodes = xml_global_parameters_node.getElementsByTagName(
            "text_legend_area")

        if (len(text_legend_nodes) > 0):
            self.text_legend_area = xml_funcs.get_box(text_legend_nodes[0])
        else:
            self.text_legend_area = None

        # reading learning_cards

        learning_cards_node = self.xml_game_node.getElementsByTagName(
            "learning_cards")[0]

        learning_cards = learning_cards_node.getElementsByTagName(
            "learning_card")

        self.learning_cards = []

        for learning_card_node in learning_cards:

            learning_card = Learning_card()

            image_nodes = learning_card_node.getElementsByTagName("image")

            for image_node in image_nodes:

                if (image_node.parentNode == learning_card_node):
                    # we ignore images which are not direct children
                    # of the learning_card

                    image_filename = xml_funcs.getText(image_node)

                    learning_card.append_image_filename(image_filename)

            sound_nodes = learning_card_node.getElementsByTagName("sound")

            for sound_node in sound_nodes:
                sound_node_lang = sound_node.getAttribute("lang")

                if ((cmp(sound_node_lang, "") == 0)
                        or (cmp(sound_node_lang, main_language) == 0)):

                    learning_card.append_sound_filename(
                        xml_funcs.getText(sound_node))

            text_nodes = learning_card_node.getElementsByTagName("text")

            for text_node in text_nodes:

                if (text_node.parentNode == learning_card_node):

                    text_lang = text_node.getAttribute("lang")

                    text_should_be_added = False

                    if (text_lang == ""):
                        # if no lang attribute defined, the text is included
                        text_should_be_added = True
                    else:
                        # if there is a lang attribute, we add the text only
                        # if this language is the main language
                        if (cmp(text_lang, main_language) == 0):
                            text_should_be_added = True

                        # the text node might be a dictionary key, in this case we also add it :
                        if (cmp(text_node.getAttribute("key"), "") != 0):
                            text_should_be_added = True

                    if (text_should_be_added == True):

                        text = xml_funcs.getText(text_node, self.i18n_dict,
                                                 main_language)

                        learning_card.append_text(text)

            self.learning_cards.append(learning_card)

        self.learning_cards = common.randomize_list(self.learning_cards)
Ejemplo n.º 12
0
	def __init__(self, game, score) :
		
		self.globalvars = game.globalvars

		# creation of a new game
		common.Game.__init__(self, self.globalvars, game.xml_game_node, game.level, score)

		self.score.enable_record_time()


		if (self.xml_game_node != None) :

			# reading global parameters
			xml_global_parameters_node = self.xml_game_node.getElementsByTagName("global_parameters")[0]
		

			# the amount of identical cards to find
			self.amount_identical_cards = xml_funcs.getInt(xml_global_parameters_node.getElementsByTagName("identical_cards")[0])


			# Grid setup
			grid_node  = xml_global_parameters_node.getElementsByTagName("grid")[0]
			
			self.grid_box = xml_funcs.get_box(grid_node)
			
			self.grid_amount_x = xml_funcs.getInt(grid_node.getElementsByTagName("amount_x")[0])
			self.grid_amount_y = xml_funcs.getInt(grid_node.getElementsByTagName("amount_y")[0])


			self.amount_different_cards = int((1.0 * self.grid_amount_x * self.grid_amount_y) / self.amount_identical_cards)

			if (self.amount_different_cards != round(self.amount_different_cards)) :
				common.error("the amount of cards is not a multiple of the amount of cards to group")
				raise common.BadXMLException()


			spacing_x_nodes = grid_node.getElementsByTagName("spacing_x")
			spacing_y_nodes = grid_node.getElementsByTagName("spacing_y")

			if (len(spacing_x_nodes) > 0) :
				self.spacing_x = xml_funcs.getFloat(spacing_x_nodes[0])
			else :
				self.spacing_x = 0

			if (len(spacing_y_nodes) > 0) :
				self.spacing_y = xml_funcs.getFloat(spacing_y_nodes[0])
			else :
				self.spacing_y = 0

			# card setup
			card_node  = xml_global_parameters_node.getElementsByTagName("card")[0]

			front_card_node = card_node.getElementsByTagName("front")[0]
			self.front_card_file = xml_funcs.getText(front_card_node)

			back_card_node = card_node.getElementsByTagName("back")[0]
			self.back_card_file = xml_funcs.getText(back_card_node)

			image_area_nodes = xml_global_parameters_node.getElementsByTagName("image_area")
			if (len(image_area_nodes) > 0) :
				image_area_node = image_area_nodes[0]

				ratio_x_node = image_area_node.getElementsByTagName("ratio_x")[0]
				self.ratio_x = xml_funcs.getFloat(ratio_x_node)

				ratio_y_node = image_area_node.getElementsByTagName("ratio_y")[0]
				self.ratio_y = xml_funcs.getFloat(ratio_y_node)
			else :
				self.ratio_x = 100.0
				self.ratio_y = 100.0


			# reading associations
			# (here, only images with associated sounds are supported)
			
			associations_node = self.xml_game_node.getElementsByTagName("associations")[0]
			
			associations = associations_node.getElementsByTagName("association")
			
			self.associations = []
			
			for association_node in associations :
				
				association = Association(self)
				
				image_nodes = association_node.getElementsByTagName("image")
				
		
				for image_node in image_nodes :
						
					image_filename = xml_funcs.getText(image_node)
					
					association.images.append(image_filename)
							

					sound_nodes = image_node.getElementsByTagName("sound")
					
					for sound_node in sound_nodes :
						association.append_image_sound(image_filename, xml_funcs.getText(sound_node))
						

				
				self.associations.append(association)

			if (len(self.associations) < self.amount_different_cards) :
				common.error("The XML file contains " + str(len(self.associations)) + " associations")
				common.error("But at least "+str(self.amount_different_cards) + " associations are required")
				raise common.BadXMLException()

		
			self.associations = common.randomize_list(self.associations)
Ejemplo n.º 13
0
    def __init__(self, game, main_language):

        xml_game_node = game.xml_game_node

        self.globalvars = game.globalvars

        # here we create a new game object to play with
        # thus the original game won't be altered
        common.Game.__init__(self, self.globalvars, xml_game_node, game.level)

        self.xml_game_node = xml_game_node

        # reading global parameters
        xml_global_parameters_node = self.xml_game_node.getElementsByTagName("global_parameters")[0]

        # first of all, game setup
        xml_game_setup_node = self.xml_game_node.getElementsByTagName("game_setup")[0]

        # the min and max amounts of learning cards to display (which also happen to be draggable)
        self.min_draggable = xml_funcs.getInt(xml_game_setup_node.getElementsByTagName("min_display")[0])
        self.max_draggable = xml_funcs.getInt(xml_game_setup_node.getElementsByTagName("max_display")[0])

        # global placeholders where to draw learning cards

        item_area_nodes = xml_global_parameters_node.getElementsByTagName("item_to_display_area")

        self.item_areas = []
        for item_area_node in item_area_nodes:
            self.item_areas.append(Item_area(item_area_node))

            # area to display text legends
        text_legend_nodes = xml_global_parameters_node.getElementsByTagName("text_legend_area")

        if len(text_legend_nodes) > 0:
            self.text_legend_area = xml_funcs.get_box(text_legend_nodes[0])
        else:
            self.text_legend_area = None

            # reading learning_cards

        learning_cards_node = self.xml_game_node.getElementsByTagName("learning_cards")[0]

        learning_cards = learning_cards_node.getElementsByTagName("learning_card")

        self.learning_cards = []

        for learning_card_node in learning_cards:

            learning_card = Learning_card()

            image_nodes = learning_card_node.getElementsByTagName("image")

            for image_node in image_nodes:

                if image_node.parentNode == learning_card_node:
                    # we ignore images which are not direct children
                    # of the learning_card

                    image_filename = xml_funcs.getText(image_node)

                    learning_card.append_image_filename(image_filename)

            sound_nodes = learning_card_node.getElementsByTagName("sound")

            for sound_node in sound_nodes:
                sound_node_lang = sound_node.getAttribute("lang")

                if (cmp(sound_node_lang, "") == 0) or (cmp(sound_node_lang, main_language) == 0):

                    learning_card.append_sound_filename(xml_funcs.getText(sound_node))

            text_nodes = learning_card_node.getElementsByTagName("text")

            for text_node in text_nodes:

                if text_node.parentNode == learning_card_node:

                    text_lang = text_node.getAttribute("lang")

                    text_should_be_added = False

                    if text_lang == "":
                        # if no lang attribute defined, the text is included
                        text_should_be_added = True
                    else:
                        # if there is a lang attribute, we add the text only
                        # if this language is the main language
                        if cmp(text_lang, main_language) == 0:
                            text_should_be_added = True

                            # the text node might be a dictionary key, in this case we also add it :
                        if cmp(text_node.getAttribute("key"), "") != 0:
                            text_should_be_added = True

                    if text_should_be_added == True:

                        text = xml_funcs.getText(text_node, self.i18n_dict, main_language)

                        learning_card.append_text(text)

            self.learning_cards.append(learning_card)

        self.learning_cards = common.randomize_list(self.learning_cards)
Ejemplo n.º 14
0
	def get_random_associations(self) :

		# we position images and texts which might be displayed
		# (in case there would be more than one in some associations)		
		for association in self.associations :
			association.select_random_items()

		# the amount of draggable items will be a random value between min_draggable and max_draggable
		if (self.score.get_arcade_mode() == False) :
			amount_draggable = self.min_draggable + random.randint(0, self.max_draggable-self.min_draggable)
		else :
			# in arcade mode, we force the maximum amount of drag objects
			amount_draggable = self.max_draggable


		# taking a random association
		# those will be the "good" answers
		good_associations = []
		
		if (cmp(self.type_to_associate, "image_on_map") == 0):
			goals_to_find = amount_draggable

		else :
			goals_to_find = len(self.goals)
		

		for i in range(goals_to_find) :
		
			for association in self.associations :
				if (association.done == False) :
					if (association not in good_associations) :
						good_associations.append(association)

						break
			else :
				# if all the associations were found, there's nothing more to associate !
				
				common.info("Not enough associations left to find. Activity ended")
				
				return (None, None)

		
		# select other "wrong" associations
		

		
		all_associations = copy.copy(good_associations)
		
		for i in range(amount_draggable - len(self.goals)) :
			
			found = False
			
			if (len(all_associations) >= len(self.associations)) :
				# we won't be able to find other associations (all are already selected)
				# so we have to stop, to avoid an infinite while loop below
				common.info("Not enough associations available for 'bad' choices.")
				common.info("Please check your xml file to add more associations or lower 'max_draggable' parameter")

				return (None, None)
				

			while (found == False) :
				other_association = self.associations[random.randint(0, len(self.associations)-1)]
				
				if (other_association not in all_associations) :
					all_associations.append(other_association)

					found = True


		
		
		# eventually sorting the entries
		if (self.sort == True) :
			all_associations.sort()
		else :
			all_associations = common.randomize_list(all_associations)

		
		return (good_associations, all_associations)
Ejemplo n.º 15
0
	def __init__(self, game, main_language, score) :

		xml_game_node = game.xml_game_node

		self.globalvars = game.globalvars

		# here we create a new game object to play with
		# thus the original game won't be altered

		common.Game.__init__(self, self.globalvars, xml_game_node, game.level, score)

		self.score.enable_count_good()
		self.score.enable_count_wrong()
		self.score.enable_record_time()


		self.xml_game_node = xml_game_node

		# reading global parameters
		xml_global_parameters_node = self.xml_game_node.getElementsByTagName("global_parameters")[0]
	
	
		# first of all, game setup
		xml_game_setup_node = self.xml_game_node.getElementsByTagName("game_setup")[0]
	
		# possible values for types :
		# image
		# image_on_map (only to associate)
		# text
		self.type_to_associate = xml_funcs.getText(xml_game_setup_node.getElementsByTagName("type_to_associate")[0])
		
		type_to_drag_node = xml_game_setup_node.getElementsByTagName("type_to_drag")[0]

		self.type_to_drag = xml_funcs.getText(type_to_drag_node)
		sort = type_to_drag_node.getAttribute("sort")
		
		if (sort == None) :
			self.sort = False
		elif (cmp(sort.lower(), "yes") == 0) :
			self.sort = True
		else :
			self.sort = False
		
		
	
		# the min and max amounts of associations (good + bad ones) which will become draggable items
		self.min_draggable = xml_funcs.getInt(xml_game_setup_node.getElementsByTagName("min_draggable")[0])
		self.max_draggable = xml_funcs.getInt(xml_game_setup_node.getElementsByTagName("max_draggable")[0])
	
	
		item_to_associate_parameters_nodes  = xml_global_parameters_node.getElementsByTagName("item_to_associate")
		
		self.item_to_associate_parameters = []
		for item_to_associate_parameters_node in item_to_associate_parameters_nodes :
			self.item_to_associate_parameters.append(xml_funcs.get_box(item_to_associate_parameters_node))


		draggable_items_area_nodes = xml_global_parameters_node.getElementsByTagName("draggable_items_area")
		self.draggable_items_areas = []
		
		for draggable_items_area_node in draggable_items_area_nodes :

			spacing_x_nodes = draggable_items_area_node.getElementsByTagName("spacing_x")
			spacing_y_nodes = draggable_items_area_node.getElementsByTagName("spacing_y")

			if (len(spacing_x_nodes) > 0) :
				spacing_x = xml_funcs.getFloat(spacing_x_nodes[0])
			else :
				spacing_x = 0

			if (len(spacing_y_nodes) > 0) :
				spacing_y = xml_funcs.getFloat(spacing_y_nodes[0])
			else :
				spacing_y = 0

			draggable_items_area = (xml_funcs.get_box(draggable_items_area_node),
						xml_funcs.getInt(draggable_items_area_node.getElementsByTagName("amount_x")[0]),
						xml_funcs.getInt(draggable_items_area_node.getElementsByTagName("amount_y")[0]),
						spacing_x,
						spacing_y)
			
			# TODO: make this under each area
			
			text_height_nodes = draggable_items_area_node.getElementsByTagName("font_height")
			if (len(text_height_nodes) > 0) :
				self.text_height = xml_funcs.getInt(text_height_nodes[0])
			else :
				self.text_height = None
			
			self.draggable_items_areas.append(draggable_items_area)
		

		# global placeholders where to drag items
		# only present for non-map associations
		goal_nodes = xml_global_parameters_node.getElementsByTagName("goal")

		self.goals = []
		for goal_node in goal_nodes :
		
			goal = Goal(goal_node)
		
			self.goals.append(goal)
		

		# space to display text legends
		text_legend_nodes = xml_global_parameters_node.getElementsByTagName("text_legend_area")

		if (len(text_legend_nodes) > 0) :
			self.text_legend_area = xml_funcs.get_box(text_legend_nodes[0])
		else :
			self.text_legend_area = None



		
		# Map information (only present if type_to_associate is "on_map")
		map_nodes = xml_global_parameters_node.getElementsByTagName("map")

		if (len(map_nodes) > 0) :
			map_node = map_nodes[0]
			
			(self.map_pos, self.map_size) = xml_funcs.get_box(map_node)
			
			map_filenames = map_node.getElementsByTagName("image")
			
			self.map_filename = xml_funcs.getText(map_filenames[0])



		# reading associations
		
		associations_node = self.xml_game_node.getElementsByTagName("associations")[0]
		
		associations = associations_node.getElementsByTagName("association")
		
		self.associations = []
		
		for association_node in associations :
			
			association = Association(self)
			
			image_nodes = association_node.getElementsByTagName("image")
			
	
			for image_node in image_nodes :
				
				if (image_node.parentNode == association_node) :
					# we ignore images which are not direct children
					# of the association (ie: images inside goal for instance)
				
					image_filename = xml_funcs.getText(image_node)
					

					if (cmp(image_node.getAttribute("type"), "") == 0) :
						if (cmp(self.type_to_associate, "image") == 0) :
							association.images_to_associate.append(image_filename)
						if (cmp(self.type_to_drag, "image") == 0) :
							association.images_to_drag.append(image_filename)
							
					elif (cmp(image_node.getAttribute("type"), "to_associate") == 0) :
						if ((cmp(self.type_to_associate, "image") == 0) or (cmp(self.type_to_associate, "image_on_map") == 0)) :
							association.images_to_associate.append(image_filename)
	
							if (cmp(self.type_to_associate, "image_on_map") == 0) :
								association.image_to_associate_pos_size = xml_funcs.get_box(image_node)
	
						else :
							common.warn(image_filename + " is supposed to be associated, but the game is not supposed to associate images")
							
					elif (cmp(image_node.getAttribute("type"), "to_drag") == 0) :
						if ((cmp(self.type_to_drag, "image") == 0) or (cmp(self.type_to_associate, "image_on_map") == 0)) :
							association.images_to_drag.append(image_filename)
						else :
							common.warn(image_filename + " is supposed to be dragged and dropped, but the game is not supposed to drag an drop images")
						
					# find potential associated sounds

					sound_nodes = image_node.getElementsByTagName("sound")
					
					for sound_node in sound_nodes :
						sound_node_lang = sound_node.getAttribute("lang")

						if ((cmp(sound_node_lang, "") == 0) or (cmp(sound_node_lang, main_language) == 0)) :

							association.append_image_sound(image_filename, xml_funcs.getText(sound_node))

					# find potential associated text legends
					# only texts with no lang tag or with lang tag = main_language are used
					text_legend_nodes = image_node.getElementsByTagName("text")
					
					for text_legend_node in text_legend_nodes :

						if ((cmp(text_legend_node.getAttribute("lang"), main_language) == 0) or (cmp(text_legend_node.getAttribute("key"), "") != 0)) :

							association.append_image_text_legend(image_filename, xml_funcs.getText(text_legend_node, self.i18n_dict, main_language))					

					
			
			text_nodes = association_node.getElementsByTagName("text")
			
			for text_node in text_nodes :

				if (text_node.parentNode == association_node) :
				
					text_lang = text_node.getAttribute("lang")

					text_should_be_added = False

					if (text_lang == "") :
						# if no lang attribute defined, the text is included
						text_should_be_added = True
					else :
						# if there is a lang attribute, we add the text only
						# if this language is the main language
						if (cmp(text_lang, main_language) == 0) :
							text_should_be_added = True

						# the text node might be a dictionary key, in this case we also add it :
						if (cmp(text_node.getAttribute("key"), "") != 0) :
							text_should_be_added = True
					

					if (text_should_be_added == True) :

						text = xml_funcs.getText(text_node, self.i18n_dict, main_language)
					
						association.texts.append(text)
					
						sound_nodes = text_node.getElementsByTagName("sound")
					
						for sound_node in sound_nodes :

							sound_node_lang = sound_node.getAttribute("lang")

							if ((cmp(sound_node_lang, "") == 0) or (cmp(sound_node_lang, main_language) == 0)) :
	
								association.append_text_sound(text, xml_funcs.getText(sound_node))
				
				
			# goals local to only one association
			
			goal_nodes = association_node.getElementsByTagName("goal")
			
			if (len(goal_nodes) > 0) :
			
				# TODO : allow for more than a goal ?
				goal_node = goal_nodes[0]
				
				if (cmp(self.type_to_associate, "image_on_map") == 0) :
					
					goal = Goal(goal_node)

					# TODO : remove from here ?				
					self.goals.append(goal)
					
					# TODO : put more than one goal
					association.associated_goal = goal
			
				else :
					common.warn("<goal> found inside an association whereas type to associate is not image_on_map")
			
			
			
			
			self.associations.append(association)
			
		
		self.associations = common.randomize_list(self.associations)