示例#1
0
        public static GameLevel[] GetGameLevelsBasedOnCategory(string categoryName)
        {
            GameLevelData    data       = GameLevelToolkitWindow.GetGameLevelsData();
            List <GameLevel> categories = new List <GameLevel>();

            if (categoryName == data.allCategoriesName) // Get All
            {
                for (int i = 0; i < data.gameLevelsCreatedByUser.Count; i++)
                {
                    categories.Add(data.gameLevelsCreatedByUser[i]);
                }
            }
            else // Get By Name
            {
                for (int i = 0; i < data.gameLevelsCreatedByUser.Count; i++)
                {
                    if (data.gameLevelsCreatedByUser[i].assignedCategory == categoryName)
                    {
                        categories.Add(data.gameLevelsCreatedByUser[i]);
                    }
                }
            }

            return(categories.ToArray());
        }
示例#2
0
    private void Awake()
    {
        _character.Initialize(this);
        _hud.Initialize(this, _character.OnTapDown);
        // level init
        LevelData levelEntry = GameController.Instance.GetSelectedLevelData();

        _timeBonusPosition = levelEntry.TimeBonusCellPosition;
        _spikesPosition    = levelEntry.SpikesPosition;
        _levelData         = new GameLevelData
        {
            Name     = levelEntry.Name,
            MaxCoins = 0
        };
        _levelData.MaxCoins = GameController.Instance.DataLoader.GetLevelMaxCoins(levelEntry.Name);
        Debug.Log("Level " + _levelData.Name + " max coins: " + _levelData.MaxCoins.ToString());

        var levelObj = GameObject.Instantiate(levelEntry.GamePrefab, _tilemapGrid.transform);

        levelObj.transform.localPosition = _levelLocalPosition;
        InitializeTilemap();
        CurrentLevelTime = _levelTotalTime;
        TogglePause(false);
        LevelStarted = false;
    }
    public void init(string levelCode)
    {
        this.reset();
        GameLevelData data = DodResources.GetLevelData(levelCode);

        //判空
        if (data == null)
        {
            throw new System.Exception("level not found");
        }



        //循环构筑timeline
        string[] spliter = new string[] { "__" };

        foreach (string code in data.commandSource)
        {
            _timeline.AddLast(new TimeCommand(
                                  code.Split(spliter, StringSplitOptions.None)
                                  ));
        }

        foreach (TimeCommand line in _timeline)
        {
            line.print();
        }

        //todo:初始化关卡参数
    }
示例#4
0
        public static void CreateCategory(string targetName)
        {
            GameLevelData data = GameLevelToolkitWindow.GetGameLevelsData();

            data.allUserCreatedCategories.Add(targetName);
            EditorUtility.SetDirty(data);
        }
示例#5
0
        public override void Start()
        {
            base.Start();

            //WorldData worldData = WorldList.Worlds[WorldToLoad.Value];
            WorldData worldData = DataMgr.Instance.CurrentWorldData;

            Levels = worldData.LevelList;

            _selectedLevel = Levels.Levels[LoadLevel.Value];

            WorldName.text = worldData.WorldName.ToUpper();
            LevelName.text = string.Format("Level {0}", LoadLevel.Value + 1);

            if (_selectedLevel != null)
            {
                if (_selectedLevel.Photo == null)
                {
                    if (!string.IsNullOrEmpty(_selectedLevel.PhotoUrl))
                    {
                        // Format photo string URL here.
                    }
                    else
                    {
                        Debug.LogErrorFormat("Cannot load photo at URL: {0}!", _selectedLevel.Photo);
                    }
                }

                LevelImage.sprite = Sprite.Create(_selectedLevel.Photo, new Rect(0, 0, _selectedLevel.Photo.width, _selectedLevel.Photo.height), Vector2.zero);

                LevelDescription.text = _selectedLevel.Description;
            }
        }
示例#6
0
 public void SetCurrentGameLevelById(string id)
 {
     if (_gameLevelDatasById.ContainsKey(id))
     {
         CurrentGameLevelData = _gameLevelDatasById[id];
     }
 }
示例#7
0
 /// <summary>
 /// Setta le informazioni necessare per il round corrente.
 /// </summary>
 void SetUpRound(int _round, GameLevelData _gameLeveldata)
 {
     Debug.Log("Setup Round");
     if (GamePlayManager.I.CurrentRound == 1)
     {
         foreach (PlayerData playerD in GamePlayManager.I.Players)
         {
             playerD.PutCardsInHand(_gameLeveldata.StartNumberOfCards);
         }
     }
     else
     {
         foreach (PlayerData playerD in GamePlayManager.I.Players)
         {
             if (playerD.CardDataInHand.Count < 8)
             {
                 playerD.PutCardsInHand(1);
             }
         }
     }
     foreach (PlayerData p in GamePlayManager.I.Players)
     {
         p.Mana = GamePlayManager.I.CurrentRound;
     }
 }
    public bool TrySaveLevelMaxCoins(GameLevelData data)
    {
        var key = GameData.Find(k => string.Equals(k.Name, data.Name));

        if (key == null)
        {
            GameData.Add(new GameLevelData
            {
                Name     = data.Name,
                MaxCoins = data.MaxCoins
            });

            // save
            PlayerPrefs.SetInt(data.Name, data.MaxCoins);
            return(true);
        }

        if (key.MaxCoins < data.MaxCoins)
        {
            key.MaxCoins = data.MaxCoins;
            // save
            PlayerPrefs.SetInt(data.Name, data.MaxCoins);
            return(true);
        }

        return(false);
    }
示例#9
0
    private void createLevelObjects()
    {
        GameLevelData levelData = this.dataManager.GameLevelsData[this.dataManager.CurrenLevel];

        foreach (AsteroidLevelData item in levelData.asteroids)
        {
            createObject(item.name, item.position, false);
        }
    }
示例#10
0
        private void DuplicateLevel()
        {
            if (HasNewLocationNameAssigned() == true)
            {
                Debug.LogError("Has No New Location Name Assigned");
                return;
            }

            if (gameLevelToCreateDuplicateOf == null)
            {
                Debug.LogError("Location Required to Duplicate");
                return;
            }

            GameLevelToolkitWindow toolkit = GameLevelToolkitWindow.GetRefreshedToolkitWindow();
            string projectPathName         = GameLevelToolkitWindow.GetProjectPathStringWithSlash();

            //Check if there is a location already existing with that name.
            GameLevel existingGameLevel = (GameLevel)AssetDatabase.LoadAssetAtPath("Assets/" + projectPathName + "Resources/" + SceneAndResourceFolderName.folderNameValue + "/" + newGameLevelName + "/" + newGameLevelName + ".asset", typeof(GameLevel));

            if (existingGameLevel != null)
            {
                Debug.LogError("Location With Same Name Already Exists");
                return;
            }

            //Create the Location Resource
            GameLevel gameLevelResource = GameLevelData.CreateInstance <GameLevel>();

            AssetDatabase.CreateAsset(GameLevel.CreateInstance <GameLevel>(), "Assets/" + projectPathName + "Resources/" + SceneAndResourceFolderName.folderNameValue + "/" + "Existing " + SceneAndResourceFolderName.folderNameValue + "/" + newGameLevelName + ".asset");
            AssetDatabase.SaveAssets();
            AssetDatabase.Refresh();
            GameLevel createdGameLevel = (GameLevel)AssetDatabase.LoadAssetAtPath("Assets/" + projectPathName + "Resources/" + SceneAndResourceFolderName.folderNameValue + "/" + "Existing " + SceneAndResourceFolderName.folderNameValue + "/" + newGameLevelName + ".asset", typeof(GameLevel));

            createdGameLevel.gameLevelName           = newGameLevelName;
            createdGameLevel.assignedScenesDirectory = "Assets/" + projectPathName + "Scenes/" + SceneAndResourceFolderName.folderNameValue + "/" + newGameLevelName;
            createdGameLevel.levelDependencies       = gameLevelToCreateDuplicateOf.levelDependencies;
            createdGameLevel.assignedScenes          = gameLevelToCreateDuplicateOf.assignedScenes;
            GameLevelToolkitWindow.GetGameLevelsData().gameLevelsCreatedByUser.Add(createdGameLevel);

            //Create the Scene Directory
            string scenesFolder = AssetDatabase.CreateFolder("Assets/" + projectPathName + "Scenes/" + SceneAndResourceFolderName.folderNameValue, newGameLevelName);

            //Copy the Existing Scenes
            for (int i = 0; i < gameLevelToCreateDuplicateOf.assignedScenes.Count; i++)
            {
                string sceneToCopy = gameLevelToCreateDuplicateOf.assignedScenesDirectory + "/" + gameLevelToCreateDuplicateOf.gameLevelName + "_" + gameLevelToCreateDuplicateOf.assignedScenes[i] + ".unity";
                string destination = createdGameLevel.assignedScenesDirectory + "/" + newGameLevelName + "_" + gameLevelToCreateDuplicateOf.assignedScenes[i] + ".unity";
                FileUtil.CopyFileOrDirectory(sceneToCopy, destination);
            }

            EditorUtility.SetDirty(createdGameLevel);
            EditorUtility.SetDirty(toolkit.gameLevelsData);

            AssetDatabase.SaveAssets();
            AssetDatabase.Refresh();
        }
示例#11
0
    private void LoadEnemyConfig()
    {
        _enemyDataConfig.Clear();
        GameLevelData currentGameLevel = GameLevelDataController.Instance.CurrentGameLevelData;

        for (int i = 0; i < currentGameLevel.EnemyDatas.Count; i++)
        {
            _enemyDataConfig.Add(currentGameLevel.EnemyDatas[i].UnitPrefabId, currentGameLevel.EnemyDatas[i]);
        }
    }
示例#12
0
    private void LoadTileConfig()
    {
        _tileConfig.Clear();
        GameLevelData gameLevel = GameLevelDataController.Instance.CurrentGameLevelData;

        for (int i = 0; i < gameLevel.MapData.TileDatas.Count; i++)
        {
            _tileConfig.Add(gameLevel.MapData.TileDatas[i].name, gameLevel.MapData.TileDatas[i]);
        }
    }
示例#13
0
    public void OnLevelLoaded()
    {
        GameManager gameManager = GameManager.instance;

        gameLevelData_ = gameManager.currentLevelData;
        if (gameLevelData_ != null)
        {
            Debug.Log("Successfully loaded level " + gameLevelData_.sceneName);
        }
    }
示例#14
0
        /// <summary>
        /// Load a GameLevel from an XML file.
        /// </summary>
        /// <param name="data">Serialized GameLevelData XML file.</param>
        public void loadLevel(String path)
        {
            // Load GameLevel data
            GameLevelData data = _gameContentMgr.loadLevelData(path);

            // Initialize level
            initLevel(data.NumRows, data.NumCols);

            // Load all GameTiles
            for (int row = 0; row < _tileRows; row++)
            {
                for (int col = 0; col < _tileCols; col++)
                {
                    GameTileData tileData   = data.Tiles[row * _tileCols + col];
                    GameTile     tile       = _tiles[row, col];
                    Entity       tileEntity = new Entity(_gameContentMgr.loadDrawable(tileData.Drawable));

                    tile.Entity = tileEntity;
                    tile.Active = tileData.Active;
                    tile.Node.translate(0.0f, tileData.Elevation, 0.0f);
                }
            }

            // Load all GameObjects
            foreach (GameObjectData gobjData in data.GameObjs)
            {
                GameObject gobj = null;

                switch (gobjData.ObjType)
                {
                case 0:         // GameObject
                    gobj = createGameObject <GameObject>(gobjData.Name, gobjData.Drawable);
                    break;

                case 1:         // GameObjectMovable
                    gobj = createGameObject <GameObjectMovable>(gobjData.Name, gobjData.Drawable);
                    break;

                case 2:         // GameCharacter
                    gobj = createGameObject <GameCharacter>(gobjData.Name, gobjData.Drawable);
                    break;
                }

                tileAtIndex(0, 0).Node.attachChildNode(gobj.Node);
                gobj.Node.translateTo(gobjData.Position);

                gobj.DirectionVector = gobjData.Direction;
                gobj.Active          = gobjData.Active;
            }

            Console.WriteLine("Level loaded: " + path);
        }
示例#15
0
        public IEnumerator ChangeLevel(int index)
        {
            Debug.Log(string.Format("Loading level {0}", index));

            WorldData CurrentWorld = null;

            if (CNV_TOOL)
            {
                CurrentWorld = CNVWorldList.Worlds[WorldToLoad.Value];
            }
            else
            {
                if (ConnectionMgr.OFFLINE_DEBUG)
                {
                    CurrentWorld = WorldList.Worlds[WorldToLoad.Value];
                }
                else
                {
                    CurrentWorld = DataMgr.Instance.CurrentWorldData;
                }
            }

            Levels = CurrentWorld.LevelList;

            // Set current level based on selection.
            CurrentLevel = Levels.Levels[index];

            // Download texture for the game.
            if (!CNV_TOOL)
            {
                if (CurrentLevel.Photo == null)
                {
                    if (!string.IsNullOrEmpty(CurrentLevel.PhotoUrl))
                    {
                        // Format photo string URL here.
                    }
                    else
                    {
                        Debug.LogErrorFormat("Cannot load photo at URL: {0}!", CurrentLevel.Photo);
                    }
                }
            }

            ToolMgr.Instance.TurnOffAll();
            ImageMgr.Instance.FlagAsDirty();

            yield return(null);

            ToolMgr.Instance.TurnOn(CurrentLevel.Tool);
        }
        public static void OpenLocationsData()
        {
            GameLevelData data              = GetGameLevelsData();
            var           inspectorType     = typeof(EditorGUI).Assembly.GetType("UnityEditor.InspectorWindow");
            var           inspectorInstance = ScriptableObject.CreateInstance(inspectorType) as EditorWindow;

            inspectorInstance.Show();
            var prevSelection = Selection.activeGameObject;

            Selection.activeObject = data;
            var isLocked = inspectorType.GetProperty("isLocked", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public);

            isLocked.GetSetMethod().Invoke(inspectorInstance, new object[] { true });
            Selection.activeGameObject = prevSelection;
        }
示例#17
0
 public void LoadNextLevel()
 {
     if (currentLevelId < numOfLevels)
     {
         playMode          = false;
         currentLevelData_ = gameLevelData[currentLevelId++];
         currentLevelData_.UnlockLevel();
         //currentSceneName = gameLevelData[currentLevelId++].sceneName;
         SceneManager.LoadScene(currentLevelData_.sceneName, LoadSceneMode.Single);
         Debug.Log("Loading next scene : " + currentLevelData_.levelName);
     }
     else
     {
         Debug.LogError("No more scenes to be loaded");
         SceneManager.LoadScene(mainMenuSceneName, LoadSceneMode.Single);
     }
 }
示例#18
0
    /// <summary>
    /// Setta i players
    /// </summary>
    void SetUpPlayers(GameLevelData _gameLeveldata)
    {
        Debug.Log("Setup Players");
        GamePlayManager.I.Players = LoadPlayersFromDisk();
        // TODO: Limitare numero di player a 2.
        GamePlayManager.I.Players.RemoveRange(2, GamePlayManager.I.Players.Count - 2);
        SetPlayersOrder();
        // Player 1 inizializzazione
        GamePlayManager.I.PView1.Init(GamePlayManager.I.Players[0]);
        GamePlayManager.I.Players[0].Mana = GamePlayManager.I.CurrentRound;
        GamePlayManager.I.Players[0].Life = _gameLeveldata.PlayersStartLife;

        // Player 2 inizializzazione
        GamePlayManager.I.PView2.Init(GamePlayManager.I.Players[1]);
        GamePlayManager.I.Players[1].Mana = GamePlayManager.I.CurrentRound;
        GamePlayManager.I.Players[1].Life = _gameLeveldata.PlayersStartLife;
    }
示例#19
0
        public static void RenameCategory(string categoryOriginalName, string targetCategoryName)
        {
            //Get All Levels that Have this category and rename it there too
            GameLevel[] levels = GetGameLevelsBasedOnCategory(categoryOriginalName);
            RenameGameLevelsCategory(levels, targetCategoryName);

            GameLevelData data = GameLevelToolkitWindow.GetGameLevelsData();

            for (int i = 0; i < data.allUserCreatedCategories.Count; i++)
            {
                if (data.allUserCreatedCategories[i] == categoryOriginalName)
                {
                    data.allUserCreatedCategories[i] = targetCategoryName;
                    break;
                }
            }
            EditorUtility.SetDirty(data);
        }
    public void InitializeScene()
    {
        _character.Initialize(this);
        _character.transform.position = _characterInitialPosition;
        _hud.Initialize(this, _character.OnSwipe, _character.OnLeftDown, _character.OnRightDown, _character.OnButtonUp);
        // level init
        LevelData levelEntry = GameController.Instance.GetSelectedLevelData();

        _levelData = GameController.Instance.DataLoader.GetLevelMaxData(levelEntry.Name);
        Debug.Log("Level " + _levelData.Name + " max height: " + _levelData.MaxHeight.ToString());
        _config = levelEntry.SceneConfig;
        _cameraPivotPosition.position = new Vector3(0.0f, 0.0f, -5.0f);
        _baseCameraPivotPos           = _cameraPivotPosition.position;
        InitializeLevel();
        CurrentHeight    = 0;
        CurrentPlatforms = 0;
        TogglePause(false);
        LevelStarted = false;
    }
        public static GameLevelData GetGameLevelsData()
        {
            string[] assetGuid = AssetDatabase.FindAssets(SceneAndResourceFolderName.folderNameValue + " Data");
            string   path      = "";

            if (assetGuid.Length == 0)
            {
                return(null);
            }

            foreach (string item in assetGuid)
            {
                path = AssetDatabase.GUIDToAssetPath(item);
                break;
            }

            GameLevelData data = (GameLevelData)AssetDatabase.LoadAssetAtPath(path, typeof(GameLevelData));

            return(data);
        }
示例#22
0
        public static void DeleteExistingCategory(string targetCategory)
        {
            GameLevelData data = GameLevelToolkitWindow.GetGameLevelsData();

            //Get All Levels that have this category and assign them to unassigned
            GameLevel[] levels = GetGameLevelsBasedOnCategory(targetCategory);
            RenameGameLevelsCategory(levels, data.unassignedCategoryName);

            //Remove The Item From The data list
            for (int i = 0; i < data.allUserCreatedCategories.Count; i++)
            {
                if (data.allUserCreatedCategories[i] == targetCategory)
                {
                    data.allUserCreatedCategories.RemoveAt(i);
                    break;
                }
            }

            EditorUtility.SetDirty(data);
        }
示例#23
0
    /// <summary>
    /// Carica da disco le info del livello tramite l'id del livello,
    /// Operazione da seguire solo nella fase di setup
    /// </summary>
    /// <param name="_levelId"></param>
    /// <returns></returns>
    GameLevelData GetLevelInfo(string _levelId)
    {
        // Creo oggetto riempire e restutire
        GameLevelData returnGameLevel = new GameLevelData();

        GameLevelData[] allLevels = Resources.LoadAll <GameLevelData>("Levels");
        foreach (GameLevelData levelData in allLevels)
        {
            if (levelData.Id == _levelId)
            {
                returnGameLevel = levelData;
            }
        }

        returnGameLevel.AllCards = CardManager.GetAllCards();

        #region Costruttore di Livelli
        //switch (_levelId) {
        //    case 1:
        //        returnGameLevel = new GameLevel() {
        //            StartNumberOfCards = 5,
        //            Cols = new List<BoardCol>() {
        //                                     new BoardCol() { ColType = -1 },
        //                                     new BoardCol() { ColType = 0 },
        //                                     new BoardCol() { ColType = 0 },
        //                                     new BoardCol() { ColType = 0 },
        //                                     new BoardCol() { ColType = -1 },
        //                                 }
        //        };
        //        break;

        //    default:
        //        returnGameLevel = new GameLevel();
        //        break;
        //}

        #endregion


        return(returnGameLevel);
    }
示例#24
0
    void LoadLevelData()
    {
        OnNotification.OnNext("Download LevelData..");
        Debug.Log("Application.persistentDataPath " + Application.streamingAssetsPath);
        var    filePath = Path.Combine(Application.streamingAssetsPath, FilePath.GAME_LEVEL_DATA);
        string jsonString;

        if (Application.platform == RuntimePlatform.Android) //Need to extract file from apk first
        {
            WWW reader = new WWW(filePath);
            while (!reader.isDone)
            {
            }

            jsonString = reader.text;
        }
        else
        {
            jsonString = GameUtil.GetTextFromFile(filePath);
        }


        //OnNotification.OnNext(path);
        //var jsonData = GameUtil.GetTextFromFile(path);
        Debug.Log(jsonString);
        Dictionary <string, object> gameleveldata = JsonConvert.DeserializeObject <Dictionary <string, object> >(jsonString);
        GameLevelData levelData = JsonConvert.DeserializeObject <GameLevelData>(jsonString);

        GameDataManager.Instance.SetUpGameLeveldata(levelData);
        OnNotification.OnNext("LevelData download complete prepareTo Login");
        CheckCopmpletedData(-1);
        Debug.Log("leveldata " + levelData.version);
        Debug.Log("leveldata gameThemes" + levelData.gameThemesData.Count);
        Debug.Log("dic count " + gameleveldata.Count);
        foreach (var data in levelData.gameThemesData)
        {
            Debug.Log(string.Format("themename {0} stageLevel {1}", data.themeName, data.gameStages.Count));
        }
        //Debug.Log("gameleveldata "+gameleveldata.gameThemes);
    }
示例#25
0
        /// <summary>
        /// Save the current state of this GameLevel as an XML file.
        /// </summary>
        /// <param name="path">File path to save this GameLevel.</param>
        public void saveLevel(String path)
        {
            // XML writer settings for serialization
            XmlWriterSettings settings = new XmlWriterSettings();

            settings.Indent = true;

            // GameLevelData to hold state data
            GameLevelData data = new GameLevelData();

            // Save GameTiles
            data.NumRows = _tileRows;
            data.NumCols = _tileCols;
            data.Tiles   = new GameTileData[_tileRows * _tileCols];
            for (int row = 0; row < _tileRows; row++)
            {
                for (int col = 0; col < _tileCols; col++)
                {
                    data.Tiles[row * _tileCols + col] = _tiles[row, col].save();
                }
            }

            // Save GameObjects
            data.GameObjs = new GameObjectData[_gameObjs.Count];
            int i = 0;

            foreach (KeyValuePair <String, GameObject> entry in _gameObjs)
            {
                data.GameObjs[i] = entry.Value.save();
                i++;
            }

            // Write XML file
            using (XmlWriter writer = XmlWriter.Create(path + ".xml", settings))
                IntermediateSerializer.Serialize(writer, data, null);

            // Print success message to console
            Console.WriteLine("Current level saved to: " + path);
        }
示例#26
0
        public static string[] GetAllCategories(bool includeAllType, bool includeUnassigned = true)
        {
            GameLevelData data       = GameLevelToolkitWindow.GetGameLevelsData();
            List <string> categories = new List <string>();

            if (includeAllType == true)
            {
                categories.Add(data.allCategoriesName);
            }
            if (includeUnassigned == true)
            {
                categories.Add(data.unassignedCategoryName);
            }
            if (data.allUserCreatedCategories.Count > 0)
            {
                for (int i = 0; i < data.allUserCreatedCategories.Count; i++)
                {
                    categories.Add(data.allUserCreatedCategories[i]);
                }
            }
            return(categories.ToArray());
        }
示例#27
0
    public void OnEventButtonStart()
    {
        Monster[] list = PoolingManage.Character.GetList <Monster>();
        for (int i = 0; i < list.Length; ++i)
        {
            list[i].Remove();
        }

        GameDifficult difficult        = (GameDifficult)System.Enum.Parse(typeof(GameDifficult), m_difficultyDropdown.captionText.text);
        int           greaterRiftLevel = int.Parse(m_greaterRifitLevel.text);
        int           monsterNum       = int.Parse(m_monsterNum.text);

        for (int i = 0; i < monsterNum; ++i)
        {
            Monster monster = (Monster)PoolingManage.Character.Create("Butcher");
            Vector3 pos     = Vector3.zero;
            pos.x = Random.Range(-16, 15);
            pos.z = Random.Range(0, 15);
            monster.transform.position = pos;
            GameLevelData.ApplyMonster(monster, difficult, greaterRiftLevel);
        }

        Remove();
    }
示例#28
0
    public bool TrySaveLevelMaxRecord(GameLevelData data)
    {
        var key = GameData.Find(k => string.Equals(k.Name, data.Name));

        if (key == null)
        {
            GameData.Add(new GameLevelData
            {
                Name         = data.Name,
                MaxHeight    = data.MaxHeight,
                MaxPlatforms = data.MaxPlatforms,
            });

            // save
            PlayerPrefs.SetInt(data.Name + "_height", data.MaxHeight);
            PlayerPrefs.SetInt(data.Name + "_platforms", data.MaxPlatforms);
            return(true);
        }

        bool dataSaved = false;

        if (key.MaxHeight < data.MaxHeight)
        {
            key.MaxHeight = data.MaxHeight;
            PlayerPrefs.SetInt(data.Name + "_height", data.MaxHeight);
            dataSaved = true;
        }
        if (key.MaxPlatforms < data.MaxPlatforms)
        {
            key.MaxPlatforms = data.MaxPlatforms;
            PlayerPrefs.SetInt(data.Name + "_platforms", data.MaxPlatforms);
            dataSaved = true;
        }

        return(dataSaved);
    }
示例#29
0
    /// <summary>
    /// Save Game
    /// </summary>
    public void Save()
    {
        // Create new Save file.
        GameStateData stateData = new GameStateData();
        GameLevelData levelData = new GameLevelData();

        // Write State Data
        BinaryFormatter bf = new BinaryFormatter();
        FileStream file = File.Create(PersistentGameState());
        bf.Serialize(file, stateData);
        file.Close();

        // Write Level Data
        file = File.Create(PersistentLevelState());
        bf.Serialize(file, levelData);
        file.Close();
    }
示例#30
0
    /// <summary>
    /// Creates the level using the data from levelData
    /// </summary>
    /// <param name="levelData"></param>
    private void CreateLevel(GameLevelData levelData)
    {
        #region Documentation
        //Calculate dificulty % , with 0 as minimun and 1 maximum
        //For example if level is between 6 and 10, difficutly would be 0,0.25,0.50,0.5 and 1 respectively, making the difficulty increasing for every level.
        //This value will be used for giving a integer value between 2 vars affecting difficulty.
        //In short , this function calculates an increasing difficulty for a level.
        #endregion

        float difficulty = (1.0f / (levelData.MaxLevel - levelData.MinLevel)) * (CurrentLevel - levelData.MinLevel);

        //Define how many helixes would this level have, according the difficult settings.
        //More advanced levels will have more helixes.
        //Example MinHelixNumber=25 and MaxHelixNumber=35 -> the result would be something like 25,25,30,33 and 35

        int helixNumber = Mathf.RoundToInt(Mathf.Lerp(levelData.MinHelixNumber, levelData.MaxHelixNumber, difficulty));  //Random.Range(levelData.MinHelixNumber, levelData.MaxHelixNumber);

        //Assign colors to different pieces
        deadPieceMaterial.color   = levelData.DeadPieceColor;
        normalPieceMaterial.color = levelData.NormalPieceColor;
        brokenPieceMaterial.color = levelData.BrokenPieceColor;
        PlayerController.Instance.SetBallColor(levelData.BallColor);
        pillarMaterial.color = levelData.PillarColor;

        //Calculate time needed for this leve, increasing according the level.
        TimeToPassLevel = Mathf.RoundToInt(Mathf.Lerp(levelData.MinTimeToPassLevel, levelData.MaxTimeToPassLevel, difficulty)); //.Range(levelData.MinTimeToPassLevel, levelData.MaxTimeToPassLevel);

        //Create the first helix . Every disc is a 12-pieces helix
        HelixController firstHelixControl = Instantiate(helixPrefab, GPC.firstHelixPosition, Quaternion.identity).GetComponent <HelixController>();

        //Pass how many pieces will be disabled , how many would be a kill piece and the colors for each one
        firstHelixControl.HandleHelix(Random.Range(levelData.MinDisablePiecesNumber, levelData.MaxDeadPiecesNumber), 0, levelData.NormalPieceColor, levelData.DeadPieceColor);
        firstHelixControl.transform.SetParent(rotaterTrans);

        //Calculate the height of all helixs, space and distance between the pillar and the first helix
        float oneHelixHeight   = helixPrefab.transform.GetChild(0).GetComponent <Renderer>().bounds.size.y;
        float totalHelixHeight = oneHelixHeight * helixNumber - (helixNumber - 1) * oneHelixHeight + GPC.helixSpace;
        float totalSpace       = GPC.helixSpace * (helixNumber - 1);
        float distance         = Vector3.Distance(GPC.firstHelixPosition + Vector3.up * oneHelixHeight, pillar.transform.position);

        //Calculate and set the pillar's height
        float pillarHeight = totalSpace + totalHelixHeight + Mathf.Round(distance);
        pillar.transform.localScale = new Vector3(1, pillarHeight, 1);

        //Create helixes
        Vector3 nextHelixPos = GPC.firstHelixPosition + Vector3.down * GPC.helixSpace;
        for (int i = 0; i < helixNumber - 1; i++)
        {
            HelixController helixControl = Instantiate(helixPrefab, nextHelixPos, Quaternion.identity).GetComponent <HelixController>();

            if (levelData.MovPieces)
            {
                helixControl.SetMovPiece(levelData.RandomValues, levelData.OneDirection, levelData.LerpMov, levelData.angleMov, levelData.velMov, levelData.velLerp, levelData.dstMeta, levelData.percentMov);
            }

            helixControl.HandleHelix(Random.Range(levelData.MinDisablePiecesNumber, levelData.MaxDisablePiecesNumber),
                                     Mathf.RoundToInt(Mathf.Lerp(levelData.MinDeadPiecesNumber, levelData.MaxDeadPiecesNumber, difficulty)),
                                     levelData.NormalPieceColor, levelData.DeadPieceColor);
            helixControl.transform.SetParent(rotaterTrans);
            nextHelixPos = helixControl.transform.position + Vector3.down * GPC.helixSpace;
        }

        //Move bottomHelix object to the bottom
        bottomPillar.transform.position = nextHelixPos + Vector3.up * oneHelixHeight;;
    }
示例#31
0
 private void LoadLevelStateData(GameLevelData levelData)
 {
     if (levelData != null)
     {
         if (GetCurrentLevel() == levelData.gameData.currentLevel)
             GameControl.m_gameControl.SetPlayTime(levelData.gameData.playTime);
         else
         {
             Application.LoadLevel(levelData.gameData.currentLevel);
             return;
         }
     }
 }
示例#32
0
    protected override void Exit()
    {
        GameLevelData level = GameManager.Instance.levels[GameManager.Instance.levelIndex];

        GameManager.Instance.RequestLevel(level.sceneName);
    }
	internal void SetData(GameLevelData a_data, int a_index)
	{
		label.text = a_data.levelName;
		button.levelIndex = a_index;
	}