コード例 #1
0
        public static void hide()
        {
            if (!_isShown)
                return;

            Debug.Log("Hiding Main Page.");

            _pageTitle.destroy();
            _pageTitle = null;

            _backButton.destroy();
            _backButton = null;

            _levelsContainer.destroy();
            _levelsContainer = null;

            _isShown = false;
        }
コード例 #2
0
        public void destroy()
        {
            _topPanel.destroy();
            _topPanel = null;

            _leftPanel.destroy();
            _leftPanel = null;

            _rightPanel.destroy();
            _rightPanel = null;
        }
コード例 #3
0
        public MapEditorGUI()
        {
            Color backgroundColor = new Color(.3f, .3f, 1.0f, .3f);
            Color lightBackgroundColor = new Color(.6f, .6f, 1.0f, .3f);

            ObjectManipulator.Get().activate(); // The default tool;

            _leftPanel = new GUIObject((obj) =>
            {
                _leftPanel.name("Left Panel");

                _leftPanel.addListener(EventTriggerType.PointerEnter, (e) =>
                {
                    disableTools();
                });
                _leftPanel.addListener(EventTriggerType.PointerExit, (e) =>
                {
                    enableTools();
                });

                _leftPanel.anchor(new Vector2(0.0f, 1.0f));
                _leftPanel.position(new Vector2(28, -150), GUIObject.POSITION_TYPE.RELATIVE);
                _leftPanel.size(new Vector2(56, 300));

                // Background Image
                new GUIImage((image) =>
                {
                    GUIImage background = image as GUIImage;

                    _leftPanel.addChild(background);

                    background.position(Vector2.zero);
                    background.size(_leftPanel.size());
                    background.imageColor(backgroundColor);
                });

                Vector2 buttonSize = new Vector2(40, 40);
                // Play Button
                new GUIButton((button) =>
                {
                    GUIButton playButton = button as GUIButton;

                    _leftPanel.addChild(button);

                    playButton.anchor(new Vector2(0.5f, 0.0f));
                    playButton.position(new Vector2(0, 254), GUIObject.POSITION_TYPE.RELATIVE);
                    playButton.size(buttonSize);
                    playButton.setBaseBackground(_rm.sprite("Textures/GUI/Buttons/Play"), Color.white);
                    playButton.setOverBackground(_rm.sprite("Textures/GUI/Buttons/PlayHover"), Color.white);
                    playButton.setDownBackground(_rm.sprite("Textures/GUI/Buttons/PlayHover"), Color.white);
                });

                // Save Button
                new GUIButton((button) =>
                {
                    GUIButton saveButton = button as GUIButton;

                    _leftPanel.addChild(button);

                    saveButton.anchor(new Vector2(0.5f, 0.0f));
                    saveButton.position(new Vector2(0, 188), GUIObject.POSITION_TYPE.RELATIVE);
                    saveButton.size(buttonSize);
                    saveButton.setBaseBackground(_rm.sprite("Textures/GUI/Buttons/Save"), Color.white);
                    saveButton.setOverBackground(_rm.sprite("Textures/GUI/Buttons/SaveHover"), Color.white);
                    saveButton.setDownBackground(_rm.sprite("Textures/GUI/Buttons/SaveHover"), Color.white);

                    saveButton.addListener(EventTriggerType.PointerClick, (e) =>
                    {
                        string levelPath = EditorUtility.SaveFilePanel("New Level", "Levels", "Epoch Level", "");

                        if (levelPath == "")
                            return;

                        SaveManager.Get().saveLevel(levelPath);
                    });
                });

                // Open Button
                new GUIButton((button) =>
                {
                    GUIButton openButton = button as GUIButton;

                    _leftPanel.addChild(button);

                    openButton.anchor(new Vector2(0.5f, 0.0f));
                    openButton.position(new Vector2(0, 116), GUIObject.POSITION_TYPE.RELATIVE);
                    openButton.size(buttonSize);
                    openButton.setBaseBackground(_rm.sprite("Textures/GUI/Buttons/Open"), Color.white);
                    openButton.setOverBackground(_rm.sprite("Textures/GUI/Buttons/OpenHover"), Color.white);
                    openButton.setDownBackground(_rm.sprite("Textures/GUI/Buttons/OpenHover"), Color.white);

                    openButton.addListener(EventTriggerType.PointerClick, (e) =>
                    {
                        string levelPath = EditorUtility.OpenFolderPanel("New Level", "Levels", "Epoch Level");

                        if (levelPath == "")
                            return;

                        SaveManager.Get().loadLevel(levelPath);
                    });
                });

                // Exit Button
                new GUIButton((button) =>
                {
                    GUIButton exitButton = button as GUIButton;

                    _leftPanel.addChild(button);

                    exitButton.anchor(new Vector2(0.5f, 0.0f));
                    exitButton.position(new Vector2(0, 48), GUIObject.POSITION_TYPE.RELATIVE);
                    exitButton.size(buttonSize);
                    exitButton.setBaseBackground(_rm.sprite("Textures/GUI/Buttons/Exit"), Color.white);
                    exitButton.setOverBackground(_rm.sprite("Textures/GUI/Buttons/ExitHover"), Color.white);
                    exitButton.setDownBackground(_rm.sprite("Textures/GUI/Buttons/ExitHover"), Color.white);

                    exitButton.addListener(EventTriggerType.PointerClick, (e) =>
                    {
                        Debug.Log("Clicking exit");
                        Driver.Get().progress(Driver.DRIVER_STATE.MAIN_MENU);
                    });
                });
            });

            _topPanel = new GUIHorizontalDialog((obj) =>
            {
                _topPanel.name("Top Panel");

                _topPanel.addListener(EventTriggerType.PointerEnter, (e) =>
                {
                    disableTools();
                });
                _topPanel.addListener(EventTriggerType.PointerExit, (e) =>
                {
                    enableTools();
                });

                _topPanel.anchor(new Vector2(0.0f, 1.0f));
                _topPanel.position(new Vector2(MainCanvas.Get().canvasSize().x / 2 + 28, -28), GUIObject.POSITION_TYPE.RELATIVE);
                _topPanel.size(new Vector2(MainCanvas.Get().canvasSize().x - 56, 56));
                _topPanel.overflow(GUI.GUIContent.OVERFLOW_TYPE.HIDE);
                _topPanel.scrollButtonPosition(28);
                _topPanel.backgroundColor(lightBackgroundColor);
                _topPanel.contentWidth(1300.0f);

                float offset = 48 + GUI_PADDING + GUI_DOOR_BUTTON_SIZE.x / 2;

                string doorPath = "Textures/Activatables/Doors/Assemblies/";
                string pressurePadPath = "Textures/Actuators/Pressure Pads/";
                string staticWallPath = "Textures/Game Environment/Walls/";
                string tilePath = "Textures/Game Environment/";

                Input.InputListener.Get().addListener(
                    new Input.Hotkey(new Input.Button(KeyCode.Escape)),
                    (key) =>
                    {
                        resetTools();
                    });

                ObjectManipulator.Get().onNewPlacement = (placeableObject) =>
                {
                    #region Doors
                    if (placeableObject as PlaceableStandardDoor != null)
                    {
                        updateRightPanel("Standard Door", _rm.sprite(doorPath + "StandardDoor"), GUI_DOOR_BUTTON_SIZE, (content) =>
                        {
                            create_doorInitiallyOpened((checkbox) =>
                            {
                                checkbox.position(new Vector2(0, - GUI_PADDING * 1 - GUI_DOOR_BUTTON_SIZE.y * 0.5f), GUIObject.POSITION_TYPE.RELATIVE);
                            });
                            create_rotationDropDown((dropDown) =>
                            {
                                dropDown.position(new Vector2(0, - GUI_PADDING * 3 - GUI_DOOR_BUTTON_SIZE.y * 1.5f), GUIObject.POSITION_TYPE.RELATIVE);
                            });
                        });
                    }
                    else if (placeableObject as PlaceableTeleporterDoor != null)
                    {
                        updateRightPanel("Teleporter Door", _rm.sprite(doorPath + "TeleporterDoor"), GUI_DOOR_BUTTON_SIZE, (content) =>
                        {
                            create_doorInitiallyOpened((checkbox) =>
                            {
                                checkbox.position(new Vector2(0, - GUI_PADDING * 1 - GUI_DOOR_BUTTON_SIZE.y * 0.5f), GUIObject.POSITION_TYPE.RELATIVE);
                            });
                            create_rotationDropDown((dropDown) =>
                            {
                                dropDown.position(new Vector2(0, - GUI_PADDING * 3 - GUI_DOOR_BUTTON_SIZE.y * 1.5f), GUIObject.POSITION_TYPE.RELATIVE);
                            });
                        });
                    }
                    else if (placeableObject as PlaceableCheckpointDoor != null)
                    {
                        updateRightPanel("Checkpoint Door", _rm.sprite(doorPath + "CheckpointDoor"), GUI_DOOR_BUTTON_SIZE, (content) =>
                        {
                            create_rotationDropDown((dropDown) =>
                            {
                                dropDown.position(new Vector2(0, - GUI_PADDING * 1 - GUI_DOOR_BUTTON_SIZE.y * 0.5f), GUIObject.POSITION_TYPE.RELATIVE);
                            });
                        });
                    }
                    else if (placeableObject as PlaceableDirectionalDoor != null)
                    {
                        updateRightPanel("One Way Door", _rm.sprite(doorPath + "OneWayDoor"), GUI_DOOR_BUTTON_SIZE, (content) =>
                        {
                            create_doorInitiallyOpened((checkbox) =>
                            {
                                checkbox.position(new Vector2(0, - GUI_PADDING * 1 - GUI_DOOR_BUTTON_SIZE.y * 0.5f), GUIObject.POSITION_TYPE.RELATIVE);
                            });
                            create_rotationDropDown((dropDown) =>
                            {
                                dropDown.position(new Vector2(0, - GUI_PADDING * 3 - GUI_DOOR_BUTTON_SIZE.y * 1.5f), GUIObject.POSITION_TYPE.RELATIVE);
                            });
                        });
                    }
                    else if (placeableObject as PlaceableEntranceDoor != null)
                    {
                        updateRightPanel("Entrance Door", _rm.sprite(doorPath + "EntranceDoor"), GUI_DOOR_BUTTON_SIZE, (content) =>
                        {
                            create_rotationDropDown((dropDown) =>
                            {
                                dropDown.position(new Vector2(0, - GUI_PADDING * 1 - GUI_DOOR_BUTTON_SIZE.y * 0.5f), GUIObject.POSITION_TYPE.RELATIVE);
                            });
                        });
                    }
                    #endregion
                    // TODO: Power Core Door
                    #region Pressure Pads
                    else if (placeableObject as PlaceablePressureSwitch != null)
                    {
                        updateRightPanel("Pressure Switch", _rm.sprite(pressurePadPath + "On Pressure Switch"), GUI_ACTIVATOR_BUTTON_SIZE, (content) =>
                        { });
                    }
                    else if (placeableObject as PlaceablePressurePlate != null)
                    {
                        updateRightPanel("Pressure Plate", _rm.sprite(pressurePadPath + "Toggle A Pressure Plate"), GUI_ACTIVATOR_BUTTON_SIZE, (content) =>
                        { });
                    }
                        #endregion
                    else if (placeableObject as PlaceableStaticWall != null)
                    {
                        updateRightPanel("Static Wall", _rm.sprite(staticWallPath + "SingleUnitSprite"), GUI_ACTIVATOR_BUTTON_SIZE, (content) =>
                        { });
                    }
                };
                ObjectManipulator.Get().onSelect = (placeableObject) =>
                {
                    #region Doors
                    if (placeableObject as PlaceableStandardDoor != null)
                    {
                        updateRightPanel("Standard Door", _rm.sprite(doorPath + "StandardDoor"), GUI_DOOR_BUTTON_SIZE, (content) =>
                        {
                            create_doorInitiallyOpened((checkbox) =>
                            {
                                checkbox.position(new Vector2(0, - GUI_PADDING * 1 - GUI_DOOR_BUTTON_SIZE.y * 0.5f), GUIObject.POSITION_TYPE.RELATIVE);
                            });
                        });
                    }
                    else if (placeableObject as PlaceableTeleporterDoor != null)
                    {
                        updateRightPanel("Teleporter Door", _rm.sprite(doorPath + "TeleporterDoor"), GUI_DOOR_BUTTON_SIZE, (content) =>
                        {
                            create_doorInitiallyOpened((checkbox) =>
                            {
                                checkbox.position(new Vector2(0, - GUI_PADDING * 1 - GUI_DOOR_BUTTON_SIZE.y * 0.5f), GUIObject.POSITION_TYPE.RELATIVE);
                            });
                        });
                    }
                    else if (placeableObject as PlaceableCheckpointDoor != null)
                    {
                        updateRightPanel("Checkpoint Door", _rm.sprite(doorPath + "CheckpointDoor"), GUI_DOOR_BUTTON_SIZE, (content) =>
                        { });
                    }
                    else if (placeableObject as PlaceableDirectionalDoor != null)
                    {
                        updateRightPanel("One Way Door", _rm.sprite(doorPath + "OneWayDoor"), GUI_DOOR_BUTTON_SIZE, (content) =>
                        {
                            create_doorInitiallyOpened((checkbox) =>
                            {
                                checkbox.position(new Vector2(0, - GUI_PADDING * 1 - GUI_DOOR_BUTTON_SIZE.y * 0.5f), GUIObject.POSITION_TYPE.RELATIVE);
                            });
                        });
                    }
                    else if (placeableObject as PlaceableEntranceDoor != null)
                    {
                        updateRightPanel("Entrance Door", _rm.sprite(doorPath + "EntranceDoor"), GUI_DOOR_BUTTON_SIZE, (content) =>
                        { });
                    }
                    #endregion
                    #region Pressure Pads
                    else if (placeableObject as PlaceablePressureSwitch != null)
                    {
                        updateRightPanel("Pressure Switch", _rm.sprite(pressurePadPath + "On Pressure Switch"), GUI_ACTIVATOR_BUTTON_SIZE, (content) =>
                        { });
                    }
                    else if (placeableObject as PlaceablePressurePlate != null)
                    {
                        updateRightPanel("Pressure Plate", _rm.sprite(pressurePadPath + "Toggle A Pressure Plate"), GUI_ACTIVATOR_BUTTON_SIZE, (content) =>
                        { });
                    }
                    #endregion
                    else if (placeableObject as PlaceableStaticWall != null)
                    {
                        updateRightPanel("Static Wall", _rm.sprite(staticWallPath + "SingleUnitSprite"), GUI_ACTIVATOR_BUTTON_SIZE, (content) =>
                        { });
                    }
                };
                ObjectManipulator.Get().onCancelPlacement = () =>
                {
                    emptyRightPanel();
                };
                ObjectManipulator.Get().onCancelSelect = () =>
                {
                    emptyRightPanel();
                };

                #region Door Selectors
                // Standard Door Selector
                new GUIButton((_button) =>
                {
                    _topPanel.addChild(_button);
                    GUIButton button = _button as GUIButton;

                    button.name("Standard Door Selector");

                    button.anchor(new Vector2(0.0f, 0.5f));
                    button.position(
                        new Vector2((GUI_PADDING * 2 + GUI_DOOR_BUTTON_SIZE.x) * 0 + offset, 0.0f),
                        GUIObject.POSITION_TYPE.RELATIVE);
                    button.size(GUI_DOOR_BUTTON_SIZE);
                    button.setBaseBackground(_rm.sprite(doorPath + "StandardDoor"), Color.white);
                    button.setOverBackground(_rm.sprite(doorPath + "StandardDoor"), Color.blue);
                    button.setDownBackground(_rm.sprite(doorPath + "StandardDoor"), Color.black);

                    button.addListener(EventTriggerType.PointerClick, (e) =>
                    {
                        resetTools();

                        ObjectManipulator.Get().setObjectPrefab(PlaceableStandardDoor.getPrefab());
                        ObjectManipulator.Get().activate();
                    });
                });

                // One Way Door Selector
                new GUIButton((_button) =>
                {
                    _topPanel.addChild(_button);
                    GUIButton button = _button as GUIButton;

                    button.name("One Way Door Selector");

                    button.anchor(new Vector2(0.0f, 0.5f));
                    button.position(
                        new Vector2((GUI_PADDING * 2 + GUI_DOOR_BUTTON_SIZE.x) * 1 + offset, 0.0f),
                        GUIObject.POSITION_TYPE.RELATIVE);
                    button.size(GUI_DOOR_BUTTON_SIZE);
                    button.setBaseBackground(_rm.sprite(doorPath + "OneWayDoor"), Color.white);
                    button.setOverBackground(_rm.sprite(doorPath + "OneWayDoor"), Color.blue);
                    button.setDownBackground(_rm.sprite(doorPath + "OneWayDoor"), Color.black);

                    button.addListener(EventTriggerType.PointerClick, (e) =>
                    {
                        resetTools();

                        ObjectManipulator.Get().setObjectPrefab(PlaceableDirectionalDoor.getPrefab());
                        ObjectManipulator.Get().activate();
                    });
                });

                // Teleporter Door Selector
                new GUIButton((_button) =>
                {
                    _topPanel.addChild(_button);
                    GUIButton button = _button as GUIButton;

                    button.name("Teleporter Door Selector");

                    button.anchor(new Vector2(0.0f, 0.5f));
                    button.position(
                        new Vector2((GUI_PADDING * 2 + GUI_DOOR_BUTTON_SIZE.x) * 2 + offset, 0.0f),
                        GUIObject.POSITION_TYPE.RELATIVE);
                    button.size(GUI_DOOR_BUTTON_SIZE);
                    button.setBaseBackground(_rm.sprite(doorPath + "TeleporterDoor"), Color.white);
                    button.setOverBackground(_rm.sprite(doorPath + "TeleporterDoor"), Color.blue);
                    button.setDownBackground(_rm.sprite(doorPath + "TeleporterDoor"), Color.black);

                    button.addListener(EventTriggerType.PointerClick, (e) =>
                    {
                        resetTools();

                        ObjectManipulator.Get().setObjectPrefab(PlaceableTeleporterDoor.getPrefab());
                        ObjectManipulator.Get().activate();
                    });
                });

                // Checkpoint Door Selector
                new GUIButton((_button) =>
                {
                    _topPanel.addChild(_button);
                    GUIButton button = _button as GUIButton;

                    button.name("Checkpoint Door Selector");

                    button.anchor(new Vector2(0.0f, 0.5f));
                    button.position(
                        new Vector2((GUI_PADDING * 2 + GUI_DOOR_BUTTON_SIZE.x) * 3 + offset, 0.0f),
                        GUIObject.POSITION_TYPE.RELATIVE);
                    button.size(GUI_DOOR_BUTTON_SIZE);
                    button.setBaseBackground(_rm.sprite(doorPath + "CheckpointDoor"), Color.white);
                    button.setOverBackground(_rm.sprite(doorPath + "CheckpointDoor"), Color.blue);
                    button.setDownBackground(_rm.sprite(doorPath + "CheckpointDoor"), Color.black);

                    button.addListener(EventTriggerType.PointerClick, (e) =>
                    {
                        resetTools();

                        ObjectManipulator.Get().setObjectPrefab(PlaceableCheckpointDoor.getPrefab());
                        ObjectManipulator.Get().activate();
                    });
                });

                /*// Power Core Door Selector
                new GUIButton((_button) =>
                {
                    _topPanel.addChild(_button);
                    GUIButton button = _button as GUIButton;

                    button.name("Power Core Door Selector");

                    button.anchor(new Vector2(0.0f, 0.5f));
                    button.position(
                        new Vector2((GUI_PADDING * 2 + GUI_DOOR_BUTTON_SIZE.x) * 4 + offset, 0.0f),
                        GUIObject.POSITION_TYPE.RELATIVE);
                    button.size(GUI_DOOR_BUTTON_SIZE);
                    button.setBaseBackground(_rm.sprite(doorPath + "FullCoreDoor"), Color.white);
                    button.setOverBackground(_rm.sprite(doorPath + "FullCoreDoor"), Color.blue);
                    button.setDownBackground(_rm.sprite(doorPath + "FullCoreDore"), Color.black);

                });*/

                // Entrance Door Selector
                new GUIButton((_button) =>
                {
                    _topPanel.addChild(_button);
                    GUIButton button = _button as GUIButton;

                    button.name("Power Core Door Selector");

                    button.anchor(new Vector2(0.0f, 0.5f));
                    button.position(
                        new Vector2((GUI_PADDING * 2 + GUI_DOOR_BUTTON_SIZE.x) * 5 + offset, 0.0f),
                        GUIObject.POSITION_TYPE.RELATIVE);
                    button.size(GUI_DOOR_BUTTON_SIZE);
                    button.setBaseBackground(_rm.sprite(doorPath + "EntranceDoor"), Color.white);
                    button.setOverBackground(_rm.sprite(doorPath + "EntranceDoor"), Color.blue);
                    button.setDownBackground(_rm.sprite(doorPath + "EntranceDoor"), Color.black);

                    button.addListener(EventTriggerType.PointerClick, (e) =>
                    {
                        resetTools();

                        ObjectManipulator.Get().setObjectPrefab(PlaceableEntranceDoor.getPrefab());
                        ObjectManipulator.Get().activate();
                    });
                });
                #endregion

                #region Pressure Pad Selectors
                // Pressure Switch
                new GUIButton((_button) =>
                {
                    _topPanel.addChild(_button);
                    GUIButton button = _button as GUIButton;

                    button.name("Pressure Switch Selector");

                    button.anchor(new Vector2(0.0f, 0.5f));
                    button.position(
                        new Vector2((GUI_PADDING * 2 + GUI_DOOR_BUTTON_SIZE.x) * 6 + offset, 0.0f),
                        GUIObject.POSITION_TYPE.RELATIVE);
                    button.size(GUI_ACTIVATOR_BUTTON_SIZE);
                    button.setBaseBackground(_rm.sprite(pressurePadPath + "On Pressure Switch"), Color.white);
                    button.setOverBackground(_rm.sprite(pressurePadPath + "On Pressure Switch"), Color.blue);
                    button.setDownBackground(_rm.sprite(pressurePadPath + "On Pressure Switch"), Color.black);

                    button.addListener(EventTriggerType.PointerClick, (e) =>
                    {
                        resetTools();

                        ObjectManipulator.Get().setObjectPrefab(PlaceablePressureSwitch.getPrefab());
                        ObjectManipulator.Get().activate();
                    });
                });

                // Pressure Pad
                new GUIButton((_button) =>
                {
                    _topPanel.addChild(_button);
                    GUIButton button = _button as GUIButton;

                    button.name("Pressure Pad Selector");

                    button.anchor(new Vector2(0.0f, 0.5f));
                    button.position(
                        new Vector2((GUI_PADDING * 2 + GUI_DOOR_BUTTON_SIZE.x) * 7 + offset, 0.0f),
                        GUIObject.POSITION_TYPE.RELATIVE);
                    button.size(GUI_ACTIVATOR_BUTTON_SIZE);
                    button.setBaseBackground(_rm.sprite(pressurePadPath + "Toggle A Pressure Plate"), Color.white);
                    button.setOverBackground(_rm.sprite(pressurePadPath + "Toggle A Pressure Plate"), Color.blue);
                    button.setDownBackground(_rm.sprite(pressurePadPath + "Toggle A Pressure Plate"), Color.black);

                    button.addListener(EventTriggerType.PointerClick, (e) =>
                    {
                        resetTools();

                        ObjectManipulator.Get().setObjectPrefab(PlaceablePressurePlate.getPrefab());
                        ObjectManipulator.Get().activate();
                    });
                });
                    #endregion

                // Static Wall
                new GUIButton((_button) =>
                {
                    _topPanel.addChild(_button);
                    GUIButton button = _button as GUIButton;

                    button.name("Static Wall Selector");

                    button.anchor(new Vector2(0.0f, 0.5f));
                    button.position(
                        new Vector2((GUI_PADDING * 2 + GUI_DOOR_BUTTON_SIZE.x) * 8 + offset, 0.0f),
                        GUIObject.POSITION_TYPE.RELATIVE);
                    button.size(GUI_ACTIVATOR_BUTTON_SIZE);
                    button.setBaseBackground(_rm.sprite(staticWallPath + "SingleUnitSprite"), Color.white);
                    button.setOverBackground(_rm.sprite(staticWallPath + "SingleUnitSprite"), Color.blue);
                    button.setDownBackground(_rm.sprite(staticWallPath + "SingleUnitSprite"), Color.black);

                    button.addListener(EventTriggerType.PointerClick, (e) =>
                    {
                        resetTools();

                        ObjectManipulator.Get().setObjectPrefab(PlaceableStaticWall.getPrefab());
                        ObjectManipulator.Get().activate();
                    });
                });

                // Tile Creator
                new GUIButton((_button) =>
                {
                    _topPanel.addChild(_button);
                    GUIButton button = _button as GUIButton;

                    button.name("Tile Selector");

                    button.anchor(new Vector2(0.0f, 0.5f));
                    button.position(
                        new Vector2((GUI_PADDING * 2 + GUI_DOOR_BUTTON_SIZE.x) * 9 + offset, 0.0f),
                        GUIObject.POSITION_TYPE.RELATIVE);
                    button.size(GUI_ACTIVATOR_BUTTON_SIZE);
                    button.setBaseBackground(_rm.sprite(tilePath + "Tile"), Color.white);
                    button.setOverBackground(_rm.sprite(tilePath + "Tile"), Color.blue);
                    button.setDownBackground(_rm.sprite(tilePath + "Tile"), Color.black);

                    button.addListener(EventTriggerType.PointerClick, (e) =>
                    {
                        resetTools();

                        TileManipulator.Get().activate();
                    });
                });

                // Tile Eraser
                new GUIButton((_button) =>
                {
                    _topPanel.addChild(_button);
                    GUIButton button = _button as GUIButton;

                    button.name("Tile Selector");

                    button.anchor(new Vector2(0.0f, 0.5f));
                    button.position(
                        new Vector2((GUI_PADDING * 2 + GUI_DOOR_BUTTON_SIZE.x) * 10 + offset, 0.0f),
                        GUIObject.POSITION_TYPE.RELATIVE);
                    button.size(GUI_ACTIVATOR_BUTTON_SIZE);
                    button.setBaseBackground(_rm.sprite(tilePath + "TileEraser"), Color.white);
                    button.setOverBackground(_rm.sprite(tilePath + "TileEraser"), Color.blue);
                    button.setDownBackground(_rm.sprite(tilePath + "TileEraser"), Color.black);

                    button.addListener(EventTriggerType.PointerClick, (e) =>
                    {
                        resetTools();

                        TileEraser.Get().activate();
                    });
                });
            });

            _rightPanel = new GUIVerticalDialog((_dialog) =>
            {
                _rightPanel.name("Right Panel");

                _rightPanel.addListener(EventTriggerType.PointerEnter, (e) =>
                {
                    disableTools();
                });
                _rightPanel.addListener(EventTriggerType.PointerExit, (e) =>
                {
                    enableTools();
                });

                _rightPanel.anchor(new Vector2(1.0f, 1.0f));
                _rightPanel.size(new Vector2(GUI_RIGHT_PANEL_WIDTH, MainCanvas.Get().canvasSize().y - _topPanel.size().y));
                _rightPanel.position(new Vector2(-_dialog.size().x / 2, - MainCanvas.Get().canvasSize().y / 2 - _topPanel.size().y / 2), GUIObject.POSITION_TYPE.RELATIVE);
                _rightPanel.backgroundColor(backgroundColor);

                // Title Image
                new GUIImage((_obj) =>
                {
                    GUIImage titleImage = _obj as GUIImage;
                    titleImage.name("rightPanelTitleImage");

                    _rightPanel.addChild(titleImage);

                    titleImage.anchor(new Vector2(0.0f, 1.0f));
                    titleImage.position(
                    new Vector2(GUI_PADDING + GUI_DOOR_BUTTON_SIZE.x / 2, -GUI_PADDING - GUI_DOOR_BUTTON_SIZE.y / 2),
                        GUIObject.POSITION_TYPE.RELATIVE);
                    titleImage.size(GUI_DOOR_BUTTON_SIZE);

                    titleImage.hide();
                });

                // Title (text)
                new GUI.GUIText((_obj) =>
                {
                    GUI.GUIText title = _obj as GUI.GUIText;
                    title.name("rightPanelTitle");

                    _rightPanel.addChild(title);

                    title.anchor(new Vector2(0.5f, 1.0f));
                    title.position(
                        new Vector2(0, - GUI_PADDING * 3 - GUI_DOOR_BUTTON_SIZE.y * 1.5f),
                        GUIObject.POSITION_TYPE.RELATIVE);
                    title.size(new Vector2(_rightPanel.size().x - GUI_PADDING * 2, GUI_DOOR_BUTTON_SIZE.y));

                    title.fontSize(20);
                    title.fontColor(Color.white);
                    title.font(_rm.font("Fonts/Sans"));

                    title.hide();
                });

                // Content
                new GUIObject((content) =>
                {
                    content.name("rightPanelContent");

                    _rightPanel.addChild(content);

                    content.anchor(new Vector2(0.5f, 1.0f));
                    content.position(new Vector2(0, - GUI_PADDING * 5 - GUI_DOOR_BUTTON_SIZE.y * 2.5f), GUIObject.POSITION_TYPE.RELATIVE);
                    content.size(new Vector2(_rightPanel.size().x - GUI_PADDING * 2, GUI_DOOR_BUTTON_SIZE.y));

                    content.hide();
                });
            });
        }
コード例 #4
0
        public static void show()
        {
            if (_isShown)
                return;

            _isShown = true;

            Debug.Log("Showing Main Page.");

            // Epoch Escape Title ======================================================================================
            _pageTitle = new GUIImage((_obj) =>
            {
                _pageTitle.position(new Vector2(0, 0.7f));
                _pageTitle.size(new Vector2(800, 120));
                _pageTitle.image(_rm.sprite("Textures/GUI/MainMenu/EpochLevels"));
            });

            _backButton = new GUIButton((_obj) =>
            {
                GUIButton obj = _obj as GUIButton;

                obj.name("backButton");
                obj.position(new Vector2(-0.9f, 0.7f));
                obj.size(ARROW_SIZE);
                obj.setBaseBackground(_rm.sprite("Textures/GUI/Buttons/LeftArrow"), Color.white);
                obj.setOverBackground(_rm.sprite("Textures/GUI/Buttons/LeftArrowHover"), Color.white);
                obj.setDownBackground(_rm.sprite("Textures/GUI/Buttons/LeftArrowHover"), Color.white);

                obj.addListener(EventTriggerType.PointerClick, (e) =>
                {
                    MainPage.show();
                    LevelsPage.hide();
                });
            });

            _levelsContainer = new GUIVerticalDialog((_obj) =>
            {
                GUIVerticalDialog obj = _obj as GUIVerticalDialog;
                obj.name("levelsContainer");

                obj.position(new Vector2(0, -0.2f), GUIObject.POSITION_TYPE.PERCENT);
                obj.size(new Vector2(600, 400));
                obj.overflow(GUI.GUIContent.OVERFLOW_TYPE.HIDE);
                obj.backgroundImage(null);
                obj.backgroundColor(new Color(0, 0, 0, 0.1f));
                obj.contentHeight(800);

                new GUI.GUIText((_level1) =>
                {
                    GUI.GUIText level1 = _level1 as GUI.GUIText;
                    obj.addChild(level1);

                    level1.name("Level1");
                    level1.text("This is the first level");
                    level1.font(Resources.Load<Font>("Fonts/Sans"));
                    level1.fontColor(Color.black);
                });
            });
        }