示例#1
0
    public void ResetMidLevelState(SaveWhen type)
    {
        if (!(type == SaveWhen.MidLevel || type == SaveWhen.GoBack1 || type == SaveWhen.GoBack2))
        {
            return;
        }
        int latest_wave = getLatestMidLevel().current_wave;

        int looking_for_wave = (type == SaveWhen.MidLevel)? latest_wave : (type == SaveWhen.GoBack1) ? latest_wave - 1 : latest_wave - 2;

        if (looking_for_wave <= 0)
        {
            return;
        }

        for (int i = 0; i < midlevels.Length; i++)
        {
            if (midlevels[i].current_wave == looking_for_wave)
            {
                midlevels[i] = getMidLevelState(type);
                midlevels[i] = new SaveState();
                midlevels[i].current_wave = -1;
            }
        }
    }
示例#2
0
    public SaveState getMidLevelState(SaveWhen type)
    {
        if (!(type == SaveWhen.MidLevel || type == SaveWhen.GoBack1 || type == SaveWhen.GoBack2))
        {
            return(null);
        }

        int latest_wave      = getLatestMidLevel().current_wave;
        int looking_for_wave = (type == SaveWhen.MidLevel) ? latest_wave : (type == SaveWhen.GoBack1) ? latest_wave - 1 : latest_wave - 2;

        if (looking_for_wave < 0)
        {
            return(null);
        }

        foreach (SaveState state in midlevels)
        {
            if (state.current_wave == looking_for_wave)
            {
                return(state);
            }
        }
        return(null);
    }
示例#3
0
    public void SaveGame(SaveWhen type)
    {
        if (LevelBalancer.Instance.am_enabled)
        {
            return;
        }
        // Debug.Log("maybe saving game " + type + "\n");
        if (!(type == SaveWhen.MidLevel || type == SaveWhen.EndOfLevel || type == SaveWhen.BetweenLevels))
        {
            Debug.Log("Cannot save game, unsupported SaveWhen type " + type + "\n");
            return;
        }


        EagleEyes.Instance.RunSavingGameVisual();

        Debug.Log("!!!SAVING GAME " + type + "\n");

        SaveState midlevel   = games[current_savegame_id].getOldestMidLevel();
        SaveState persistent = games[current_savegame_id].getSaveState(SaveStateType.Persistent);

        switch (type)
        {
        case SaveWhen.MidLevel:     //save


            midlevel.SaveBasicMidLevelShit();
            midlevel.type = SaveStateType.MidLevel;
            midlevel.SaveIslands();        //ToySaver and other stuff ok
            midlevel.SaveWishes();         //deepclone
            midlevel.SaveEvents();         //meh int and a list of strings that never change
            midlevel.SaveRewards();        //deepclone
            midlevel.SaveSkillInventory(); //deepclone
            midlevel.SaveHeroStats();      //list of RuneSavers getSnapshot
            midlevel.SaveToyStats();       // list of unitStatSavers getSnapshot
            midlevel.SaveScore();          // need to save possible wishes etc
            midlevel.SaveFakePlayer();

            break;

        case SaveWhen.EndOfLevel:       //save

            persistent.SaveWishes();
            persistent.SaveToyStats();
            persistent.SaveHeroStats();
            persistent.SaveRewards();
            persistent.SaveSkillInventory();
            persistent.SaveScore();
            persistent.current_level = Central.Instance.getCurrentLevel();
            persistent.current_level++;
            games[current_savegame_id].InitMidLevel();

            //INCREMENT LEVEL SOMEWHERE
            break;

        case SaveWhen.BetweenLevels:       //save

            persistent.SaveScore();
            persistent.SaveHeroStats();
            persistent.SaveSkillInventory();
            persistent.SaveWishes();     //marketplace
            persistent.SaveRewards();    //for intralevel events
            break;
        }

        games[current_savegame_id].SaveFile();
        games[current_savegame_id].LoadFile("");
        if (onSaveCompleteStartWave != null)
        {
            onSaveCompleteStartWave();
        }
    }
示例#4
0
    public bool LoadGame(SaveWhen type)
    {
        //if (!(type == SaveWhen.MidLevel || type == SaveWhen.BetweenLevels|| type == SaveWhen.BeginningOfLevel))
        if (type == SaveWhen.Null || type == SaveWhen.EndOfLevel)
        {
            Debug.Log("Cannot load game, unsupported SaveWhen type " + type + "\n");
            return(false);
        }


        if (FakeRunner.Instance != null && FakeRunner.Instance.hasFakePlayer())
        {
            FakeRunner.Instance.current_player.fake_player.Stop();
        }
        RewardOverseer.RewardInstance.StopOverseer();

        games[Current_savegame_id].LoadFile("");

        //bool ok = true;

        SaveState midlevel   = games[current_savegame_id].getMidLevelState(type);
        SaveState persistent = games[current_savegame_id].getSaveState(SaveStateType.Persistent);

        Debug.Log("!!!!!!! Loading game " + type + "\n");
        switch (type)
        {
        case SaveWhen.GoBack1:
        case SaveWhen.GoBack2:
        case SaveWhen.MidLevel:
            //load

            Tracker.Log(PlayerEvent.LoadGame, false,
                        customAttributes: new Dictionary <string, string>()
            {
                { "attribute_2", Peripheral.Instance.difficulty.ToString() },
                { "attribute_1", type.ToString() }
            },
                        customMetrics: new Dictionary <string, double> {
                { "metric_1", midlevel.current_level }
            });

            if (type == SaveWhen.GoBack1)
            {
                games[current_savegame_id].ResetMidLevelState(SaveWhen.MidLevel);
            }
            if (type == SaveWhen.GoBack2)
            {
                games[current_savegame_id].ResetMidLevelState(SaveWhen.MidLevel);
                games[current_savegame_id].ResetMidLevelState(SaveWhen.GoBack1);
            }

            midlevel.LoadRewards();
            midlevel.LoadSkillsInventory(false);
            Peripheral.Instance.LoadBasicMidLevelShit(midlevel);

            midlevel.LoadWishes();
            //persistent.LoadScore();
            midlevel.LoadScore(false);
            midlevel.LoadHeroStats();
            midlevel.LoadEvents();
            midlevel.LoadToyStats();

            //if (FakePlayer.Instance != null) midlevel.LoadFakePlayer();
            if (FakeRunner.Instance != null && FakeRunner.Instance.hasFakePlayer())
            {
                midlevel.LoadFakePlayer();
            }

            Central.Instance.updateCost(Peripheral.Instance.getToys());
            EagleEyes.Instance.UpdateToyButtons("blah", ToyType.Null, false);     // UpdateToyButtons does not happen by default on changeState
            Peripheral.Instance.my_skillmaster.my_panel.UpdatePanel();


            Central.Instance.changeState(GameState.InGame);
            Peripheral.Instance.Pause(false);
            if (type == SaveWhen.GoBack1 || type == SaveWhen.GoBack2)
            {
                games[current_savegame_id].SaveFile();
            }

            break;

        case SaveWhen.BetweenLevels:                        //load


            persistent.LoadScore(true);
            persistent.LoadHeroStats();
            persistent.LoadRewards();
            persistent.LoadWishes();     //marketplace
            //persistent.LoadToyStats(); ???!!
            persistent.LoadSkillsInventory(true);

            if (midlevel != null)
            {
                midlevel.resetMidLevelStuff();     //lose all progress. yes, forever.
                games[current_savegame_id].SaveFile();
                games[current_savegame_id].LoadFile("");
            }
            break;


        case SaveWhen.BeginningOfLevel:                        //load
            Debug.Log("Loading Beginning Of Level\n");



            Monitor.Instance.ResetIslands();

            midlevel                     = new SaveState();
            midlevel.type                = SaveStateType.MidLevel;
            midlevel.current_level       = persistent.current_level;
            midlevel.hero_stats          = persistent.hero_stats;
            midlevel.score_details       = persistent.score_details;
            midlevel.actor_stats         = persistent.actor_stats;
            midlevel.wishes              = persistent.wishes;
            midlevel.rewards             = persistent.rewards;
            midlevel.skills_in_inventory = persistent.skills_in_inventory;

            games[current_savegame_id].setNewMidlevel(midlevel);

            games[current_savegame_id].SaveAndReload();     // deep copy

            persistent.LoadRewards();
            persistent.LoadToyStats();
            persistent.LoadHeroStats();
            persistent.LoadSkillsInventory(true);
            persistent.LoadWishes();
            persistent.LoadScore(true);
            persistent.LoadEvents();     //still need to reset this

            Tracker.Log(PlayerEvent.LoadGame, false,
                        customAttributes: new Dictionary <string, string>()
            {
                { "attribute_2", Get.getCarryOverInventory() },
                { "attribute_1", Peripheral.Instance.difficulty.ToString() + "|" + type.ToString() }
            },
                        customMetrics: new Dictionary <string, double> {
                { "metric_1", persistent.current_level }
            });

            Central.Instance.updateCost(0);
            Moon.Instance.SetWave(0, 0);
            Central.Instance.changeState(GameState.InGame);

            break;
        }
        RewardOverseer.RewardInstance.StartOverseer();
        return(true);
    }
示例#5
0
    public void changeState(GameState s, string content)
    {
        Noisemaker.Instance.Stop();
        GameState oldstate = state;

        state = s;
        Debug.Log("Changing state " + oldstate + " to " + s + "\n");

        if (oldstate != GameState.InGame && s == GameState.InGame)
        {
            //my_spyglass.DisableByGameState(false);c
        }
        else if (oldstate == GameState.InGame && s != GameState.InGame)
        {
            if (Monitor.Instance != null)
            {
                Monitor.Instance.my_spyglass.DisableByGameState(true);
            }

            Moon.Instance.WaveInProgress = false;
            Peripheral.Instance.ClearAll(SelectedType.Null, "");
        }

        switch (state)
        {
        case GameState.WonGame:
            game_saver.SaveGame(SaveWhen.EndOfLevel);
            current_lvl = -1;

            System.Diagnostics.Process.GetCurrentProcess().Kill();
            break;

        case GameState.Quit:
            Application.Quit();    //for now
            break;

        case GameState.MainMenu:

            EagleEyes.Instance.PlaceState(state);
            if (oldstate == GameState.InGame)
            {
                clearLevel();
            }
            break;

        case GameState.InGame:
            if (Monitor.Instance != null)
            {
                Monitor.Instance.my_spyglass.Reset();
            }
            if (Monitor.Instance != null)
            {
                Monitor.Instance.my_spyglass.DisableByGameState(false);
            }

            if (oldstate == GameState.InGame)
            {
                clearLevel();
            }

            EagleEyes.Instance.PlaceState(state);
            ScoreKeeper.Instance.SetLevel(current_lvl, getCurrentDifficultyLevel());
            if (EventOverseer.Instance != null)
            {
                EventOverseer.Instance.StartOverseer();
            }
            else
            {
                //Debug.Log("No overseer to start:(");
            }
            EagleEyes.Instance.ResetHealthVisual();
            break;

        case GameState.Won:
            game_saver.SaveGame(SaveWhen.EndOfLevel);
            clearLevel();
            incrementLevel();
            Peripheral.Instance.Wave_interval = 0f;

            GameStatCollector.Instance.printStats();

            EagleEyes.Instance.PlaceState(state);
            break;

        case GameState.LevelList:

            //if (saved_level == -1 && content.Equals("AskConfirm")) content = "Start";

            switch (content)
            {
            case "AskConfirm":        //from mainmenu to map
                EagleEyes.Instance.DisplayConfirmPanel(MenuButton.Start, true);
                break;

            case "CancelConfirm":
                EagleEyes.Instance.DisplayConfirmPanel(MenuButton.Start, false);
                break;

            case "AskConfirmToMap":        // from ingame to map
                EagleEyes.Instance.DisplayConfirmPanel(MenuButton.ToMap, true);
                break;

            case "CancelConfirmToMap":
                EagleEyes.Instance.DisplayConfirmPanel(MenuButton.ToMap, false);
                break;

            case "ToMap":         //lose progress
                softClearLevel();
                clearLevel();     //does this need to be here?

                Central.Instance.game_saver.LoadGame(SaveWhen.BetweenLevels);
                if (EventOverseer.Instance != null)
                {
                    EventOverseer.Instance.StopOverseer();
                }
                //if (RewardOverseer.RewardInstance != null) RewardOverseer.RewardInstance.StartMe(false);

                EagleEyes.Instance.PlaceState(state);
                break;

            case "Start":
                Debug.Log("Start...\n");
                //     RewardOverseer.RewardInstance.StartMe(false);
                EagleEyes.Instance.PlaceState(state);
                break;

            default:
                Debug.Log("UNKNOWN content " + content + " for GameState LevelList\n");
                state = oldstate;
                break;
            }
            break;

        case GameState.Lost:
            EagleEyes.Instance.PlaceState(state);
            softClearLevel(); //clear towers
            clearLevel();     //clear ui
            GameStatCollector.Instance.printStats();

            break;

        case GameState.Loading:
            softClearLevel();    //clear towers
            DynamicLoadingBackground.Instance.InitRandom();
            switch (content)
            {
            case "LoadSnapshot":         //restart wave button
                EagleEyes.Instance.PlaceState(state);
                if (oldstate == GameState.InGame)
                {
                    softClearLevel();
                }
                if (EventOverseer.Instance != null)
                {
                    EventOverseer.Instance.StopOverseer();
                }
                levelchange = true;
                Levelmakers = SaveWhen.MidLevel;

                break;

            case "GoBack1":         //restart wave button
                EagleEyes.Instance.PlaceState(state);
                if (oldstate == GameState.InGame)
                {
                    softClearLevel();
                }
                if (EventOverseer.Instance != null)
                {
                    EventOverseer.Instance.StopOverseer();
                }
                levelchange = true;
                Levelmakers = SaveWhen.GoBack1;

                break;

            case "GoBack2":         //restart wave button
                EagleEyes.Instance.PlaceState(state);
                if (oldstate == GameState.InGame)
                {
                    softClearLevel();
                }
                if (EventOverseer.Instance != null)
                {
                    EventOverseer.Instance.StopOverseer();
                }
                levelchange = true;
                Levelmakers = SaveWhen.GoBack2;

                break;


            case "NewLevel":

                EagleEyes.Instance.PlaceState(state);
                levelchange = true;
                Levelmakers = SaveWhen.BeginningOfLevel;

                break;

            case "LoadStartLevelSnapshot":         //restart level button
                EagleEyes.Instance.PlaceState(state);
                if (EventOverseer.Instance != null)
                {
                    EventOverseer.Instance.StopOverseer();
                }
                if (oldstate == GameState.InGame)
                {
                    softClearLevel();
                }
                levelchange = true;
                Levelmakers = SaveWhen.BeginningOfLevel;
                break;

            default:
                EagleEyes.Instance.PlaceState(state);
                Debug.Log("UNKNOWN content for GameState Loading, button " + this.name + "\n");
                state = oldstate;
                break;
            }
            break;

        case GameState.LoadingWave:
            Debug.Log("When does this happen?\n");
            EagleEyes.Instance.PlaceState(state);
            if (oldstate == GameState.InGame)
            {
                softClearLevel();
            }
            levelchange = true;
            Levelmakers = SaveWhen.MidLevel;
            break;

        default:
            break;
        }
    }