Beispiel #1
0
    def __init__(self, server_scenario):
        super().__init__()

        self._cursors = {}
        self._cursor_not_allowed = {}

        workforce_action_cursor_settings = server_scenario.get_workforce_action_cursor_settings(
        )
        for workforce_type in workforce_action_cursor_settings:
            if workforce_type not in self._cursors:
                self._cursors[workforce_type] = {}

            self._cursors[workforce_type][
                WorkforceAction.MOVE] = QtGui.QCursor(
                    QtGui.QPixmap(
                        constants.extend(
                            constants.GRAPHICS_MAP_ICON_FOLDER,
                            workforce_action_cursor_settings[workforce_type]
                            ['workforce_action_cursor_move'])))
            self._cursors[workforce_type][
                WorkforceAction.DUTY_ACTION] = QtGui.QCursor(
                    QtGui.QPixmap(
                        constants.extend(
                            constants.GRAPHICS_MAP_ICON_FOLDER,
                            workforce_action_cursor_settings[workforce_type]
                            ['workforce_action_cursor_duty_action'])))
            self._cursor_not_allowed[workforce_type] = QtGui.QCursor(
                QtGui.QPixmap(
                    constants.extend(
                        constants.GRAPHICS_MAP_ICON_FOLDER,
                        workforce_action_cursor_settings[workforce_type]
                        ['workforce_action_cursor_not_allowed'])))
Beispiel #2
0
    def __init__(self, server_scenario):
        super().__init__()

        workforce_settings = server_scenario.get_workforce_settings()

        self.pixmaps_stand = {}
        self.pixmaps_on_duty = {}
        for workforce_type in workforce_settings:
            pixmap_stand = QtGui.QPixmap(
                constants.extend(
                    constants.GRAPHICS_WORKFORCE_FOLDER,
                    workforce_settings[workforce_type]
                    ['texture_filename_stand']))
            self.pixmaps_stand[workforce_type] = pixmap_stand.scaled(
                constants.WORKFORCE_SIZE[0], constants.WORKFORCE_SIZE[1])

            duty_image = QtGui.QImage(
                constants.extend(
                    constants.GRAPHICS_WORKFORCE_FOLDER,
                    workforce_settings[workforce_type]
                    ['texture_filename_on_duty']))

            # must be sure that sprite is divided evenly
            hor_count = int(duty_image.width() / constants.WORKFORCE_SIZE[0])
            ver_count = int(duty_image.height() / constants.WORKFORCE_SIZE[1])
            width = constants.WORKFORCE_SIZE[0]
            height = constants.WORKFORCE_SIZE[1]
            self.pixmaps_on_duty[workforce_type] = [
                QtGui.QPixmap.fromImage(
                    duty_image.copy(row * height, col * width, width,
                                    height)).scaled(
                                        constants.WORKFORCE_SIZE[0],
                                        constants.WORKFORCE_SIZE[1])
                for row in range(hor_count) for col in range(ver_count)
            ]
Beispiel #3
0
    def __init__(self, client):
        super().__init__()

        self.setAttribute(QtCore.Qt.WA_StyledBackground)
        self.setProperty('background', 'black')

        layout = qt.RelativeLayout(self)

        start_image = QtGui.QPixmap(constants.extend(constants.GRAPHICS_UI_FOLDER, 'start.background.jpg'))
        start_image_item = QtWidgets.QGraphicsPixmapItem(start_image)
        start_image_item.setZValue(1)

        scene = QtWidgets.QGraphicsScene(self)
        scene.addItem(start_image_item)

        view = QtWidgets.QGraphicsView(scene)
        view.resize(start_image.size())
        view.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
        view.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
        view.setSceneRect(0, 0, start_image.width(), start_image.height())
        view.layout_constraint = qt.RelativeLayoutConstraint().center_horizontal().center_vertical()
        layout.addWidget(view)

        subtitle = QtWidgets.QLabel('')
        subtitle.layout_constraint = qt.RelativeLayoutConstraint((0.5, -0.5, 0),
            (0.5, -0.5, start_image.height() / 2 + 20))
        layout.addWidget(subtitle)

        actions = {'exit': client.quit, 'help': client.show_help_browser, 'lobby': client.show_game_lobby_dialog,
                   'editor': client.switch_to_editor_screen, 'options': client.show_preferences_dialog}

        image_map_file = constants.extend(constants.GRAPHICS_UI_FOLDER, 'start.overlay.info')
        image_map = utils.read_as_yaml(image_map_file)

        # security check, they have to be the same
        if actions.keys() != image_map.keys():
            raise RuntimeError('Start screen hot map info file ({}) corrupt.'.format(image_map_file))

        for k, v in image_map.items():
            # add action from our predefined action dictionary
            pixmap = QtGui.QPixmap(constants.extend(constants.GRAPHICS_UI_FOLDER, v['overlay']))
            map_item = MapItem(view, pixmap, label=subtitle, description=v['label'])
            map_item.item.setZValue(3)
            offset = v['offset']
            map_item.item.setOffset(QtCore.QPointF(offset[0], offset[1]))
            map_item.item.signaller.clicked.connect(actions[k])

            frame_path = QtGui.QPainterPath()
            frame_path.addRect(map_item.item.boundingRect())
            frame_item = scene.addPath(frame_path, StartScreen.frame_pen)
            frame_item.setZValue(4)
            scene.addItem(map_item.item)

        version_label = QtWidgets.QLabel('<font color=#ffffff>{}</font>'.format(version.__version_full__))
        version_label.layout_constraint = qt.RelativeLayoutConstraint().east(20).south(20)
        layout.addWidget(version_label)
Beispiel #4
0
    def __init__(self, *args, **kwargs):
        """
        All the necessary initializations. Is shown at the end.
        """
        super().__init__(*args, **kwargs)
        # set geometry
        self.setGeometry(tools.get_option(constants.Option.MAINWINDOW_BOUNDS))
        # set title
        self.setWindowTitle('Imperialism Remake')

        # just a layout but nothing else
        self.layout = QtWidgets.QHBoxLayout(self)
        self.layout.setContentsMargins(0, 0, 0, 0)
        self.content = None

        # show in full screen, maximized or normal
        if tools.get_option(constants.Option.MAINWINDOW_FULLSCREEN):
            self.setWindowFlags(self.windowFlags()
                                | QtCore.Qt.FramelessWindowHint)
            self.showFullScreen()
        elif tools.get_option(constants.Option.MAINWINDOW_MAXIMIZED):
            self.showMaximized()
        else:
            self.show()

        # loading animation
        # TODO animation right and start, stop in client
        self.animation = QtGui.QMovie(
            constants.extend(constants.GRAPHICS_UI_FOLDER, 'loading.gif'))
        #       self.animation.start()
        self.loading_label = QtWidgets.QLabel(
            self, flags=QtCore.Qt.FramelessWindowHint | QtCore.Qt.Window)
        self.loading_label.setAttribute(QtCore.Qt.WA_TranslucentBackground)
        self.loading_label.setMovie(self.animation)
Beispiel #5
0
    def __init__(self, *args, **kwargs):
        """
        All the necessary initializations. Is shown at the end.
        """
        super().__init__(*args, **kwargs)
        # set geometry
        self.setGeometry(tools.get_option(constants.Option.MAINWINDOW_BOUNDS))
        # set icon
        self.setWindowIcon(tools.load_ui_icon('window.icon.ico'))
        # set title
        self.setWindowTitle('Imperialism Remake')

        # just a layout but nothing else
        self.layout = QtWidgets.QHBoxLayout(self)
        self.layout.setContentsMargins(0, 0, 0, 0)
        self.content = None

        # show in full screen, maximized or normal
        if tools.get_option(constants.Option.MAINWINDOW_FULLSCREEN):
            self.setWindowFlags(self.windowFlags() | QtCore.Qt.FramelessWindowHint)
            self.showFullScreen()
        elif tools.get_option(constants.Option.MAINWINDOW_MAXIMIZED):
            self.showMaximized()
        else:
            self.show()

        # loading animation
        # TODO animation right and start, stop in client
        self.animation = QtGui.QMovie(constants.extend(constants.GRAPHICS_UI_FOLDER, 'loading.gif'))
        # self.animation.start()
        self.loading_label = QtWidgets.QLabel(self, flags=QtCore.Qt.FramelessWindowHint | QtCore.Qt.Window)
        self.loading_label.setAttribute(QtCore.Qt.WA_TranslucentBackground)
        self.loading_label.setMovie(self.animation)
Beispiel #6
0
    def from_file(file_path):
        """
        Load/deserialize all internal variables from a zipped archive via YAML.
        """
        # TODO what if not a valid scenario file, we should raise an error then

        scenario = Scenario()

        reader = utils.ZipArchiveReader(file_path)

        scenario._properties = reader.read_as_yaml(
            constants.SCENARIO_FILE_PROPERTIES)
        scenario._maps = reader.read_as_yaml(constants.SCENARIO_FILE_MAPS)
        scenario._provinces = reader.read_as_yaml(
            constants.SCENARIO_FILE_PROVINCES)
        # TODO check all ids are smaller then len()

        scenario._nations = reader.read_as_yaml(
            constants.SCENARIO_FILE_NATIONS)
        # TODO check all ids are smaller then len()

        # read rule file
        # TODO how to specify which rules file apply
        rule_file = constants.extend(
            constants.SCENARIO_RULESET_FOLDER,
            scenario[constants.ScenarioProperty.RULES])
        scenario._rules = utils.read_as_yaml(rule_file)

        return scenario
    def create(self, properties):
        """
        Create new scenario (from the create new scenario dialog).

        :param properties:
        """
        logger.debug('create properties:%s', properties)

        self.server_scenario = ServerScenario(ServerScenarioBase())
        self.server_scenario[constants.ScenarioProperty.TITLE] = properties[
            constants.ScenarioProperty.TITLE]
        self.server_scenario.create_empty_map(
            properties[constants.ScenarioProperty.MAP_COLUMNS],
            properties[constants.ScenarioProperty.MAP_ROWS])

        # standard rules
        self.server_scenario[
            constants.ScenarioProperty.RULES] = 'standard.rules'
        # self.scenario.load_rules()
        # TODO rules as extra?
        rule_file = constants.extend(
            constants.SCENARIO_RULESET_FOLDER,
            self.server_scenario[constants.ScenarioProperty.RULES])
        self.server_scenario.get_scenario_base()._rules = utils.read_from_file(
            rule_file)

        self._init()
Beispiel #8
0
def load_ui_icon(name):
    """
    Loads an icon from a base icon path.

    :param name:
    :return:
    """
    file_name = constants.extend(constants.GRAPHICS_UI_FOLDER, name)
    return QtGui.QIcon(file_name)
Beispiel #9
0
def load_ui_icon(name):
    """
    Loads an icon from a base icon path.

    :param name:
    :return:
    """
    file_name = constants.extend(constants.GRAPHICS_UI_FOLDER, name)
    return QtGui.QIcon(file_name)
Beispiel #10
0
    def __init__(self, settings, folder, property_filename):
        super().__init__()

        self.pixmaps = {}
        for texture_type in settings:
            pixmap = QtGui.QPixmap(
                constants.extend(folder,
                                 settings[texture_type][property_filename]))
            self.pixmaps[texture_type] = pixmap.scaled(constants.TILE_SIZE,
                                                       constants.TILE_SIZE)
Beispiel #11
0
 def _draw_towns_and_names(self) -> None:
     logger.debug("_draw_towns_and_names")
     # draw towns and names
     city_pixmap = QtGui.QPixmap(
         constants.extend(constants.GRAPHICS_MAP_FOLDER, 'city.png'))
     for nation in self.scenario.server_scenario.nations():
         # get all provinces of this nation
         provinces = self.scenario.server_scenario.provinces_of_nation(
             nation)
         for province in provinces:
             column, row = self.scenario.server_scenario.province_property(
                 province, constants.ProvinceProperty.TOWN_LOCATION)
             sx, sy = scene_position(column, row)
             # center city image on center of tile
             scene_utils.put_pixmap_in_tile_center(self.scene, city_pixmap,
                                                   sx, sy, 6)
             # display province name below
             province_name = self.scenario.server_scenario.province_property(
                 province, constants.ProvinceProperty.NAME)
             item = self.scene.addSimpleText(province_name)
             item.setPen(qt.TRANSPARENT_PEN)
             item.setBrush(QtGui.QBrush(QtCore.Qt.darkRed))
             x = (sx + 0.5
                  ) * constants.TILE_SIZE - item.boundingRect().width() / 2
             y = (sy +
                  1) * constants.TILE_SIZE - item.boundingRect().height()
             item.setPos(x, y)
             item.setZValue(6)
             # display rounded rectangle below province name
             bx = 8
             by = 4
             background = QtCore.QRectF(
                 x - bx, y - by,
                 item.boundingRect().width() + 2 * bx,
                 item.boundingRect().height() + 2 * by)
             path = QtGui.QPainterPath()
             path.addRoundedRect(background, 50, 50)
             item = self.scene.addPath(path,
                                       pen=qt.TRANSPARENT_PEN,
                                       brush=QtGui.QBrush(
                                           QtGui.QColor(128, 128, 255, 64)))
             item.setZValue(5)
Beispiel #12
0
    def create(self, properties):
        """
        Create new scenario (from the create new scenario dialog).

        :param properties:
        """
        self.scenario = Scenario()
        self.scenario[constants.ScenarioProperty.TITLE] = properties[constants.ScenarioProperty.TITLE]
        self.scenario.create_empty_map(properties[constants.ScenarioProperty.MAP_COLUMNS],
            properties[constants.ScenarioProperty.MAP_ROWS])

        # standard rules
        self.scenario[constants.ScenarioProperty.RULES] = 'standard.rules'
        # self.scenario.load_rules()
        # TODO rules as extra?
        rule_file = constants.extend(constants.SCENARIO_RULESET_FOLDER, self.scenario[constants.ScenarioProperty.RULES])
        self.scenario._rules = utils.read_as_yaml(rule_file)

        # emit that everything has changed
        self.changed.emit()
Beispiel #13
0
def load_soundtrack_playlist():
    """
        Loads the play list of the soundtracks and replaces the file name with the full path.

        A playlist is a list where each entry is a list of two strings: file path, title
    """
    global soundtrack_playlist

    # create playlist
    soundtrack_playlist = QtMultimedia.QMediaPlaylist()
    soundtrack_playlist.setPlaybackMode(QtMultimedia.QMediaPlaylist.Loop)

    # read information file
    data = utils.read_as_yaml(constants.SOUNDTRACK_INFO_FILE)

    # add the soundtrack folder to each file name
    for entry in data:
        file = constants.extend(constants.SOUNDTRACK_FOLDER, entry[0])
        url = qt.local_url(file)
        media = QtMultimedia.QMediaContent(url)
        soundtrack_playlist.addMedia(media)
Beispiel #14
0
    def from_file(file_path):
        """
        Load/deserialize all internal variables from a zipped archive
        """
        # TODO what if not a valid scenario file, we should raise an error then

        logger.debug('from_file file: %s', file_path)

        server_scenario = ServerScenario(ServerScenarioBase())

        reader = utils.ZipArchiveReader(file_path)

        server_scenario.get_scenario_base().properties = reader.read_from_file(
            constants.SCENARIO_FILE_PROPERTIES)
        server_scenario.get_scenario_base().maps = reader.read_from_file(
            constants.SCENARIO_FILE_MAPS)
        server_scenario.get_scenario_base().provinces = reader.read_from_file(
            constants.SCENARIO_FILE_PROVINCES)
        # TODO check all ids are smaller then len()

        server_scenario.get_scenario_base().nations = reader.read_from_file(
            constants.SCENARIO_FILE_NATIONS)
        # TODO check all ids are smaller then len()

        # read rule file
        # TODO how to specify which rules file apply
        rule_file = constants.extend(
            constants.SCENARIO_RULESET_FOLDER,
            server_scenario[constants.ScenarioProperty.RULES])
        server_scenario.get_scenario_base().rules = utils.read_from_file(
            rule_file)

        if ServerScenarioBase.ROAD not in server_scenario._scenario_base.maps:
            server_scenario._scenario_base.maps[ServerScenarioBase.ROAD] = []

        if ServerScenarioBase.STRUCTURE not in server_scenario._scenario_base.maps:
            server_scenario._scenario_base.maps[
                ServerScenarioBase.STRUCTURE] = {}

        return server_scenario
Beispiel #15
0
    def from_file(file_name):
        """
        Load/deserialize all internal variables from a zipped archive via YAML.
        """

        scenario = Scenario()

        reader = utils.ZipArchiveReader(file_name)

        scenario._properties = reader.read_as_yaml(constants.SCENARIO_FILE_PROPERTIES)
        scenario._maps = reader.read_as_yaml(constants.SCENARIO_FILE_MAPS)
        scenario._provinces = reader.read_as_yaml(constants.SCENARIO_FILE_PROVINCES)
        # TODO check all ids are smaller then len()

        scenario._nations = reader.read_as_yaml(constants.SCENARIO_FILE_NATIONS)
        # TODO check all ids are smaller then len()

        # read rule file
        # TODO how to specify which rules file apply
        rule_file = constants.extend(constants.SCENARIO_RULESET_FOLDER, scenario[constants.ScenarioProperty.RULES])
        scenario._rules = utils.read_as_yaml(rule_file)

        return scenario
Beispiel #16
0
    def __init__(self, client):
        super().__init__()

        self.setAttribute(QtCore.Qt.WA_StyledBackground)
        self.setProperty('background', 'black')

        layout = qt.RelativeLayout(self)

        start_image = QtGui.QPixmap(
            constants.extend(constants.GRAPHICS_UI_FOLDER,
                             'start.background.jpg'))
        start_image_item = QtWidgets.QGraphicsPixmapItem(start_image)
        start_image_item.setZValue(1)

        scene = QtWidgets.QGraphicsScene(self)
        scene.addItem(start_image_item)

        view = QtWidgets.QGraphicsView(scene)
        view.resize(start_image.size())
        view.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
        view.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
        view.setSceneRect(0, 0, start_image.width(), start_image.height())
        view.layout_constraint = qt.RelativeLayoutConstraint(
        ).center_horizontal().center_vertical()
        layout.addWidget(view)

        subtitle = QtWidgets.QLabel('')
        subtitle.layout_constraint = qt.RelativeLayoutConstraint(
            (0.5, -0.5, 0), (0.5, -0.5, start_image.height() / 2 + 20))
        layout.addWidget(subtitle)

        actions = {
            'exit': client.quit,
            'help': client.show_help_browser,
            'lobby': client.show_game_lobby_dialog,
            'editor': client.switch_to_editor_screen,
            'options': client.show_preferences_dialog
        }

        image_map_file = constants.extend(constants.GRAPHICS_UI_FOLDER,
                                          'start.overlay.info')
        image_map = utils.read_as_yaml(image_map_file)

        # security check, they have to be the same
        if list(actions.keys()) != list(image_map.keys()):
            raise RuntimeError(
                'Start screen hot map info file ({}) corrupt.'.format(
                    image_map_file))

        for k, v in list(image_map.items()):
            # add action from our predefined action dictionary
            pixmap = QtGui.QPixmap(
                constants.extend(constants.GRAPHICS_UI_FOLDER, v['overlay']))
            map_item = MapItem(view,
                               pixmap,
                               label=subtitle,
                               description=v['label'])
            map_item.item.setZValue(3)
            offset = v['offset']
            map_item.item.setOffset(QtCore.QPointF(offset[0], offset[1]))
            map_item.item.signaller.clicked.connect(actions[k])

            frame_path = QtGui.QPainterPath()
            frame_path.addRect(map_item.item.boundingRect())
            frame_item = scene.addPath(frame_path, StartScreen.frame_pen)
            frame_item.setZValue(4)
            scene.addItem(map_item.item)

        version_label = QtWidgets.QLabel(
            '<font color=#ffffff>{}</font>'.format(version.__version_full__))
        version_label.layout_constraint = qt.RelativeLayoutConstraint().east(
            20).south(20)
        layout.addWidget(version_label)
Beispiel #17
0
if __name__ == '__main__':

    # add source directory to path if needed
    source_directory = os.path.realpath(
        os.path.join(os.path.abspath(os.path.dirname(__file__)),
                     os.path.pardir, os.path.pardir, 'source'))
    if source_directory not in sys.path:
        sys.path.insert(0, source_directory)

    from imperialism_remake.base import constants
    from imperialism_remake.server.scenario import Scenario

    # load scenario
    scenario = Scenario.from_file(
        constants.extend(constants.CORE_SCENARIO_FOLDER,
                         'Europe1814.scenario'))

    # nation map
    columns = scenario[constants.ScenarioProperty.MAP_COLUMNS]
    rows = scenario[constants.ScenarioProperty.MAP_ROWS]
    map = [0] * (columns * rows)
    for nation in scenario.nations():
        provinces = scenario.provinces_of_nation(nation)
        for province in provinces:
            tiles = scenario.province_property(province, 'tiles')
            for column, row in tiles:
                map[row * columns + column] = nation

    # get outlines
    for nation in scenario.nations():
        visited = [False] * (columns * rows)
Beispiel #18
0
def create_start_screen_widget(actions):
    """
    Creates the start screen.

    :param client:
    :return:
    """

    screen = QtWidgets.QWidget()
    screen.setAttribute(QtCore.Qt.WA_StyledBackground, True)
    screen.setProperty('background', 'black')

    layout = qt.RelativeLayout(screen)

    path = constants.extend(constants.GRAPHICS_UI_FOLDER,
                            'start.background.jpg')
    start_image = QtGui.QPixmap(path)
    start_image_item = QtWidgets.QGraphicsPixmapItem(start_image)
    start_image_item.setZValue(1)

    scene = QtWidgets.QGraphicsScene(screen)
    scene.addItem(start_image_item)

    view = QtWidgets.QGraphicsView(scene)
    view.resize(start_image.size())
    view.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
    view.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
    view.setSceneRect(0, 0, start_image.width(), start_image.height())
    view.layout_constraint = qt.RelativeLayoutConstraint().center_horizontal()\
        .center_vertical()
    layout.addWidget(view)

    subtitle = QtWidgets.QLabel('')
    subtitle.resize(0, 0)
    # TODO this is below the main image but collides with screens only 768 px high
    subtitle.layout_constraint = qt.RelativeLayoutConstraint(
        (0.5, -0.5, 0), (0.5, -0.5, start_image.height() / 2 + 20))
    layout.addWidget(subtitle)

    image_map_file = constants.extend(constants.GRAPHICS_UI_FOLDER,
                                      'start.overlay.info')
    image_map = utils.read_as_yaml(image_map_file)

    # security check, they have to be the same
    if actions.keys() != image_map.keys():
        raise RuntimeError(
            'Start screen hot map info file ({}) corrupt.'.format(
                image_map_file))

    frame_pen = QtGui.QPen(QtGui.QBrush(QtGui.QColor(255, 255, 255, 64)), 6)
    for k, v in image_map.items():
        # add action from our predefined action dictionary
        pixmap = QtGui.QPixmap(
            constants.extend(constants.GRAPHICS_UI_FOLDER, v['overlay']))
        map_item = MapItem(scene,
                           pixmap,
                           label=subtitle,
                           description=v['label'])
        map_item.item.setZValue(3)
        offset = v['offset']
        map_item.item.setOffset(QtCore.QPointF(offset[0], offset[1]))
        map_item.item.signaller.clicked.connect(actions[k])

        frame_path = QtGui.QPainterPath()
        frame_path.addRect(map_item.item.boundingRect())
        frame_item = scene.addPath(frame_path, frame_pen)
        frame_item.setZValue(4)
        scene.addItem(map_item.item)

    version_label = QtWidgets.QLabel('<font color=#ffffff>{}</font>'.format(
        version.__version_full__))
    version_label.resize(version_label.sizeHint())
    version_label.layout_constraint = qt.RelativeLayoutConstraint().east(
        20).south(20)
    layout.addWidget(version_label)

    return screen
Beispiel #19
0
def create_start_screen_widget(actions):
    """
    Creates the start screen.

    :param client:
    :return:
    """

    screen = QtWidgets.QWidget()
    screen.setAttribute(QtCore.Qt.WA_StyledBackground, True)
    screen.setProperty('background', 'black')

    layout = qt.RelativeLayout(screen)

    path = constants.extend(constants.GRAPHICS_UI_FOLDER, 'start.background.jpg')
    start_image = QtGui.QPixmap(path)
    start_image_item = QtWidgets.QGraphicsPixmapItem(start_image)
    start_image_item.setZValue(1)

    scene = QtWidgets.QGraphicsScene(screen)
    scene.addItem(start_image_item)

    view = QtWidgets.QGraphicsView(scene)
    view.resize(start_image.size())
    view.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
    view.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
    view.setSceneRect(0, 0, start_image.width(), start_image.height())
    view.layout_constraint = qt.RelativeLayoutConstraint().center_horizontal()\
        .center_vertical()
    layout.addWidget(view)

    subtitle = QtWidgets.QLabel('')
    subtitle.resize(0, 0)
    # TODO this is below the main image but collides with screens only 768 px high
    subtitle.layout_constraint = qt.RelativeLayoutConstraint(
        (0.5, -0.5, 0), (0.5, -0.5, start_image.height() / 2 + 20))
    layout.addWidget(subtitle)

    image_map_file = constants.extend(constants.GRAPHICS_UI_FOLDER, 'start.overlay.info')
    image_map = utils.read_as_yaml(image_map_file)

    # security check, they have to be the same
    if actions.keys() != image_map.keys():
        raise RuntimeError('Start screen hot map info file ({}) corrupt.'
                           .format(image_map_file))

    frame_pen = QtGui.QPen(QtGui.QBrush(QtGui.QColor(255, 255, 255, 64)), 6)
    for k, v in image_map.items():
        # add action from our predefined action dictionary
        pixmap = QtGui.QPixmap(constants.extend(constants.GRAPHICS_UI_FOLDER, v['overlay']))
        map_item = MapItem(scene, pixmap, label=subtitle, description=v['label'])
        map_item.item.setZValue(3)
        offset = v['offset']
        map_item.item.setOffset(QtCore.QPointF(offset[0], offset[1]))
        map_item.item.signaller.clicked.connect(actions[k])

        frame_path = QtGui.QPainterPath()
        frame_path.addRect(map_item.item.boundingRect())
        frame_item = scene.addPath(frame_path, frame_pen)
        frame_item.setZValue(4)
        scene.addItem(map_item.item)

    version_label = QtWidgets.QLabel('<font color=#ffffff>{}</font>'
                                     .format(version.__version_full__))
    version_label.resize(version_label.sizeHint())
    version_label.layout_constraint = qt.RelativeLayoutConstraint().east(20).south(20)
    layout.addWidget(version_label)

    return screen
import os, sys

from PyQt5 import QtWidgets

if __name__ == '__main__':

    # add source directory to path if needed
    source_directory = os.path.realpath(os.path.join(os.path.abspath(os.path.dirname(__file__)), os.path.pardir, os.path.pardir, 'source'))
    if source_directory not in sys.path:
        sys.path.insert(0, source_directory)

    from imperialism_remake.base import constants
    from imperialism_remake.server.scenario import Scenario

    # load scenario
    scenario = Scenario.from_file(constants.extend(constants.CORE_SCENARIO_FOLDER, 'Europe1814.scenario'))

    # nation map
    columns = scenario[constants.ScenarioProperty.MAP_COLUMNS]
    rows = scenario[constants.ScenarioProperty.MAP_ROWS]
    map = [0] * (columns * rows)
    for nation in scenario.nations():
        provinces = scenario.provinces_of_nation(nation)
        for province in provinces:
            tiles = scenario.province_property(province, 'tiles')
            for column, row in tiles:
                map[row * columns + column] = nation

    # get outlines
    for nation in scenario.nations():
        visited = [False] * (columns * rows)
Beispiel #21
0
    def redraw(self):
        """
        Whenever a scenario is been created or loaded new we need to draw the whole map.
        """
        self.scene.clear()

        columns = editor_scenario.scenario[constants.ScenarioProperty.MAP_COLUMNS]
        rows = editor_scenario.scenario[constants.ScenarioProperty.MAP_ROWS]

        width = (columns + 0.5) * self.TILE_SIZE
        height = rows * self.TILE_SIZE
        self.scene.setSceneRect(0, 0, width, height)

        # TODO should load only once and cache (universal cache), should be soft coded somewhere
        # load all textures
        brushes = {0: QtGui.QBrush(QtGui.QColor(64, 64, 255)), 1: QtGui.QBrush(QtGui.QColor(64, 255, 64)),
                   2: QtGui.QBrush(QtGui.QColor(64, 255, 64)), 3: QtGui.QBrush(QtGui.QColor(64, 255, 64)),
                   4: QtGui.QBrush(QtGui.QColor(222, 222, 222)), 5: QtGui.QBrush(QtGui.QColor(0, 128, 0)),
                   6: QtGui.QBrush(QtGui.QColor(222, 222, 0))}

        # fill the ground layer with ocean
        item = self.scene.addRect(0, 0, width, height, brush=brushes[0], pen=qt.TRANSPARENT_PEN)
        item.setZValue(0)

        # fill plains, hills, mountains, tundra, swamp, desert with texture

        # go through each position
        paths = {}
        for t in range(1, 7):
            paths[t] = QtGui.QPainterPath()
        for column in range(0, columns):
            for row in range(0, rows):
                t = editor_scenario.scenario.terrain_at(column, row)
                if t != 0:
                    # not for sea
                    sx, sy = editor_scenario.scenario.scene_position(column, row)
                    paths[t].addRect(sx * self.TILE_SIZE, sy * self.TILE_SIZE, self.TILE_SIZE, self.TILE_SIZE)
        for t in paths:
            path = paths[t]
            path = path.simplified()
            item = self.scene.addPath(path, brush=brushes[t], pen=qt.TRANSPARENT_PEN)
            item.setZValue(1)

        # fill the half tiles which are not part of the map
        brush = QtGui.QBrush(QtCore.Qt.darkGray)
        for row in range(0, rows):
            if row % 2 == 0:
                item = self.scene.addRect(columns * self.TILE_SIZE, row * self.TILE_SIZE, self.TILE_SIZE / 2,
                    self.TILE_SIZE, pen=qt.TRANSPARENT_PEN)
            else:
                item = self.scene.addRect(0, row * self.TILE_SIZE, self.TILE_SIZE / 2, self.TILE_SIZE,
                    pen=qt.TRANSPARENT_PEN)
            item.setBrush(brush)
            item.setZValue(1)

        # draw rivers
        river_pen = QtGui.QPen(QtGui.QColor(64, 64, 255))
        river_pen.setWidth(5)
        # TODO get rivers via a method (generator)
        for river in editor_scenario.scenario[constants.ScenarioProperty.RIVERS]:
            tiles = river['tiles']
            path = QtGui.QPainterPath()
            for tile in tiles:
                sx, sy = editor_scenario.scenario.scene_position(tile[0], tile[1])
                x = (sx + 0.5) * self.TILE_SIZE
                y = (sy + 0.5) * self.TILE_SIZE
                if tile == tiles[0]:
                    path.moveTo(x, y)
                else:
                    path.lineTo(x, y)
            item = self.scene.addPath(path, pen=river_pen)
            item.setZValue(2)

        # draw province and nation borders
        # TODO the whole border drawing is a crude approximation, implement it the right way
        province_border_pen = QtGui.QPen(QtGui.QColor(QtCore.Qt.black))
        province_border_pen.setWidth(2)
        nation_border_pen = QtGui.QPen()
        nation_border_pen.setWidth(4)
        for nation in editor_scenario.scenario.nations():
            # get nation color
            color = editor_scenario.scenario.nation_property(nation, constants.NationProperty.COLOR)
            nation_color = QtGui.QColor()
            nation_color.setNamedColor(color)
            # get all provinces
            provinces = editor_scenario.scenario.provinces_of_nation(nation)
            nation_path = QtGui.QPainterPath()
            # get all tiles
            for province in provinces:
                province_path = QtGui.QPainterPath()
                tiles = editor_scenario.scenario.province_property(province, constants.ProvinceProperty.TILES)
                for column, row in tiles:
                    sx, sy = editor_scenario.scenario.scene_position(column, row)
                    province_path.addRect(sx * self.TILE_SIZE, sy * self.TILE_SIZE, self.TILE_SIZE, self.TILE_SIZE)
                province_path = province_path.simplified()
                item = self.scene.addPath(province_path, pen=province_border_pen)
                item.setZValue(4)
                nation_path.addPath(province_path)
            nation_path = nation_path.simplified()
            nation_border_pen.setColor(nation_color)
            item = self.scene.addPath(nation_path, pen=nation_border_pen)
            item.setZValue(5)

        # draw towns and names
        city_pixmap = QtGui.QPixmap(constants.extend(constants.GRAPHICS_MAP_FOLDER, 'city.png'))
        for nation in editor_scenario.scenario.nations():
            # get all provinces of this nation
            provinces = editor_scenario.scenario.provinces_of_nation(nation)
            for province in provinces:
                column, row = editor_scenario.scenario.province_property(province, constants.ProvinceProperty.TOWN_LOCATION)
                sx, sy = editor_scenario.scenario.scene_position(column, row)
                # center city image on center of tile
                x = (sx + 0.5) * self.TILE_SIZE - city_pixmap.width() / 2
                y = (sy + 0.5) * self.TILE_SIZE - city_pixmap.height() / 2
                item = self.scene.addPixmap(city_pixmap)
                item.setOffset(x, y)
                item.setZValue(6)
                # display province name below
                province_name = editor_scenario.scenario.province_property(province, constants.ProvinceProperty.NAME)
                item = self.scene.addSimpleText(province_name)
                item.setPen(qt.TRANSPARENT_PEN)
                item.setBrush(QtGui.QBrush(QtCore.Qt.darkRed))
                x = (sx + 0.5) * self.TILE_SIZE - item.boundingRect().width() / 2
                y = (sy + 1) * self.TILE_SIZE - item.boundingRect().height()
                item.setPos(x, y)
                item.setZValue(6)
                # display rounded rectangle below province name
                bx = 8
                by = 4
                background = QtCore.QRectF(x - bx, y - by, item.boundingRect().width() + 2 * bx, item.boundingRect().height() + 2 * by)
                path = QtGui.QPainterPath()
                path.addRoundedRect(background, 50, 50)
                item = self.scene.addPath(path, pen=qt.TRANSPARENT_PEN,
                    brush=QtGui.QBrush(QtGui.QColor(128, 128, 255, 64)))
                item.setZValue(5)

        # draw the grid and the coordinates
        for column in range(0, columns):
            for row in range(0, rows):
                sx, sy = editor_scenario.scenario.scene_position(column, row)
                # item = self.scene.addRect(sx * self.tile_size, sy * self.tile_size,  self.tile_size,  self.tile_size)
                # item.setZValue(1000)
                text = '({},{})'.format(column, row)
                item = QtWidgets.QGraphicsSimpleTextItem(text)
                item.setBrush(QtGui.QBrush(QtCore.Qt.black))
                item.setPos((sx + 0.5) * self.TILE_SIZE - item.boundingRect().width() / 2, sy * self.TILE_SIZE)
                item.setZValue(1001)
                self.scene.addItem(item)

        # emit focus changed with -1, -1
        self.focus_changed.emit(-1, -1)
import os, sys

from PyQt5 import QtWidgets

if __name__ == '__main__':

    # add source directory to path if needed
    source_directory = os.path.realpath(os.path.join(os.path.abspath(os.path.dirname(__file__)), os.path.pardir, os.path.pardir, 'source'))
    if source_directory not in sys.path:
        sys.path.insert(0, source_directory)

    from imperialism_remake.base import constants
    from imperialism_remake.server.server_scenario import ServerScenario

    # load scenario
    scenario = ServerScenario.from_file(constants.extend(constants.CORE_SCENARIO_FOLDER, 'Europe1814.scenario'))

    # nation map
    columns = scenario[constants.ScenarioProperty.MAP_COLUMNS]
    rows = scenario[constants.ScenarioProperty.MAP_ROWS]
    map = [0] * (columns * rows)
    for nation in scenario.nations():
        provinces = scenario.provinces_of_nation(nation)
        for province in provinces:
            tiles = scenario.province_property(province, 'tiles')
            for column, row in tiles:
                map[row * columns + column] = nation

    # get outlines
    for nation in scenario.nations():
        visited = [False] * (columns * rows)