Наследование: MonoBehaviour
Пример #1
0
    protected void Awake()
    {
        if(sInstance != null)
        {
            Destroy(gameObject);
            return;
        }

        sInstance = this;

        if (mDungeon == null)
        {
            mDungeon = FindObjectOfType<Dungeon>();
        }

        if (mFollowCamera == null)
        {
            mFollowCamera = FindObjectOfType<FollowCamera>();
        }

        if(mFader == null)
        {
            mFader = FindObjectOfType<Fader>();
        }

        GameObject goalObj = SpawnPrefab(mGoalPrefab);
        mGoal = goalObj.GetComponent<Goal>();
        GameObject playerObj = SpawnPrefab(GlobalData.sSelectedCharacter == SelectedCharacter.Rose ? mPlayerRosePrefab : mPlayerVuPrefab);
        mPlayer1 = playerObj.GetComponent<PlayerController>();
        mFollowCamera.Init(mPlayer1.transform);
    }
Пример #2
0
    //-------------------------------------------------------------------------
    //                          METHOD DEFINITIONS
    //-------------------------------------------------------------------------
    void Awake()
    {
        // scale and position start and exit button

        StartButton.SetScale(0.5f);

        float w = StartButton.GetWidth();
        float x = (Screen.width - w - 120);
        float y = Screen.height/3.0f;

        StartButton.SetPosition(new Vector2(x, y));

        ExitButton.SetScale(0.5f);
        w = ExitButton.GetWidth();
        float h = ExitButton.GetHeight();
        x = (Screen.width - w - 120);
        y += h;

        ExitButton.SetPosition(new Vector2(x, y));

        // set the fader for the buttons
        buttonFader_ = new Fader(0.0f, 2.0f, 0.5f);
        backgFader_ = new Fader(0.0f, 5.0f, 5.0f);
        musicFader_ = new Fader(0.0f, 3.0f, 3.0f);

        // set buttons unclickable in the beginning
        StartButton.SetIsClickable(false);
        ExitButton.SetIsClickable(false);
    }
Пример #3
0
    //-------------------------------------------------------------------------
    //                        CLASS METHOD DEFINITIONS
    //-------------------------------------------------------------------------
    void Awake()
    {
        // position the again button
        AgainButton.SetScale(0.25f);
        ExitButton.SetScale(0.25f);

        float off = 50;

        Vector2 pos = new Vector2();
        pos.x = Screen.width/2.0f - (AgainButton.GetWidth() + ExitButton.GetWidth() + 50)/2.0f;
        pos.y = 40.0f;

        AgainButton.SetPosition(pos);

        // position the exit button

        pos.x = Screen.width/2.0f + (ExitButton.GetWidth())/2.0f;
        pos.y = 40.0f;

        ExitButton.SetPosition(pos);

        // set the fading parameters for the beginning fade in of the game
        // over screen
        fader_ = new Fader(0.0f, 3.0f, 3.0f);
        fader_.FadeIn();

        // set the initial update state to fade in
        update_ = fadeIn;
    }
Пример #4
0
    void Start()
    {
        _Fader = (Fader) GameObject.FindObjectOfType(typeof(Fader));
        _Maestro = Maestro.DetectLastInstance();
        _TransitionManager = TransitionManager.Instance;

        _Maestro.FadeIn();
    }
Пример #5
0
	// Use this for initialization
    void Start()
    {
        _renderer = this.GetComponent<Renderer>();
        _fader = this.GetComponent<Fader>();
        _fader.SetColor(this.color);
        _renderer.material.color = color;
        color.a = 255f;
    }
Пример #6
0
 // Use this for initialization
 void Start()
 {
     _rigidbody = this.GetComponent<Rigidbody2D>();
     _fader = this.GetComponent<Fader>();
     _collider = this.GetComponent<Collider2D>();
     this._collider.enabled = false;
     this._originalPosition = this.transform.position;
 }
Пример #7
0
 //-------------------------------------------------------------------------
 void Awake()
 {
     fader = new Fader(0.0f, 3.0f, 0.0f);
     AgainButton.SetScale(0.30f);
     ExitButton.SetScale(0.30f);
     float x = Screen.width - ExitButton.GetWidth();
     AgainButton.SetPosition(new Vector2(x - 405, 655.0f));
     ExitButton.SetPosition(new Vector2(x - 100, 655.0f));
 }
Пример #8
0
 public void Awake()
 {
     if (mFader == null)
     {
         mFader = FindObjectOfType<Fader>();
     }
     mFader.FadeIn();
     PlayMusic();
 }
    private void Awake()
    {
        GlobalData.sSelectedCharacter = SelectedCharacter.None;
        UpdateDisplay();

        if (mFader == null)
        {
            mFader = FindObjectOfType<Fader>();
        }
        mFader.FadeIn();
    }
Пример #10
0
        public ColorPicker(Mode mode, Fader fader)
        {
            _mode=mode;
            _fader=fader;

            InitializeComponent();

            UpdateUI();
            filter=new ShiftKeyFilter();
            filter.ShiftStateChanged+=new EventHandler(filter_ShiftStateChanged);
            Application.AddMessageFilter(filter);
        }
Пример #11
0
    void Awake()
    {
        if (mInstance == null)
        {
            mInstance = this as Fader;

            Instance.blackTexture = new Texture2D(32, 32, TextureFormat.RGB24, false);
            Instance.blackTexture.ReadPixels(new Rect(0, 0, 32, 32), 0, 0, false);
            Instance.blackTexture.SetPixel(0, 0, Color.white);
            Instance.blackTexture.Apply();
        }
    }
Пример #12
0
 protected void PlayCutscene()
 {
     // Fade out and in to indicate time spent.
     AppearanceGameState.INSTANCE.InCutscene = true;
     _fader = new Fader();
     // Fade to black
     StartCoroutine(
         _fader.FadeToBlack(
             2,
             () => StartCoroutine(_fader.FadeInFromBlack(2, () => OnEndCutscene())) // Just fade back in afterwards
         )
     );
 }
Пример #13
0
	// Use this for initialization
	void Awake() {
		gmRef = GameObject.Find("Game Manager").GetComponent<GameManager>();
		fRef = GameObject.Find("Fader").GetComponent<Fader>();

		transform.SetParent(GameObject.Find("Canvas").transform);
		var tr = transform as RectTransform;
		tr.pivot = new Vector2(0, 0);
		tr.localScale = new Vector3(1, 1);
		tr.anchoredPosition3D = new Vector3(30, -70, 0);

		// Вычисление лимита времени на текующий уровень
		cur_lvl_limit = 1 + gmRef.level * 3;
	}
Пример #14
0
	void Awake() {
		fRef = GameObject.Find("Fader").GetComponent<Fader>();
		i1 = GameObject.Find("Intro1").GetComponent<Text>();
		i2 = GameObject.Find("Intro2").GetComponent<Text>();
		i3 = GameObject.Find("Intro3").GetComponent<Text>();
		i4 = GameObject.Find("Intro4").GetComponent<Text>();
		outro = GameObject.Find("Outro").GetComponent<Text>();
		
		b1 = GameObject.Find("Bonus1_icon");
		b2 = GameObject.Find("Bonus2_icon");
		b3 = GameObject.Find("Bonus3_icon");

		HideAllBonusesText();
	}
Пример #15
0
	void Start () {
        initialPosition = HandPositionIndicator.localPosition;

        f = GetComponent<Fader>();
        s = GetComponent<ScrollingMenu>();
        if (!HandPositionIndicator) {
            Debug.LogError("No hand position indicator");
        }
        if (!f) {
            Debug.LogError("No fader");
        }
        if (!s) {
            Debug.LogError("No menu");
        }

        HandPositionIndicator.gameObject.GetComponent<SetColor>().color = DefaultIndicatorColor;
	}
Пример #16
0
	// Use this for initialization
	void Start () {
        if (!fader) {
            fader = GetComponent<Fader>();
        }
        if (!fader) {
            Debug.LogError("Please add a fader to " + gameObject.name);
            return;
        }

        selector = gameObject.AddComponent<ItemSelector>();
        selector.numItems = items.Length;
        selector.scrollRegion = 0.0f;
        selector.fader = fader;

        if (SelectOnPush) {
            if (null == GetComponent<PushDetector>()) {
                gameObject.AddComponent<PushDetector>();
            }
        }
	}
    void Awake()
    {
        if (instance == null) {
            instance = this;
            DontDestroyOnLoad(gameObject);
        } else {
            Destroy(gameObject);
        }
        gameover = GetComponent<GameOverMenu>();
        fader = GetComponent<Fader>();
        gman = GetComponent<GUIManager>();
        pauseScreen = GetComponent<PauseScreen>();
        bgmm = GetComponent<BGMManager>();
        semm = GetComponent<SEManager>();
        GameObject storyController = GameObject.FindGameObjectWithTag(Tags.storyController);
        if (storyController != null) {
            storysemm = storyController.GetComponent<SEManager>();
        }

        paused = false;
    }
Пример #18
0
    public void Awake()
    {
        if(mFader == null)
        {
            mFader = FindObjectOfType<Fader>();
        }

        if(GlobalData.SaveExists())
        {
            mSaveExistsGroup.SetActive(true);
            mFirstTimeGroup.SetActive(false);
        }
        else
        {
            mSaveExistsGroup.SetActive(false);
            mFirstTimeGroup.SetActive(true);
        }

        mFader.FadeIn();
        playTitleTheme();
    }
Пример #19
0
		public ColorPicker(Mode mode, Fader fader)
		{
			_mode = mode;
			_fader = fader;

			InitializeComponent();
			ForeColor = ThemeColorTable.ForeColor;
			BackColor = ThemeColorTable.BackgroundColor;
			ThemeUpdateControls.UpdateControls(this);
			whiteButton.BackColor = System.Drawing.Color.White;
			whiteButton.BackgroundImage = null;
			redButton.BackColor = System.Drawing.Color.Red;
			redButton.BackgroundImage = null;
			greenButton.BackColor = System.Drawing.Color.Green;
			greenButton.BackgroundImage = null;
			blueButton.BackColor = System.Drawing.Color.Blue;
			blueButton.BackgroundImage = null;

			UpdateUI();
			filter = new ShiftKeyFilter();
			filter.ShiftStateChanged += new EventHandler(filter_ShiftStateChanged);
			Application.AddMessageFilter(filter);
		}
Пример #20
0
    //Make faders connection to this object and start fader
    private void activateFader(Fader.FADE_STATE pState)
    {
        if (isLocalPlayer && bIsHuman){
          GameObject goFader;
          //Get the fader

          if (SceneManager.GetActiveScene() == SceneManager.GetSceneByName ("_Main"))
        goFader = GameObject.Find ("MainMenu").transform.FindChild ("Fader").gameObject;
          else
        goFader = GameObject.Find ("UI").transform.FindChild ("Canvas").FindChild ("Fader").gameObject;

          if (pState == Fader.FADE_STATE.FadeOut)
        goFader.SetActive (true);

          Fader fader = goFader.GetComponent<Fader>();//GameObject.FindGameObjectWithTag ("Fader").GetComponent<Fader> ();
          fader._NP = this;
          fader.setFadeState (pState, true);
        }
    }
Пример #21
0
 void Awake()
 {
     _screenFader = this;
     _canvasGroup = GetComponent<CanvasGroup> ();
 }
Пример #22
0
 public void InstantFadeIn()
 {
     Fader.Canvas_InstantOpaque(cvsGrp);
 }
 private void Awake()
 {
     currentFader = GetComponent<Fader>();
     Initialize();
 }
Пример #24
0
 public void OutWithMethod()
 {
     SetPointer(false);
     Fader.FadeToBlack((b) => OutMethod(b));
 }
Пример #25
0
 void Play()
 {
     Fader.FadeTo(SceneEnum.Game, Color.black, 1.5f);
 }
Пример #26
0
 public void Start()
 {
     _fader = (Fader)FindObjectOfType(typeof(Fader));
 }
Пример #27
0
 void Start()
 {
     fader = new Fader(1.0f, 0.0f, 0.5f);
     fader.FadeOut();
 }
Пример #28
0
 private void Start()
 {
     _fader = GetComponent <Fader>();
     StartCoroutine(LoadGame());
 }
 private void Start()
 {
     fader = FindObjectOfType <Fader>();
 }
Пример #30
0
    /// <summary>
    /// Triggers the screen to fade in and then invokes the action given
    /// </summary>
    /// <param name="transitionTo"></param>
    /// <returns></returns>
    IEnumerator FadeScreenAndTransitionTo(Action transitionTo)
    {
        yield return(StartCoroutine(Fader.FadeRoutine(0f, 1f, m_fadeOutDelay)));

        transitionTo?.Invoke();
    }
Пример #31
0
    /// <summary>
    /// Fades the screen in and enables gameplay
    /// </summary>
    /// <returns></returns>
    IEnumerator LoadLevelRoutine()
    {
        yield return(StartCoroutine(Fader.FadeRoutine(1f, 0f, m_fadeInDelay)));

        IsLevelLoaded = true;
    }
Пример #32
0
    public IEnumerator FadeBack()
    {
        yield return(new WaitForSeconds(3));

        Fader.FadeToClear((b => SetPointer(true)));
    }
Пример #33
0
 public PopupView()
 {
     m_aeroEnabled = false;
     Fader         = new Fader(this, this);
     InitializeComponent();
 }
Пример #34
0
 public void Start()
 {
     Instance = this;
     State    = new FaderInState(this, Duration); //FaderInState is always used, when the scene starts.
 }
Пример #35
0
    //-------------------------------------------------------------------------
    //                        CLASS METHOD DEFINITIONS
    //-------------------------------------------------------------------------
    void Awake()
    {
        manager = GetComponent<InteractableManager>();
        manager.Register(this);
        updateHandler_ = sceneIntro;

        // play the cell door sound
        CellDoorSoundSound.Play();

        // play background music but set volume to 0.
        // also set the fader for the bgm
        BackgroundMusic.Play();
        BackgroundMusic.Loop(true);
        BackgroundMusic.SetVolume(0.0f);

        bgmFader_ = new Fader(0.0f, 30.0f, 0.0f);

        //
        introBgFader_ = new Fader(1.0f, 0.0f, 5.0f);
    }
Пример #36
0
 public IObservable <Unit> AnimateOut()
 {
     return(Fader.FadeOut().OnCompleteAsObservable());
 }
Пример #37
0
 private void Awake()
 {
     fader           = FindObjectOfType <Fader>();
     inVictoryScreen = false;
 }
Пример #38
0
 private static void SetFader(DependencyObject obj, Fader value)
 {
     obj.SetValue(FaderProperty, value);
 }
Пример #39
0
 public void OnLevelWasLoaded()
 {
     DebugMessage("Level was successfully loaded.");
     _fader = (Fader)FindObjectOfType(typeof(Fader));
 }
Пример #40
0
 void Awake()
 {
     fader       = faderObj.GetComponent <Fader> ();
     isDead      = false;
     fireCounter = fireRate;
 }
Пример #41
0
 public void InstantFadeOut()
 {
     Fader.Canvas_InstantTransparent(cvsGrp);
 }
Пример #42
0
        public void PaintTopInGame(ClipState clipState)
        {
            if (clipState != ClipState.AfterClip)
            {
                return;
            }

            var visible = TurnedOn && Hud.Game.Quests.Any(quest => quest.SnoQuest.Type == QuestType.Bounty);

            if (!Fader.TestVisiblity(visible))
            {
                return;
            }

            var w = Hud.Window.Size.Height / 3f * 4f * 0.9f;
            var h = Hud.Window.Size.Height * 0.7f;
            var x = (Hud.Window.Size.Width - w) / 2;
            var y = (Hud.Window.Size.Height - h) / 2;

            var backgroundTexture       = Hud.Texture.GetTexture("BattleNetContextMenu_Title");
            var backgroundTextureBottom = Hud.Texture.GetTexture("BattleNetContextMenu_Bottom");
            var bountyCompleteTexture   = Hud.Texture.GetTexture("WaypointMap_MarkerBountyComplete");

            var sizeH = h / 8.0f;
            var sizeW = w / 5.0f;

            var bountyCompleteH = bountyCompleteTexture.Height / 1200.0f * Hud.Window.Size.Height;
            var bountyCompleteW = bountyCompleteTexture.Width / (bountyCompleteTexture.Height / bountyCompleteH);

            for (var act = 1; act <= 5; act++)
            {
                var ax = x + (sizeW * (act - 1));
                var ay = y + (Hud.Window.Size.Height * 0.032f);

                var completedCount = 0;
                foreach (var bountyType in BountyTypes)
                {
                    foreach (var quest in Hud.Game.Quests.Where(quest => quest.SnoQuest.Type == QuestType.Bounty))
                    {
                        if ((quest.SnoQuest.SnoAct == null) || (quest.SnoQuest.SnoAct.Index != act))
                        {
                            continue;
                        }
                        if (quest.SnoQuest.BountyType != bountyType)
                        {
                            continue;
                        }
                        if (quest.State == QuestState.completed)
                        {
                            completedCount++;
                        }
                        backgroundTexture.Draw(ax, ay, sizeW, sizeH, Opacity);

                        var ty = ay + (sizeH * 0.22f);

                        // var tf = quest.State != QuestState.completed ? (Engine.BountiesToHighlight.Exists(quest.SnoQuest.Sno) ? tfBountyNameHighlighted : tfBountyName) : tfBountyNameCompleted;
                        var tf         = quest.State != QuestState.completed ? BountyNameFont : BountyNameCompletedFont;
                        var textLayout = tf.GetTextLayout(quest.SnoQuest.NameLocalized);
                        tf.DrawText(textLayout, ax + ((sizeW - textLayout.Metrics.Width) / 2), ty);

                        switch (quest.State)
                        {
                        case QuestState.none:
                        {
                            textLayout = BountyWaypointAreaFont.GetTextLayout(quest.SnoQuest.BountySnoArea.NameLocalized);
                            BountyWaypointAreaFont.DrawText(textLayout, ax + ((sizeW - textLayout.Metrics.Width) / 2), ay + (sizeH * 0.65f) - textLayout.Metrics.Height);
                        }

                        break;

                        case QuestState.started:
                        {
                            if (quest.StartedOn != null)
                            {
                                var elapsed = quest.StartedOn.ElapsedMilliseconds;
                                var text    = ValueToString(elapsed * TimeSpan.TicksPerMillisecond, ValueFormat.LongTime);
                                textLayout = InprogressTimerFont.GetTextLayout(text);
                                InprogressTimerFont.DrawText(textLayout, ax + ((sizeW - textLayout.Metrics.Width) / 2), ay + (sizeH * 0.65f) - textLayout.Metrics.Height);
                            }
                        }

                        break;

                        case QuestState.completed:
                        {
                            long elapsed = 0;
                            if (quest.StartedOn != null)
                            {
                                elapsed = quest.StartedOn.ElapsedMilliseconds;
                                if (quest.CompletedOn != null)
                                {
                                    elapsed -= quest.CompletedOn.ElapsedMilliseconds;
                                }
                            }

                            if (elapsed > 0)
                            {
                                var text = ValueToString(elapsed * TimeSpan.TicksPerMillisecond, ValueFormat.LongTime);
                                textLayout = tf.GetTextLayout(text);

                                var tx = ax + ((sizeW - (bountyCompleteW * 0.75f) - textLayout.Metrics.Width) / 2) - (bountyCompleteW * 0.25f);
                                bountyCompleteTexture.Draw(tx, ay + ((sizeH - bountyCompleteH) * 0.7f), bountyCompleteW, bountyCompleteH, Opacity * 0.5f);

                                tf.DrawText(textLayout, tx + (bountyCompleteW * 0.75f), ay + (sizeH * 0.65f) - textLayout.Metrics.Height);
                            }
                            else
                            {
                                var tx = ax + ((sizeW - bountyCompleteW) / 2);
                                bountyCompleteTexture.Draw(tx, ay + ((sizeH - bountyCompleteH) * 0.7f), bountyCompleteW, bountyCompleteH, Opacity * 0.5f);
                            }
                        }

                        break;
                        }

                        ay += sizeH * 0.75f;

                        var bottomSizeH = backgroundTextureBottom.Height / backgroundTextureBottom.Width * sizeW;
                        backgroundTextureBottom.Draw(ax, ay, sizeW, bottomSizeH, Opacity);
                        ay += bottomSizeH / 2;
                    }
                }

                var actHeaderTexture = Hud.Texture.GetTexture("WaypointMap_ButtonAct" + act.ToString("D", CultureInfo.InvariantCulture) + (act == Hud.Game.CurrentAct ? "Over" : "Up"));
                var th = actHeaderTexture.Height / 1200.0f * Hud.Window.Size.Height;
                var tw = actHeaderTexture.Width / (actHeaderTexture.Height / th);
                actHeaderTexture.Draw(ax + ((sizeW - tw) / 2), y - (Hud.Window.Size.Height * 0.048f), tw, th, Opacity * (completedCount == 5 ? 0.5f : 1.0f));

                if (completedCount == 5)
                {
                    bountyCompleteTexture.Draw(ax + ((sizeW - bountyCompleteW) / 2), y - (Hud.Window.Size.Height * 0.042f), bountyCompleteW, bountyCompleteH, Opacity);
                }
            }
        }
Пример #43
0
 void ReferenceCoroutines()
 {
     fadeToOpaque      = Fader.Canvas_FadeToOpaque(cvsGrp, fadeSpeed);
     fadeToTransparent = Fader.Canvas_FadeToTransparent(cvsGrp, fadeSpeed);
 }
Пример #44
0
    public static void UpdateVolumes(InAudioBus bus)
    {
        Fader fader = bus.Fader;

        if (fader.Activated)
        {
            double currentTime = AudioSettings.dspTime;
            bus.RuntimeSelfVolume = (float)fader.Lerp(AudioSettings.dspTime);
            bus.Dirty             = true;
            if (/*bus.RuntimeSelfVolume == fader.EndValue ||*/ currentTime >= fader.EndTime)
            {
                fader.Activated = false;
            }
        }

        float parentVolume;

        if (bus.Parent != null)
        {
            var busParent = bus.Parent;
            parentVolume = busParent.FinalVolume;
        }
        else
        {
            parentVolume = 1.0f;
        }

        if (bus.Parent != null)
        {
            bus.Dirty |= bus.Parent.Dirty;
        }

        float oldVolume = bus.FinalVolume;

        bus.FinalVolume = bus.Volume * bus.RuntimeSelfVolume * parentVolume;

        float duckingVolume = Ducking(bus);

        bus.FinalVolume += duckingVolume;

        if (bus.RuntimeMute)
        {
            bus.FinalVolume = 0;
        }

        if (bus.FinalVolume != oldVolume)
        {
            bus.Dirty = true;
        }

        bool    noListener = false;
        Vector3 pos        = Vector3.zero;

        if (InAudio.ActiveListener == null)
        {
            noListener = true;
        }
        else
        {
            pos = InAudio.ActiveListener.transform.position;
        }
        var players = bus.RuntimePlayers;

        for (int i = 0; i < players.Count; ++i)
        {
            var player = players[i];

            if (player != null)
            {
                if (!noListener)
                {
                    player.internalUpdateFalloff(pos);
                }
                if (bus.Dirty)
                {
                    player.UpdateBusVolume(bus.FinalVolume);
                }
            }
            else
            {
                players.RemoveAt(i);
                --i;
            }
        }
        if (bus.Dirty)
        {
            for (int i = 0; i < bus.ExternalSources.Count; i++)
            {
                bus.ExternalSources[i].UpdateBusVolume(bus.FinalVolume);
            }
        }

        for (int i = 0; i < bus.Children.Count; ++i)
        {
            bus.Children[i].Dirty |= bus.Dirty;
            UpdateVolumes(bus.Children[i]);
        }

        bus.Dirty = false;
    }
Пример #45
0
 public void RpcActivateFader(Fader.FADE_STATE pState)
 {
     activateFader (pState);
 }
Пример #46
0
 private void Awake()
 {
     instance = this;
     anim     = GetComponent <Animator>();
 }
 public void Start()
 {
     _fader = (Fader) FindObjectOfType(typeof(Fader));
 }
Пример #48
0
 private void Start()
 {
     Instance = this;
 }
Пример #49
0
	void Start()
	{
        pushFader = gameObject.AddComponent<Fader>();
        pushFader.direction = -Vector3.forward;
	}
Пример #50
0
 /// <summary>
 ///Initializes a new FaderOutState object.
 /// </summary>
 /// <param name="fader"></param>
 /// <param name="stateActive"></param>
 /// <param name="duration"></param>
 public FaderInState(Fader fader, float duration)
 {
     Fader = fader;
     Setup(duration);
 }
Пример #51
0
 void Start()
 {
     fader = new Fader(1.0f, 0.0f, 0.5f);
     fader.FadeOut();
 }
Пример #52
0
        private void SetupUI(Client client)
        {
            var viewportSize = (Vector2)client.Viewport.Size;

            Vector2 center = viewportSize / 2;

            center.X -= 200;

            this.fader = new Fader()
            {
                Colour   = Colours.Background,
                Position = Vector2.Zero,
                Size     = viewportSize,
                ZOrder   = 1
            };

            this.title = new Text()
            {
                Colour   = Colours.Forground,
                IsTitle  = true,
                Value    = "PONG",
                Position = new Vector2(center.X, center.Y - 100),
                Origin   = new Vector2(0f, 1f)
            };

            var         btnPosition = center;
            const float btnSpacing  = 100f;

            this.newgame = new TextButton()
            {
                Colour      = Colours.Forground,
                HoverColour = Colours.Hover,
                Text        = "New Game",
                Position    = btnPosition,
                Origin      = new Vector2(0f, 0.5f),
                OnClick     = () =>
                {
                    this.fader.FadeOut(() => client.ChangeScene(1, new OfflineHost(this.Application)));
                    this.container.Interactive = false;
                }
            };

            btnPosition.Y += btnSpacing;

            this.exit = new TextButton()
            {
                Colour      = Colours.Forground,
                HoverColour = Colours.Hover,
                Text        = "Exit",
                Position    = btnPosition,
                Origin      = new Vector2(0f, 0.5f),
                OnClick     = () =>
                {
                    this.fader.FadeOut(client.Close);
                    this.container.Interactive = false;
                }
            };

            this.container.AddElement(this.fader);
            this.container.AddElement(this.title);
            this.container.AddControl(this.newgame);
            this.container.AddControl(this.exit);
        }
Пример #53
0
 void Awake()
 {
     instance = this;
 }
Пример #54
0
 void Awake()
 {
     fadeScript = GameObject.Find("Fader").GetComponent <Fader>();
     // lose = GameObject.Find("LoseScreen").GetComponent<CanvasGroup>();
 }
Пример #55
0
 //-------------------------------------------------------------------------
 //                          METHOD DEFINITIONS
 //-------------------------------------------------------------------------
 void Start()
 {
     musicFader_ = new Fader(0.0f, 10.0f, 4.0f);
     musicFader_.FadeIn();
     imseqFader_ = new Fader(1.0f, 0.0f, 4.0f);
 }
Пример #56
0
 public void Start()
 {
     _sceneChange = TransitionManager.Instance;
     _fader       = (Fader)FindObjectOfType(typeof(Fader));
 }
Пример #57
0
 public static void Crossfade(Fader fadeIn, Fader fadeOut)
 {
     fadeIn.Fade(FadeType.In);
     fadeOut.Fade(FadeType.Out);
 }
Пример #58
0
 void Start()
 {
     pushFader           = gameObject.AddComponent <Fader>();
     pushFader.direction = -Vector3.forward;
 }
Пример #59
0
        private static void HandleIsEnabledChanged(DependencyObject source, DependencyPropertyChangedEventArgs e)
        {
            var textBlock = source as TextBlock;
            if (textBlock == null)
            {
                return;
            }

            if ((bool)e.OldValue)
            {
                var fader = GetFader(textBlock);
                if (fader != null)
                {
                    fader.Detach();
                    SetFader(textBlock, null);
                }

                textBlock.Loaded -= HandleTextBlockLoaded;
                textBlock.Unloaded -= HandleTextBlockUnloaded;
            }

            if ((bool)e.NewValue)
            {
                textBlock.Loaded += HandleTextBlockLoaded;
                textBlock.Unloaded += HandleTextBlockUnloaded;

                var fader = new Fader(textBlock);
                SetFader(textBlock, fader);
                fader.Attach();
            }
        }
Пример #60
0
 private void onActive()
 {
     fading = GetComponent <Fader>();
     fading.FadeIn();
 }