Exemple #1
0
        def _callback(texture: core.Texture):
            if parent_frame.is_empty():
                return

            frame_size = gui.size_inside_square_for_texture(texture, 0.2)

            if frame_size is None:
                return

            tile = DirectGui.DirectButton(
                parent=parent_frame,
                frameSize=(0.01, frame_size.x - 0.01, -0.01, -(frame_size.y - 0.01)),
                frameTexture=texture,
                relief=DirectGuiGlobals.FLAT,
                command=self._select_tile,
                extraArgs=[picnum],
            )
            self._bind_scroll(tile)

            tile_number = DirectGui.DirectLabel(
                parent=tile,
                pos=core.Vec3(0, 0, -constants.TEXT_SIZE),
                scale=constants.TEXT_SIZE,
                text=str(picnum),
                frameColor=(0, 0, 0, 0),
                text_align=core.TextNode.A_left,
                text_fg=(1, 1, 1, 0.75),
            )
            self._bind_scroll(tile_number)
Exemple #2
0
 def drawBattleCellLabel(self, marker, cellId=0):
     marker.setTag('cellId', '%d' % cellId)
     label = DirectGui.DirectLabel(text='%d' % cellId,
                                   parent=marker,
                                   relief=None,
                                   scale=3)
     label.setBillboardPointEye(0)
     label.setScale(0.4)
    def __init__(
        self,
        parent: core.NodePath,
        edit_mode: edit_mode.EditMode,
        task_manager: Task.TaskManager,
        sound_browser: sound_view.SoundView,
        tile_viewer: tile_dialog.TileDialog,
    ):
        self._task_manager = task_manager

        self._dialog = DirectGui.DirectFrame(
            parent=parent,
            pos=core.Vec3(-1.1, -0.9),
            frameSize=(0, 2.2, 0, 1.8),
            relief=DirectGuiGlobals.RAISED,
            borderWidth=(0.01, 0.01),
        )
        self._dialog.hide()

        self._tile_section = DirectGui.DirectFrame(parent=self._dialog,
                                                   pos=core.Vec3(0.65, 0.07),
                                                   frameColor=(0, 0, 0, 0))

        current_tile_frame_parent = DirectGui.DirectFrame(
            parent=self._tile_section,
            pos=core.Vec3(0, constants.TEXT_SIZE),
            frameSize=(0, self._TILE_FRAME_SIZE, 0, self._TILE_FRAME_SIZE),
            frameColor=(0.65, 0.65, 0.65, 1),
            relief=DirectGuiGlobals.SUNKEN,
            borderWidth=(0.01, 0.01),
        )
        self._current_tile_frame = DirectGui.DirectButton(
            pos=core.Vec3(0.01, 0.01),
            parent=current_tile_frame_parent,
            frameSize=(0, self._TILE_FRAME_SIZE, self._TILE_FRAME_SIZE, 0),
            relief=DirectGuiGlobals.FLAT,
            command=self._show_tiles,
        )
        self._current_tile_frame.set_transparency(True)
        self._change_tile_button = DirectGui.DirectButton(
            parent=self._tile_section,
            scale=constants.TEXT_SIZE,
            text="Change Tile",
            text_align=core.TextNode.A_left,
            command=self._show_tiles,
        )

        self._property_parent: core.NodePath = self._dialog.attach_new_node(
            "properties")
        self._property_parent.set_pos(0.66, 0, 0.38)

        self._sound_browser = sound_browser
        self._tile_viewer = tile_viewer
        self._edit_mode = edit_mode

        self._sprite: typing.Optional[map_objects.EditorSprite] = None
        self._selected_descriptor: map_objects.sprite_type_descriptor.Descriptor = (
            map_objects.sprite_type_descriptor.Descriptor(-1, {}))
        self._current_descriptor: map_objects.sprite_type_descriptor.Descriptor = (
            map_objects.sprite_type_descriptor.Descriptor(-1, {}))
        self._current_picnum: typing.Optional[int] = None
        self._current_palette: typing.Optional[int] = None
        self._current_status_number: typing.Optional[int] = None

        self._sprite_category_options = DirectGui.DirectOptionMenu(
            parent=self._dialog,
            pos=core.Vec3(0.04, 1.72),
            items=list(descriptors.sprite_category_descriptors.keys()),
            command=self._select_sprite_category,
            scale=constants.TEXT_SIZE,
            text_align=core.TextNode.A_left,
        )
        self._sprite_type_list = sprite_type_list.SpriteTypeList(
            self._dialog, self._tile_viewer.tile_manager,
            self._select_sprite_type)
        self._properties: typing.Optional[
            sprite_property_view.SpritePropertyView] = None

        self._droppables = {
            descriptor.name: sprite_type
            for sprite_type, descriptor in descriptors.sprite_types.items()
            if descriptor.get_is_droppable(
                descriptors.sprite_category_descriptors)
        }
        self._droppables["None"] = 0

        DirectGui.DirectLabel(
            parent=self._dialog,
            text="Special Source:",
            pos=core.Vec3(1.74, 0.38),
            scale=constants.TEXT_SIZE,
        )
        self._special_source_menu = DirectGui.DirectOptionMenu(
            parent=self._dialog,
            pos=core.Vec3(1.90, 0.38),
            items=["None", "Level Start"],
            scale=constants.TEXT_SIZE,
        )

        DirectGui.DirectLabel(
            parent=self._dialog,
            text="Special Target:",
            pos=core.Vec3(1.74, 0.38 - constants.TEXT_SIZE - 0.02),
            scale=constants.TEXT_SIZE,
        )
        self._special_target_menu = DirectGui.DirectOptionMenu(
            parent=self._dialog,
            pos=core.Vec3(1.90, 0.38 - constants.TEXT_SIZE - 0.02),
            items=["None", "Secret", "Next Level", "Secret Level"],
            scale=constants.TEXT_SIZE,
        )

        DirectGui.DirectButton(
            parent=self._dialog,
            pos=core.Vec3(1.98, 0.07),
            text="Ok",
            scale=constants.TEXT_SIZE,
            command=self._save_changes,
        )
        DirectGui.DirectButton(
            parent=self._dialog,
            pos=core.Vec3(2.1, 0.07),
            text="Cancel",
            scale=constants.TEXT_SIZE,
            command=self._hide,
        )
Exemple #4
0
    def __init__(
        self,
        resource_loader: Loader.Loader,
        window: core.GraphicsWindow,
        render: core.NodePath,
        render_2d: core.NodePath,
        aspect_2d: core.NodePath,
        aspect_2d_top_left: core.NodePath,
        scene: core.NodePath,
        default_camera: Camera,
        task_manager: Task.TaskManager,
    ):
        self._resource_loader = resource_loader
        self._window = window
        self._render = render
        self._render_2d = render_2d
        self._aspect_2d = aspect_2d
        self._scene = scene
        self._builder_2d: core.NodePath = self._scene.attach_new_node(
            "builder_2d")
        self._builder: core.NodePath = self._builder_2d.attach_new_node(
            "builder_3d")
        self._default_camera = default_camera
        self._cameras: typing.Dict[str, Camera] = {
            "default": self._default_camera
        }
        self._task_manager = task_manager

        builder_arrow_segments = core.LineSegs("builder_2d_arrow")
        builder_arrow_segments.set_thickness(6)
        builder_arrow_segments.set_color(0.85, 0.85, 0.85, 1)
        builder_arrow_segments.draw_to(0, -512, 0)
        builder_arrow_segments.draw_to(0, 512, 0)
        builder_arrow_segments.draw_to(-512, 0, 0)
        builder_arrow_segments.draw_to(0, 512, 0)
        builder_arrow_segments.draw_to(512, 0, 0)
        builder_arrow: core.NodePath = self._builder.attach_new_node(
            builder_arrow_segments.create())
        builder_arrow.set_depth_write(False)
        builder_arrow.set_depth_test(False)
        builder_arrow.set_bin("fixed", constants.FRONT_MOST)
        builder_arrow.hide(constants.SCENE_3D)

        self._default_camera.camera.reparent_to(self._builder)
        self._default_camera.camera.node().set_camera_mask(constants.SCENE_3D)
        self._default_camera.lens.set_fov(90)
        self._default_camera.lens.set_near_far(10, constants.REALLY_BIG_NUMBER)

        builder_camera: core.NodePath = self._builder.attach_new_node(
            "builder_camera")
        builder_camera.hide(constants.SCENE_3D)
        builder_camera.set_depth_write(False)
        builder_camera.set_depth_test(False)
        builder_camera.set_bin("fixed", constants.FRONT_MOST)
        builder_camera.set_scale(500)

        self._info_display = DirectGui.DirectLabel(
            parent=aspect_2d_top_left,
            pos=core.Vec3(0, 0, -constants.TEXT_SIZE),
            scale=constants.TEXT_SIZE,
            text="A",
            text_bg=(0, 0, 0, 1),
            text_fg=(1, 1, 1, 1),
            frameColor=(0, 0, 0, 0),
            text_align=core.TextNode.A_left,
        )
        self._info_display_alpha = 1
        self._info_fade_task: Task.Task = None
        self._info_display.hide()
    def __init__(
        self,
        parent: core.NodePath,
        default_tile: int,
        properties: typing.Dict[str, Property],
        sound_browser: sound_view.SoundView,
        update_tile: typing.Callable[[int], None],
        canvas_height: float,
        frame_width: float,
        frame_height: float,
        alpha=1,
    ):
        self._canvas_height = canvas_height
        self._frame_width = frame_width
        self._frame_height = frame_height

        self._frame = DirectGui.DirectScrolledFrame(
            parent=parent,
            frameSize=(0, self._frame_width, 0.05, self._frame_height + 0.05),
            frameColor=(0.65, 0.65, 0.65, alpha),
            state=DirectGuiGlobals.NORMAL,
            scrollBarWidth=0.04,
            relief=DirectGuiGlobals.SUNKEN,
        )
        self._bind_scroll(self._frame)
        self._canvas = self._frame.getCanvas()
        self._default_tile = default_tile
        self._properties = properties
        self._sound_browser = sound_browser
        self._update_tile = update_tile
        self.get_current_tile: typing.Callable[[], int] = lambda: None

        property_list: _PROPERTY_LIST_TYPE = list(self._properties.items())
        property_count = len(property_list)
        columns = math.ceil(property_count / self._property_rows)

        self._frame["canvasSize"] = (
            0,
            columns * self._padded_property_width + 0.2,
            -self._canvas_height,
            0,
        )

        self._value_setters: typing.Dict[str, typing.Any] = {}
        for column in range(columns):
            for row in range(self._property_rows):
                index = column * self._property_rows + row
                if index >= property_count:
                    break

                name, descriptor = property_list[index]

                x = column * (
                    self._padded_property_width) + self._PROPERTY_PADDING / 4
                y = -(row + 1) * self._property_height

                label = DirectGui.DirectLabel(
                    parent=self._canvas,
                    pos=core.Vec3(x, y),
                    text=name,
                    scale=constants.TEXT_SIZE,
                    text_align=core.TextNode.A_left,
                    frameColor=(0, 0, 0, 0),
                )
                self._bind_scroll(label)

                label_size = label.node().get_frame() * constants.TEXT_SIZE
                label_width = (label_size[1] -
                               label_size[0]) + self._PROPERTY_PADDING
                width_left = (self._PROPERTY_WIDTH -
                              label_width) / constants.TEXT_SIZE

                if descriptor.property_type == Property.INTEGER_PROPERTY:
                    setter = DirectGui.DirectEntry(
                        parent=self._canvas,
                        pos=core.Vec3(x + label_width, y),
                        width=width_left,
                        frameColor=(1, 1, 1, 1),
                        relief=DirectGuiGlobals.SUNKEN,
                        scale=constants.TEXT_SIZE,
                        initialText=str(descriptor.value - descriptor.offset),
                    )
                elif descriptor.property_type == Property.BOOLEAN_PROPERTY:
                    setter = DirectGui.DirectCheckButton(
                        parent=self._canvas,
                        pos=core.Vec3(x + self._PROPERTY_WIDTH,
                                      y + constants.TEXT_SIZE / 2),
                        scale=constants.TEXT_SIZE,
                        indicatorValue=descriptor.value ^ descriptor.offset,
                    )
                elif descriptor.property_type == Property.SOUND_PROPERTY:
                    setter = DirectGui.DirectButton(
                        parent=self._canvas,
                        pos=core.Vec3(x + self._PROPERTY_WIDTH,
                                      y + constants.TEXT_SIZE / 2),
                        scale=constants.TEXT_SIZE,
                        text="Browse",
                        command=self._browse_sounds,
                        text_align=core.TextNode.A_right,
                    )
                    setter.set_python_tag("sound_index", descriptor.value)
                elif descriptor.property_type == Property.ENUM_PROPERTY:
                    items = list(descriptor.enum_values.keys())
                    setter = DirectGui.DirectOptionMenu(
                        parent=self._canvas,
                        pos=core.Vec3(x + label_width, y),
                        scale=constants.TEXT_SIZE,
                        items=items,
                    )
                    setter.set(
                        descriptor.reverse_enum_values[descriptor.value])
                    setter.set_python_tag("enum_values",
                                          descriptor.enum_values)
                else:
                    raise ValueError(
                        f"Invalid property type {descriptor.property_type}")

                self._bind_scroll(setter)
                self._value_setters[name] = setter

                setter["state"] = DirectGuiGlobals.NORMAL
                setter["extraArgs"] = [setter, descriptor]
                if descriptor.tile_link_type == Property.TILE_LINK_OFFSET:
                    self._setup_tile_link_offset_setter(setter, descriptor)
    def __init__(self, aspect_2d: core.NodePath,
                 on_type_changed: typing.Callable[[], None]):
        self._aspect_2d = aspect_2d
        self._on_type_changed = on_type_changed

        self._frame = DirectGui.DirectFrame(
            parent=self._aspect_2d,
            frameSize=(0, 0.56, 0, 0.2),
            relief=DirectGuiGlobals.RAISED,
            borderWidth=(0.01, 0.01),
            frameColor=(0.85, 0.85, 0.85, 0.75),
            state=DirectGuiGlobals.NORMAL,
        )
        gui.bind_gui_for_focus(self._frame)
        self._frame.hide()

        self._property_parent: core.NodePath = self._aspect_2d.attach_new_node(
            "properties")
        self._properties_frame = DirectGui.DirectFrame(
            parent=self._property_parent,
            frameSize=(-0.02, 1.02, 0.02, 1.32),
            relief=DirectGuiGlobals.RAISED,
            borderWidth=(0.01, 0.01),
            frameColor=(0.85, 0.85, 0.85, 0.75),
            state=DirectGuiGlobals.NORMAL,
        )
        self._properties_parent: core.NodePath = self._properties_frame.attach_new_node(
            "properties")
        self._properties_parent.set_z(0.10)
        gui.bind_gui_for_focus(self._properties_frame)
        self._properties_frame.hide()
        self._properties: sprite_property_view.SpritePropertyView = None

        self._sector: map_objects.EditorSector = None
        self._current_sector_type: sector_type_descriptor.SectorTypeDescriptor = None

        self._type_lookup = {
            sector_type.name: type_index
            for type_index, sector_type in descriptors.sector_types.items()
        }
        type_names = list(self._type_lookup.keys())
        self._type_selector = DirectGui.DirectOptionMenu(
            parent=self._frame,
            pos=core.Vec3(0.05, 0.08),
            scale=constants.BIG_TEXT_SIZE,
            items=type_names,
            command=self._type_changed,
        )

        DirectGui.DirectLabel(
            parent=self._properties_frame,
            text="Special Source:",
            pos=core.Vec3(7 * constants.PADDING,
                          2 * constants.TEXT_SIZE + 2 * constants.PADDING),
            scale=constants.TEXT_SIZE,
            frameColor=(0, 0, 0, 0),
        )
        self._special_source_menu = DirectGui.DirectOptionMenu(
            parent=self._properties_frame,
            pos=core.Vec3(
                7 * constants.PADDING + 0.16,
                2 * constants.TEXT_SIZE + 2 * constants.PADDING,
            ),
            items=["None", "Level Start"],
            scale=constants.TEXT_SIZE,
        )

        DirectGui.DirectLabel(
            parent=self._properties_frame,
            text="Special Target:",
            pos=core.Vec3(7 * constants.PADDING,
                          constants.TEXT_SIZE + constants.PADDING),
            scale=constants.TEXT_SIZE,
            frameColor=(0, 0, 0, 0),
        )
        self._special_target_menu = DirectGui.DirectOptionMenu(
            parent=self._properties_frame,
            pos=core.Vec3(7 * constants.PADDING + 0.16, constants.TEXT_SIZE) +
            constants.PADDING,
            items=["None", "Secret", "Next Level", "Secret Level"],
            scale=constants.TEXT_SIZE,
        )

        self._update_frame_position()
    def __init__(self, parent: core.NodePath, edit_mode: edit_mode.EditMode):
        self._dialog = DirectGui.DirectFrame(
            parent=parent,
            pos=core.Vec3(-0.78, -0.9),
            frameSize=(0, 1.58, 0, 1.8),
            relief=DirectGuiGlobals.RAISED,
            borderWidth=(0.01, 0.01),
        )
        self._dialog.hide()

        self._property_parent: core.NodePath = self._dialog.attach_new_node(
            "properties")
        self._property_parent.set_pos(0.04, 0, 0.38)

        self._edit_mode = edit_mode

        self._wall: map_objects.EditorWall = None
        self._selected_descriptor: wall_type_descriptor.WallTypeDescriptor = None
        self._current_descriptor: wall_type_descriptor.WallTypeDescriptor = None
        self._current_picnum: int = None
        self._current_palette: int = None
        self._current_status_number: int = None

        self._properties: sprite_property_view.SpritePropertyView = None

        self._type_lookup = {
            wall_type.name: type_index
            for type_index, wall_type in descriptors.wall_types.items()
        }
        type_names = list(self._type_lookup.keys())
        self._type_selector = DirectGui.DirectOptionMenu(
            parent=self._dialog,
            pos=core.Vec3(0.05, 0.38),
            scale=constants.TEXT_SIZE,
            items=type_names,
            command=self._type_changed,
        )

        DirectGui.DirectLabel(
            parent=self._dialog,
            text="Special Source:",
            pos=core.Vec3(1.12, 0.38),
            scale=constants.TEXT_SIZE,
        )
        self._special_source_menu = DirectGui.DirectOptionMenu(
            parent=self._dialog,
            pos=core.Vec3(1.28, 0.38),
            items=["None", "Level Start"],
            scale=constants.TEXT_SIZE,
        )

        DirectGui.DirectLabel(
            parent=self._dialog,
            text="Special Target:",
            pos=core.Vec3(1.12, 0.38 - constants.TEXT_SIZE - 0.02),
            scale=constants.TEXT_SIZE,
        )
        self._special_target_menu = DirectGui.DirectOptionMenu(
            parent=self._dialog,
            pos=core.Vec3(1.28, 0.38 - constants.TEXT_SIZE - 0.02),
            items=["None", "Next Level", "Secret Level"],
            scale=constants.TEXT_SIZE,
        )

        DirectGui.DirectButton(
            parent=self._dialog,
            pos=core.Vec3(1.36, 0.07),
            text="Ok",
            scale=constants.TEXT_SIZE,
            command=self._save_changes,
        )
        DirectGui.DirectButton(
            parent=self._dialog,
            pos=core.Vec3(1.48, 0.07),
            text="Cancel",
            scale=constants.TEXT_SIZE,
            command=self._hide,
        )