Example #1
0
    public void Init()
    {
        _paramTerrain      = (TerrainParameter)AssetDatabase.LoadAssetAtPath(_terrainParamPath, typeof(TerrainParameter));
        _paramWeather      = (WeatherParameter)AssetDatabase.LoadAssetAtPath(_weatherParamPath, typeof(WeatherParameter));
        _paramTemperature  = (TemperatureParameter)AssetDatabase.LoadAssetAtPath(_temperatureParamPath, typeof(TemperatureParameter));
        _paramMana         = (ManaParameter)AssetDatabase.LoadAssetAtPath(_manaParamPath, typeof(ManaParameter));
        _paramRain         = (RainParameter)AssetDatabase.LoadAssetAtPath(_rainParamPath, typeof(RainParameter));
        _biomeDistribution = (BiomeDistribution)AssetDatabase.LoadAssetAtPath(_biomeDistributionPath, typeof(BiomeDistribution));
        _terrainColor      = (ColorRangeDistribution)AssetDatabase.LoadAssetAtPath(_terrainColorRangePath, typeof(ColorRangeDistribution));
        _weatherColor      = (ColorRangeDistribution)AssetDatabase.LoadAssetAtPath(_weatherColorRangePath, typeof(ColorRangeDistribution));
        _manaColor         = (ColorRangeDistribution)AssetDatabase.LoadAssetAtPath(_manaColorRangePath, typeof(ColorRangeDistribution));
        _rainColor         = (ColorRangeDistribution)AssetDatabase.LoadAssetAtPath(_rainColorRangePath, typeof(ColorRangeDistribution));

        _serializedObj             = new SerializedObject(this);
        _propertyParamTerrain      = _serializedObj.FindProperty("_paramTerrain");
        _propertyParamWeather      = _serializedObj.FindProperty("_paramWeather");
        _propertyParamTemperature  = _serializedObj.FindProperty("_paramTemperature");
        _propertyParamMana         = _serializedObj.FindProperty("_paramMana");
        _propertyParamRain         = _serializedObj.FindProperty("_paramRain");
        _propertyBiomeDistribution = _serializedObj.FindProperty("_biomeDistribution");
        _propertyTerrainColorRange = _serializedObj.FindProperty("_terrainColor");
        _propertyWeatherColorRange = _serializedObj.FindProperty("_weatherColor");
        _propertyManaColorRange    = _serializedObj.FindProperty("_manaColor");
        _propertyRainColorRange    = _serializedObj.FindProperty("_rainColor");
        _propertyWidth             = _serializedObj.FindProperty("_width");
        _propertyHeight            = _serializedObj.FindProperty("_height");
        _propertySeed = _serializedObj.FindProperty("_seed");

        _noticeTxt    = string.Empty;
        _worldTexture = null;
        _tileData     = null;
        _executor.Clear();
    }
 public static void SaveMap(TileDataUnit saveDataUnit)
 {
     try
     {
         _SaveMap(saveDataUnit);
     }
     catch (Exception e)
     {
         Debug.Log(e);
     }
 }
Example #3
0
 private void _ShowTerrainMapCondition(TileDataUnit mapData, System.Func <TileUnit, bool> isValid)
 {
     _worldTexture = new Texture2D(mapData.Width, mapData.Height);
     for (int x = 0; x < mapData.Width; x++)
     {
         for (int y = 0; y < mapData.Height; y++)
         {
             var idx      = MathUtility.MapIndex(x, y, _height);
             var tileUnit = mapData.Map[idx];
             var color    = _terrainColor.GetLerpColor(tileUnit.Height);
             color.a = isValid(tileUnit) ? 1 : 0.2f;
             _worldTexture.SetPixel(x, y, color);
         }
     }
     _worldTexture.Apply();
 }
Example #4
0
    private void _ShowWorldMapTexture(TileDataUnit mapData)
    {
        _noticeTxt    = string.Format("Load Map  - {0}*{1}", mapData.Width, mapData.Height);
        _worldTexture = new Texture2D(mapData.Width, mapData.Height);
        for (int x = 0; x < mapData.Width; x++)
        {
            for (int y = 0; y < mapData.Height; y++)
            {
                var idx      = MathUtility.MapIndex(x, y, _height);
                var tileUnit = mapData.Map[idx];
                var color    = _GetColorOfTypeRange(tileUnit);

                _worldTexture.SetPixel(x, y, color);
            }
        }
        _worldTexture.Apply();
    }
Example #5
0
 private void _DrawMenuNewMap()
 {
     if (GUILayout.Button("Parameter"))
     {
         _newMapStatus = NewMapStatus.Parameter;
     }
     if (GUILayout.Button("Create"))
     {
         _newMapStatus = NewMapStatus.Create;
         if (_CheckPreparedToCreate())
         {
             _CreateNewWorld();
         }
     }
     if (GUILayout.Button("Save"))
     {
         _newMapStatus = NewMapStatus.Save;
         if (_tileData != null)
         {
             SaveData.SaveMap(_tileData);
             _noticeTxt = "Map saved success";
         }
         else
         {
             _noticeTxt = "Error! No map to saved";
         }
     }
     if (GUILayout.Button("Load"))
     {
         _newMapStatus = NewMapStatus.Load;
         _tileData     = SaveData.LoadMap();
         if (_tileData != null)
         {
             _noticeTxt = "Map loaded success";
         }
         else
         {
             _noticeTxt = "Error! No map to saved";
         }
     }
 }
    private static void _SaveMap(TileDataUnit saveDataUnit)
    {
        var saveJson = JsonUtility.ToJson(saveDataUnit);

        PlayerPrefs.SetString(SAVE_KEY, saveJson);
    }
Example #7
0
    private IEnumerator _CreateNewWorldMonad()
    {
        Random.InitState(_seed);

        var genTerrainMonad = new BlockMonad <float[]>(r =>
                                                       _terrainGen.GenerateHeightMap(
                                                           _width,
                                                           _height,
                                                           Random.Range(0, 10000),
                                                           Random.Range(0, 10000),
                                                           _paramTerrain,
                                                           r));
        var genHumidityMonad = new BlockMonad <float[]>(r =>
                                                        _humidityGen.GenerateWeatherMap(
                                                            _width,
                                                            _height,
                                                            Random.Range(0, 10000),
                                                            Random.Range(0, 10000),
                                                            _paramWeather,
                                                            r));
        var genTemperatureMonad = new BlockMonad <float[]>(r =>
                                                           _temperatureGen.GenerateWeatherMap(
                                                               _width,
                                                               _height,
                                                               Random.Range(0, 10000),
                                                               Random.Range(0, 10000),
                                                               _paramTemperature,
                                                               r));
        var genManaMonad = new BlockMonad <float[]>(r =>
                                                    _manaGen.GenerateManaMap(
                                                        _width,
                                                        _height,
                                                        _paramMana,
                                                        r));

        Debug.Log("start genTerrainMonad");
        yield return(genTerrainMonad.Do());

        Debug.Log("start genHumidityMonad");
        yield return(genHumidityMonad.Do());

        Debug.Log("start genTemperatureMonad");
        yield return(genTemperatureMonad.Do());

        Debug.Log("start genManaMonad");
        yield return(genManaMonad.Do());

        var terrainMap     = genTerrainMonad.Result;
        var humidityMap    = genHumidityMonad.Result;
        var temperatureMap = genTemperatureMonad.Result;
        var manaMap        = genManaMonad.Result;

        var genRiverMonad = new BlockMonad <float[]>(r =>
                                                     _riverGen.GenerateRiverMap(
                                                         _width,
                                                         _height,
                                                         terrainMap,
                                                         _paramRain,
                                                         r));

        Debug.Log("start genRiverMonad");
        yield return(genRiverMonad.Do());

        var riverMap = genRiverMonad.Result;

        var tileUnitMap = new TileUnit[_width * _height];

        IBiomeIdentifier identifier = new BasicBiomeIdentifier(_biomeDistribution);

        for (int x = 0; x < _width; x++)
        {
            for (int y = 0; y < _height; y++)
            {
                var idx = MathUtility.MapIndex(x, y, _height);

                var height      = terrainMap[idx];
                var humidity    = humidityMap[idx];
                var temperature = temperatureMap[idx];
                var mana        = manaMap[idx];
                var river       = riverMap[idx];

                BiomeData biome = identifier.IdentifyBiome(humidity, height, temperature);
                tileUnitMap[idx] = new TileUnit(
                    height,
                    humidity,
                    temperature,
                    mana,
                    river,
                    biome.Biome);
            }
        }

        _tileData = new TileDataUnit
        {
            Map    = tileUnitMap,
            Width  = _width,
            Height = _height,
        };
        _noticeTxt = "New world created.";
    }