Example #1
0
        public void ConnectToServer(IPEndPoint endPoint)
        {
            // ToDo
            const string token = "J²";

            if (net != null)
            {
                net.OnDisconnected -= OnNetworkDisconnected;
                net.Close();
            }

            byte[] clientIdentifier = Preferences.Get <byte[]>("ClientIdentifier");
            if (clientIdentifier == null)
            {
                // Generate new client identifier
                Guid guid = Guid.NewGuid();
                clientIdentifier = guid.ToByteArray();
                Preferences.Set <byte[]>("ClientIdentifier", clientIdentifier);
                Preferences.Commit();
            }

            net = new NetworkHandler(token, clientIdentifier);
            net.OnDisconnected += OnNetworkDisconnected;
            net.RegisterCallback <LoadLevel>(OnNetworkLoadLevel);
            net.Connect(endPoint);
        }
Example #2
0
        private void Commit()
        {
            Resize      = (ResizeMode)resizeMode.SelectedIndex;
            MusicVolume = musicVolume.CurrentValue;
            SfxVolume   = sfxVolume.CurrentValue;

            Preferences.Set("Resize", (byte)Resize);
            Preferences.Set("MusicVolume", (byte)(MusicVolume * 100));
            Preferences.Set("SfxVolume", (byte)(SfxVolume * 100));

#if __ANDROID__
            Duality.Android.InnerView.allowVibrations = (vibrations.SelectedIndex == 1);
            Preferences.Set("Vibrations", Duality.Android.InnerView.allowVibrations);
#else
            ScreenMode newScreenMode;
            switch (screenMode.SelectedIndex)
            {
            default:
            case 0: newScreenMode = ScreenMode.Window; break;

            case 1: newScreenMode = ScreenMode.FullWindow; break;
            }
            api.ScreenMode = newScreenMode;

            Preferences.Set("Screen", screenMode.SelectedIndex);
#endif

            Preferences.Commit();
        }
Example #3
0
        private void ApplyRescaleMode(ResizeMode mode)
        {
            Resize = mode;

            Preferences.Set("Resize", (byte)Resize);
            Preferences.Commit();

            api.LeaveSection(this);
        }
Example #4
0
        private void Commit()
        {
            Resize = (ResizeMode)((ChoiceControl)controls[0]).SelectedIndex;

#if __ANDROID__
            Duality.Android.InnerView.allowVibrations = ((ChoiceControl)controls[1]).SelectedIndex == 1;

            Preferences.Set("Vibrations", Duality.Android.InnerView.allowVibrations);
#endif

            Preferences.Commit();
        }
Example #5
0
        private void Commit()
        {
            string currentLanguage = availableLanguages[language.SelectedIndex];

            i18n.Language = currentLanguage;
            Preferences.Set("Language", currentLanguage);

#if !PLATFORM_WASM
            MusicVolume = musicVolume.CurrentValue;
            SfxVolume   = sfxVolume.CurrentValue;

            Preferences.Set("MusicVolume", (byte)(MusicVolume * 100));
            Preferences.Set("SfxVolume", (byte)(SfxVolume * 100));
#endif

#if PLATFORM_ANDROID
            Android.InnerView.AllowVibrations = (vibrations.SelectedIndex == 1);
            Preferences.Set("Vibrations", Android.InnerView.AllowVibrations);

            Android.InnerView.LeftPadding = leftPadding.CurrentValue;
            Preferences.Set("LeftPadding", (byte)(Android.InnerView.LeftPadding * 1000));

            Android.InnerView.RightPadding = rightPadding.CurrentValue;
            Preferences.Set("RightPadding", (byte)(Android.InnerView.RightPadding * 1000));

            Android.InnerView.BottomPadding1 = bottomPadding1.CurrentValue;
            Preferences.Set("BottomPadding1", (byte)((Android.InnerView.BottomPadding1 * 500) + 128));

            Android.InnerView.BottomPadding2 = bottomPadding2.CurrentValue;
            Preferences.Set("BottomPadding2", (byte)((Android.InnerView.BottomPadding2 * 500) + 128));
#elif !PLATFORM_WASM
            ScreenMode newScreenMode;
            switch (screenMode.SelectedIndex)
            {
            default:
            case 0: newScreenMode = ScreenMode.Window; break;

            case 1: newScreenMode = ScreenMode.FullWindow; break;
            }
            api.ScreenMode = newScreenMode;
            Preferences.Set("Screen", screenMode.SelectedIndex);

            api.RefreshMode = (RefreshMode)refreshMode.SelectedIndex;
            Preferences.Set("RefreshMode", refreshMode.SelectedIndex);
#endif

            Preferences.Commit();
        }
Example #6
0
        public void ConnectToServer(IPEndPoint endPoint)
        {
            // ToDo
            const string Token = "J²";

            if (client != null)
            {
                client.OnDisconnected -= OnPacketDisconnected;
                client.Close();
            }

            byte[] clientIdentifier = Preferences.Get <byte[]>("ClientIdentifier");
            if (clientIdentifier == null)
            {
                // Generate new client identifier
                Guid guid = Guid.NewGuid();
                clientIdentifier = guid.ToByteArray();
                Preferences.Set <byte[]>("ClientIdentifier", clientIdentifier);
                Preferences.Commit();
            }

            string userName = Preferences.Get <string>("UserName");

            if (userName == null)
            {
                userName = TryGetDefaultUserName();
                if (!string.IsNullOrEmpty(userName))
                {
                    Preferences.Set <string>("UserName", userName);
                    Preferences.Commit();
                }
            }

            ControlScheme.IsSuspended = true;

            client = new GameClient(Token, clientIdentifier, userName);
            client.OnDisconnected += OnPacketDisconnected;
            client.AddCallback <LoadLevel>(OnPacketLoadLevel);
            client.Connect(endPoint);
        }
Example #7
0
        public void ChangeLevel(LevelInitialization levelInit = default(LevelInitialization))
        {
            ContentResolver.Current.ResetReferenceFlag();

            if (string.IsNullOrEmpty(levelInit.LevelName))
            {
                // Next level not specified, so show main menu
                ShowMainMenu(false);
            }
            else if (levelInit.LevelName == ":end")
            {
                // End of episode

                if (!string.IsNullOrEmpty(levelInit.LastEpisodeName) && levelInit.LastEpisodeName != "unknown")
                {
                    // ToDo: Implement time
                    Preferences.Set("EpisodeEnd_Time_" + levelInit.LastEpisodeName, (int)1);

                    if (levelInit.PlayerCarryOvers.Length == 1)
                    {
                        // Save CarryOvers only in SinglePlayer mode
                        ref PlayerCarryOver player = ref levelInit.PlayerCarryOvers[0];

                        Preferences.Set("EpisodeEnd_Lives_" + levelInit.LastEpisodeName, (byte)player.Lives);
                        Preferences.Set("EpisodeEnd_Score_" + levelInit.LastEpisodeName, player.Score);
                        if (player.Ammo != null)
                        {
                            Preferences.Set("EpisodeEnd_Ammo_" + levelInit.LastEpisodeName, player.Ammo);
                        }

                        // Save WeaponUpgrades only if at least one of them is upgraded
                        if (player.WeaponUpgrades != null)
                        {
                            for (int i = 0; i < player.WeaponUpgrades.Length; i++)
                            {
                                if (player.WeaponUpgrades[i] != 0)
                                {
                                    Preferences.Set("EpisodeEnd_Upgrades_" + levelInit.LastEpisodeName, player.WeaponUpgrades);
                                    break;
                                }
                            }
                        }
                    }

                    // Remove existing continue data
                    Preferences.Remove("EpisodeContinue_Misc_" + levelInit.LastEpisodeName);
                    Preferences.Remove("EpisodeContinue_Score_" + levelInit.LastEpisodeName);
                    Preferences.Remove("EpisodeContinue_Level_" + levelInit.LastEpisodeName);
                    Preferences.Remove("EpisodeContinue_Ammo_" + levelInit.LastEpisodeName);
                    Preferences.Remove("EpisodeContinue_Upgrades_" + levelInit.LastEpisodeName);

                    Preferences.Commit();

                    Episode lastEpisode = GetEpisode(levelInit.LastEpisodeName);
                    if (lastEpisode != null && !string.IsNullOrEmpty(lastEpisode.NextEpisode))
                    {
                        // Redirect to next episode
                        Episode nextEpisode = GetEpisode(lastEpisode.NextEpisode);

                        levelInit.EpisodeName = lastEpisode.NextEpisode;
                        levelInit.LevelName   = nextEpisode.FirstLevel;

                        // Start new level
                        LevelHandler handler = new LevelHandler(this, levelInit);

                        Scene.Current.DisposeLater();
                        Scene.SwitchTo(handler);

                        GCSettings.LargeObjectHeapCompactionMode = GCLargeObjectHeapCompactionMode.CompactOnce;
                        GC.Collect();
                        GC.WaitForPendingFinalizers();

                        GCSettings.LatencyMode = GCLatencyMode.LowLatency;

                        UpdateRichPresence(levelInit, null);
                    }
                    else
                    {
                        // Next episode not found...
                        ShowMainMenu(false);
                    }
                }
                else
                {
                    // Shouldn't happen...
                    ShowMainMenu(false);
                }
            }
Example #8
0
        public override void OnUpdate()
        {
            if (selectAnimation < 1f)
            {
                selectAnimation = Math.Min(selectAnimation + Time.TimeMult * 0.016f, 1f);
            }

            if (expanded && expandedAnimation < 1f)
            {
                expandedAnimation = Math.Min(expandedAnimation + Time.TimeMult * 0.016f, 1f);
            }

            if (ControlScheme.MenuActionHit(PlayerActions.Fire))
            {
                if (episodes.Count > 0 && episodes[selectedIndex].IsAvailable)
                {
                    api.PlaySound("MenuSelect", 0.5f);

                    if (episodes[selectedIndex].CanContinue)
                    {
                        if (expanded)
                        {
                            // Restart episode
                            // Clear continue data
                            string episodeName = episodes[selectedIndex].Episode.Token;
                            Preferences.Remove("EpisodeContinue_Misc_" + episodeName);
                            Preferences.Remove("EpisodeContinue_Level_" + episodeName);
                            Preferences.Remove("EpisodeContinue_Ammo_" + episodeName);
                            Preferences.Remove("EpisodeContinue_Upgrades_" + episodeName);

                            Preferences.Commit();

                            episodes.Data[selectedIndex].CanContinue = false;
                            expanded          = false;
                            expandedAnimation = 0f;

                            api.SwitchToSection(new StartGameOptionsSection(
                                                    episodes[selectedIndex].Episode.Token,
                                                    episodes[selectedIndex].Episode.FirstLevel,
                                                    episodes[selectedIndex].Episode.PreviousEpisode
                                                    ));
                        }
                        else
                        {
                            ControlScheme.IsSuspended = true;

                            api.BeginFadeOut(() => {
                                ControlScheme.IsSuspended = false;

                                string episodeName = episodes[selectedIndex].Episode.Token;
                                string levelName   = Preferences.Get <string>("EpisodeContinue_Level_" + episodeName);

                                // Lives, Difficulty and PlayerType is saved in Misc array [Jazz2.Core/Game/Controller.cs: ~146]
                                byte[] misc = Preferences.Get <byte[]>("EpisodeContinue_Misc_" + episodeName);

                                LevelInitialization carryOver = new LevelInitialization(
                                    episodeName,
                                    levelName,
                                    (GameDifficulty)misc[1],
                                    (PlayerType)misc[2]
                                    );

                                ref PlayerCarryOver player = ref carryOver.PlayerCarryOvers[0];

                                if (misc[0] > 0)
                                {
                                    player.Lives = misc[0];
                                }

                                short[] ammo = Preferences.Get <short[]>("EpisodeContinue_Ammo_" + episodeName);
                                if (ammo != null)
                                {
                                    player.Ammo = ammo;
                                }

                                byte[] upgrades = Preferences.Get <byte[]>("EpisodeContinue_Upgrades_" + episodeName);
                                if (upgrades != null)
                                {
                                    player.WeaponUpgrades = upgrades;
                                }

                                api.SwitchToLevel(carryOver);
                            });