예제 #1
0
    void Awake () {
        if (s_Instance == null)
            s_Instance = this;
        undestructible = new Vector3[4];
        if (seed != 0)
        {
            Random.seed = seed;
        }

        terrainMap = new Dictionary<Vector3, GameObject>();
        obstacleMap = new Dictionary<Vector3, GameObject>();
        buildingMap = new Dictionary<GameObject, Vector3>();

        yScale = Mathf.Round(basicCube.GetComponent<Renderer>().bounds.size.y * 10) / 10;
        
        xScale = basicCube.GetComponent<Renderer>().bounds.size.x;
        zScale = basicCube.GetComponent<Renderer>().bounds.size.z;
        undestructible[0] = new Vector3(xMax / 2, 0, zMax / 2);
        undestructible[1] = new Vector3(xMax / 2 + 1, 0, zMax / 2);
        undestructible[2] = new Vector3(xMax / 2, 0, zMax / 2 + 1);
        undestructible[3] = new Vector3(xMax / 2 + 1, 0, zMax / 2 + 1);
        
        Generate();
        
        
    }
예제 #2
0
    // Use this for initialization
    void Start()
    {
        dispoTP = true;
        ObjectifsManager.nbAnimauxTot = ObjectifsManager.nbAnimauxTot + 1;
        //Debug.Log("Animaux Actuels = " + ObjectifsManager.nbAnimauxTot);
        old = state;

        terrain = GameObject.FindObjectOfType<TerrainGenerator>();

        if (state == "Fly")
        {
        }
        else if (state == "GoToCenter")
        {

            GameObject CaseActual = terrain.getCaseByPosition(transform.position);

            if (CaseActual.GetComponent<TerrainScript>().getType() == Type.Eau)
            {
                Destroy(gameObject);
            }

            else if (CaseActual.GetComponent<TerrainScript>().getType() == Type.Sable)
            {

            }
        }

        AllreadyInstance++;

        StartCoroutine(changeOrder());
    }
예제 #3
0
 private void Awake()
 {
     _agent            = GetComponent <NavMeshAgent>();
     _genes            = GetComponent <Genes>();
     _model            = GetComponentInChildren <MeshRenderer>().transform;
     _terrainGenerator = FindObjectOfType <TerrainGenerator>();
 }
    // Use this for initialization
    void Start2()
    {
        Chunk.setSize (chunkSize);
        Chunk.setDiscretization (voxelsPerUnit);
        NoiseSampleManager sampleManager = new NoiseSampleManager (groundLevel);
        NoisedFlatDensity density = new NoisedFlatDensity (groundLevel, sampleManager);

        foreach (NoiseSample noiseSample in noiseSamples) {
            SampleRepository.registerSample (noiseSample.getPersistentSample ());
            sampleManager.addSample (noiseSample);
        }

        TerrainGenerator generator = new TerrainGenerator (density, horizontalChunks, verticalChunks);
        generator.generate ();

        /*NoiseSample noiseSample1 = new NoiseSample (
            SampleRepository.getSample ("sample1"), weightFirstSample,
            new DefaultSaturation (noiseSaturation1.x, noiseSaturation1.y), firstSampleScale);

        NoiseSample noiseSample2 = new NoiseSample (
            SampleRepository.getSample ("sample2"), weightSecondSample,
            new DefaultSaturation (noiseSaturation2.x, noiseSaturation2.y), secondSampleScale);*/

        /*ChunkProcessor processor = new ChunkProcessor ();
        for (int i = 0; i < horizontalChunks; i++) {
            for (int j = 0; j < verticalChunks; j++) {
                for (int k = 0; k < horizontalChunks; k++) {
                    Chunk chunk = Chunk.Instantiate (new Vector3 (chunkSize*i, chunkSize*j, chunkSize*k));
                    chunk.applyDensity (density);
                    processor.process (chunk);
                }
            }
        }*/
    }
예제 #5
0
 public ErosionManager(TerrainGenerator terrain)
 {
     this.terrain = terrain;
     vertices = terrain.vertices;
     terrainSize = terrain.terrainSize;
     terrain.erosionManager = this;
 }
예제 #6
0
    public override void AgentReset()
    {
        base.AgentReset();

        BodyParts["pelvis"] = GetComponentsInChildren <Rigidbody>().FirstOrDefault(x => x.name == "torso");
        BodyParts["foot"]   = GetComponentsInChildren <Rigidbody>().FirstOrDefault(x => x.name == "foot");

        SetCenterOfMass();

        if (_terrainGenerator == null)
        {
            _terrainGenerator = GetComponent <TerrainGenerator>();
        }
        _lastXPosInMeters = (int)BodyParts["foot"].transform.position.x;
        _terrainGenerator.Reset();
        _stepCountAtLastMeter = 0;

        // set to true this to show monitor while training
        Monitor.SetActive(true);

        StepRewardFunction     = StepRewardHopper101;
        TerminateFunction      = LocalTerminate;
        ObservationsFunction   = ObservationsDefault;
        OnTerminateRewardValue = 0f;
        _pain        = 0f;
        _modeRecover = false;

        base.SetupBodyParts();
        SetCenterOfMass();
    }
예제 #7
0
        public TerrainChunk(TerrainGenerator generator, Vector2 coord, LODInfo[] detailLevels, int size, Transform parent, Material material)
        {
            _detailLevels = detailLevels;
            _generator    = generator;
            _position     = coord * size;
            _bounds       = new Bounds(_position, Vector2.one * size);
            Vector3 position3d = new Vector3(_position.x, 0, _position.y);

            _meshObject            = new GameObject($"Terrain Chunk ({coord.x}, {coord.y})");
            _meshRenderer          = _meshObject.AddComponent <MeshRenderer>();
            _meshFilter            = _meshObject.AddComponent <MeshFilter>();
            _meshCollider          = _meshObject.AddComponent <MeshCollider>();
            _meshRenderer.material = material;

            _meshObject.transform.position = position3d;
            _meshObject.transform.parent   = parent;

            SetVisible(false);

            _lodMeshes = new LODMesh[_detailLevels.Length];
            for (int i = 0; i < _detailLevels.Length; i++)
            {
                _lodMeshes[i] = new LODMesh(_generator, _detailLevels[i].lod, Update);
            }

            _generator.RequestMapData(_position, OnMapDataReceived);
        }
예제 #8
0
    // Choose terrain generator
    void SetTerrain(byte terrainId)
    {
        switch (terrainId)
        {
        case 0:
            terrainGenerator = new DefaultTerrainGenerator(this);
            break;

        case 1:
            terrainGenerator = new AlienTerrainGenerator(this);
            break;

        case 2:
            terrainGenerator = new CaveTerrainGenerator(this);
            break;

        default:
            SetTerrain(0);
            break;
        }

        // TODO: reset environment and set terrain properties like gravity and lights..
        parentOfChunks = GameObject.Find("/Environment/World").transform;

        // Init save
        save = new WorldSave(worldName, seed, terrainId);
    }
예제 #9
0
        static void Main(string[] args)
        {
            Console.WriteLine("Do you want to see the whole process? (Y/N):");
            string showcase        = Console.ReadLine();
            bool   continuous_save = false;

            if (showcase.ToUpper() == "Y")
            {
                Console.WriteLine("Do you want to save the whole process? (Y/N):");
                string continuous_save_text = Console.ReadLine();
                if (continuous_save_text.ToUpper() == "Y")
                {
                    continuous_save = true;
                }
            }

            TerrainGenerator tg = new TerrainGenerator();

            tg.continuous_save = continuous_save;
            Form form = new Form();

            form.Width  = 400;
            form.Height = 400;


            if (showcase.ToUpper() == "Y")
            {
                tg.showcase = true;
                tg.form     = form;
                Task.Run(() => {
                    Application.Run(tg.form);
                    tg.form.BringToFront();
                    tg.form.Activate();
                });
                tg.form.Text = "Generation Showcase";
            }


            while (!tg.finished)
            {
                try { tg.Update(); }
                catch (Exception e) { Console.WriteLine(e.ToString()); }
                if (tg.finished)
                {
                    Console.WriteLine("FINISHED");
                    Console.WriteLine("Do you want to repeat it? (Y/N):");
                    string repeat = Console.ReadLine();
                    if (repeat.ToUpper() == "Y")
                    {
                        tg = new TerrainGenerator();
                        tg.continuous_save = continuous_save;
                        if (showcase.ToUpper() == "Y")
                        {
                            tg.showcase = true;  tg.form = form;
                        }
                    }
                }
            }
        }
예제 #10
0
    void Start()
    {
        _manager = this;
        database = _database;
#if !UNITY_EDITOR
        toucControl = true;
#endif
        if (!toucControl)
        {
            CrossPlatformInputManager.useHardwareInput();
        }
        else
        {
            CrossPlatformInputManager.useTouchInput();
        }

        UIHandler = _UIHandler;
        path      = Application.persistentDataPath;
        Debug.Log("Game started at " + path);
        mainThread = Thread.CurrentThread;
        Timer.start("Loading Materials");
        for (int i = 0; i <= Enum.GetValues(typeof(MyMaterial)).Length - 1; i++)
        {
            ((MyMaterial)i).loadMaterial();
        }
        Timer.endAndPrint("Loading Materials");
        halfMaxChunkCount       = (maxChunkCount / 2);
        chunkPrefab             = _chunkPrefab;
        chunks                  = new Chunk[maxChunkCount, 50, maxChunkCount];
        currentTerrainGenerator = new TerrainGenerator();


        //INITIATIONS
        ItemMeshCreator.init();
        IconRenderer.init();
        if (startGame)
        {
            //LOAD SAVE FILE
            save = SaveLoader.load(saveFileName);
            currentTerrainGenerator.initiateMap();
            //INITIALIZE PLAYER
            if (save.player == null)
            {
                save.player = new Player(spawnPoint);
            }
            save.player.init(playerPrefab);
            //INITIALIZE UI
            _UIHandler.init();
        }


        //START BACKGOUND THREAD
        if (startGame)
        {
            Thread thread = new Thread(Timer.doAsycTick);
            thread.IsBackground = true;
            thread.Start();
        }
    }
예제 #11
0
    public GameObject LoadTerrainMeshes(McData data)
    {
        var gameObject = TerrainGenerator.GenerateMeshes(data);

        gameObject.name = McConsts.TerrainPrefix + data.Guid.ToString();

        return(gameObject);
    }
예제 #12
0
        private void Start()
        {
            human            = GetComponent <Human>();
            dayNightCycle    = Camera.main.GetComponent <DayNightCycle>();
            terrainGenerator = Camera.main.GetComponent <TerrainGenerator>();

            human.woodAmount = Random.Range(1, 4);
        }
예제 #13
0
 public AddConform(TerrainGenerator tg)
 {
     Debug.Log("is add conf opt type: " + tg.gen_opts.GetType());
     this.gen_opts    = (AddConformOpt)tg.gen_opts;
     this.noise_store = tg.noise_store;
     this.gen_type    = GeneratorType.AddConform;
     this.draw_editor = true;
 }
예제 #14
0
 public void Start()
 {
     terrainDataThreadInfoQueue = new ConcurrentQueue <MapThreadInfo <TileData> >();
     terrainGenerator           = GameObject.Find("Level").GetComponent <TerrainGenerator>();
     caveBuilder         = GameObject.Find("Level").GetComponent <CaveBuilder>();
     cityGenerator       = GameObject.Find("CityPoints").GetComponent <CityGenerator>();
     decorationGenerator = GameObject.Find("Decorations").GetComponent <DecorationGenerator>();
 }
예제 #15
0
 public tileGenCoro(TerrainGenerator parent, Vector2 pos, int sx, int sy, Action <TileData, Vector2> callback)
 {
     p             = parent;
     this.pos      = pos;
     this.sx       = sx;
     this.sy       = sy;
     this.callback = callback;
 }
예제 #16
0
 // Use this for initialization
 void Start()
 {
     //BoxCollider2D playerCollider = player.GetComponent<BoxCollider2D>();
     //Physics2D.IgnoreCollision()
     //LayerMask mask = 8;
     playerCamera = playerCameraObject.GetComponent<Camera>();
     terrainGenScript = terrainGen.GetComponent<TerrainGenerator>();
 }
예제 #17
0
 private static void DrawDimensionErrorMessage(TerrainGenerator instance)
 {
     if (!string.IsNullOrEmpty(instance.inspector.errorMessage) &&
         instance.inspector.errorMessage.Equals(TerrainGenerator.InspectorUtilities.LARGE_DIMENSION_ERROR_MSG))
     {
         EditorGUILayout.HelpBox(TerrainGenerator.InspectorUtilities.LARGE_DIMENSION_ERROR_MSG, MessageType.None, false);
     }
 }
예제 #18
0
 public InverseLerp(
     TerrainGenerator source,
     float lowerBound,
     float upperBound
     )
 {
     _generator = new InverseLerpGenerator(source.GetGenerator(), lowerBound, upperBound);
 }
예제 #19
0
 // Start is called before the first frame update
 void Start()
 {
     chunks             = new Dictionary <Vector3Int, Chunk>();
     chunkList          = new List <Chunk>();
     chunkThreader      = GetComponent <ChunkThreader>();
     visualChunkManager = GetComponent <VisualChunkManager>();
     tg = GetComponent <TerrainGenerator>();
 }
 public void Generate(
     object o       = null,
     EventArgs args = null)
 {
     GetReferences();
     pos  = transform.position;
     mesh = TerrainGenerator.Generate(ref datas, pos);
 }
 public Blend(
     TerrainGenerator source1,
     TerrainGenerator source2,
     TerrainGenerator weight
     )
 {
     _generator = new CoherentNoise.Generation.Combination.Blend(source1.GetGenerator(), source2.GetGenerator(), weight.GetGenerator());
 }
예제 #22
0
    private void generateWorldData()
    {
        this.terrainGenerator = GameObject.Find("Terrain").GetComponent <TerrainGenerator>();

        this.terrainGenerator.GenerateTerrain();

        this.worldData = this.terrainGenerator.GetVoxelData();
    }
예제 #23
0
 void Awake()
 {
     Target = (TerrainGenerator)target;
     if (Target.TerrainSystem != null)
     {
         Resolution = Target.TerrainSystem.Resolution;
     }
 }
예제 #24
0
    void Start()
    {
        mapImage = GetComponent <Image>();
        TerrainGenerator tg = GameObject.FindGameObjectWithTag("GameController").GetComponent <TerrainGenerator>();

        wallScale = tg.GetWallSize();
        texture   = new Texture2D(0, 0);
    }
예제 #25
0
 public RocksModifier(ISectionData sectionData, EZObjectPool[] pools,
                      TerrainGenerator terrainChunksParent, Vector3 origin) :
     base("Rocks_", pools)
 {
     this.sectionData         = sectionData;
     this.terrainChunksParent = terrainChunksParent;
     this.origin = origin;
 }
예제 #26
0
 public MultiplyConform(TerrainGenerator tg)
 {
     Debug.Log("is mul conf opt: " + tg.gen_opts.GetType());
     this.gen_opts    = (MultiplyConformOpt)tg.gen_opts;
     this.noise_store = tg.noise_store;
     this.gen_type    = GeneratorType.MultiplyConform;
     this.draw_editor = true;
 }
예제 #27
0
 void Awake()
 {
     if (instance != null)
     {
         Debug.LogError("Multiple instances of " + this + " found");
     }
     instance = this;
 }
        private static void DisplayContextMenuForPrefab(Rect r, TerrainGenerator instance, int i)
        {
            int  childCount = instance.EnvironmentalPainter.GetGroupChildCount(i);
            bool active     = instance.EnvironmentalPainter.IsGroupActive(i);

            GameObject prefab         = instance.EnvironmentalPainterSettings.GetPrefabs()[i];
            bool       hasCombination = instance.EnvironmentalPainter.GetCombinationsGroup(prefab).childCount > 0;

            GenericPopup menu = new GenericPopup();

            if (childCount > 0 && active)
            {
                menu.AddItem(new GUIContent("Group"), false, () => { GroupPrefabInstancesContextHandler(instance, i); });
            }
            else
            {
                menu.AddDisabledItem(new GUIContent("Group"), false);
            }
            if (childCount > 0 && active && hasCombination)
            {
                menu.AddItem(new GUIContent("UnGroup"), false, () => { UnGroupPrefabInstancesContextHandler(instance, i); });
            }
            else
            {
                menu.AddDisabledItem(new GUIContent("UnGroup"), false);
            }
            menu.AddSeparator();
            if (childCount > 0 && !active)
            {
                menu.AddItem(new GUIContent("Show All"), false, () => { ShowAllPrefabInstancesContextHandler(instance, i); });
            }
            else
            {
                menu.AddDisabledItem(new GUIContent("Show All"), false);
            }
            if (childCount > 0 && active)
            {
                menu.AddItem(new GUIContent("Hide All"), false, () => { HideAllPrefabInstancesContextHandler(instance, i); });
            }
            else
            {
                menu.AddDisabledItem(new GUIContent("Hide All"), false);
            }
            menu.AddSeparator();
            menu.AddItem(new GUIContent("Export Distribution Map"), false, () => { ExportDistributionMapContextHandler(instance, i); });
            menu.AddItem(new GUIContent("Mass Placement"), false, () => { MassPlacementContextHandler(instance, i); });
            menu.AddSeparator();
            if (childCount > 0)
            {
                menu.AddItem(new GUIContent("Clear All"), false, () => { ClearAllPrefabInstancesContextHandler(instance, i); });
            }
            else
            {
                menu.AddDisabledItem(new GUIContent("Clear All"), false);
            }

            menu.Show(r);
        }
예제 #29
0
        public static string SaveGame()
        {
            CameraController cameraController = Camera.main.GetComponent <CameraController>();

            string saveName = DateTime.Now.ToString("MM_dd_yyyy_HH_mm_ss");

            QuickSaveWriter quickSaveWriter = QuickSaveWriter.Create(saveName);

            quickSaveWriter.Write(GameInfo.MAP_SEED, GameInfo.mapSeed);
            quickSaveWriter.Write(GameInfo.MAP_SIZE, GameInfo.mapSize);
            quickSaveWriter.Write("playerTeam", GameInfo.playerTeam);
            quickSaveWriter.Write("cameraPosition", Camera.main.transform.position);
            quickSaveWriter.Write("cameraRotation", Camera.main.transform.rotation);

            quickSaveWriter.Write("gold", cameraController.resources[BaseBehavior.ResourceType.Gold]);
            quickSaveWriter.Write("wood", cameraController.resources[BaseBehavior.ResourceType.Wood]);
            quickSaveWriter.Write("food", cameraController.resources[BaseBehavior.ResourceType.Food]);
            quickSaveWriter.Write("favor", cameraController.resources[BaseBehavior.ResourceType.Favor]);

            int index = 0;

            foreach (GameObject unitObject in GameObject.FindGameObjectsWithTag("Building").Concat(GameObject.FindGameObjectsWithTag("Unit")))
            {
                BaseBehavior unitBaseBehavior = unitObject.GetComponent <BaseBehavior>();
                unitBaseBehavior.Save(ref quickSaveWriter, index);
                index++;
            }
            quickSaveWriter.Write("indexCount", index);

            TerrainGenerator terrainGenerator = Terrain.activeTerrain.GetComponent <TerrainGenerator>();

            // Blind texture
            Color[] colors    = terrainGenerator.blindTexture2D.GetPixels();
            int[]   blindInfo = new int[colors.Length];
            for (int i = 0; i < colors.Length; i++)
            {
                blindInfo[i] = colors[i] == Color.black ? 1 : 0;
            }
            quickSaveWriter.Write("blindTextureData", blindInfo);

            // Binds
            for (int number = 1; number <= 9; number++)
            {
                int[] binds = new int[cameraController.unitsBinds[KeyCode.Alpha0 + number].Count];
                int   i     = 0;
                foreach (GameObject bindObject in cameraController.unitsBinds[KeyCode.Alpha0 + number])
                {
                    BaseBehavior bindObjectBaseBehavior = bindObject.GetComponent <BaseBehavior>();
                    binds[i] = bindObjectBaseBehavior.uniqueId;
                    i++;
                }
                quickSaveWriter.Write(new StringBuilder(15).AppendFormat("{0}_{1}", number, "bind").ToString(), binds);
            }

            quickSaveWriter.Commit();

            return(saveName);
        }
        private static void DrawCombinationsGroup(TerrainGenerator instance)
        {
            instance.inspector.isCombinationsGroupExpanded = EditorCommon.GroupFoldout(instance.inspector.isCombinationsGroupExpanded, "Combinations");
            instance.EnvironmentalPainterSettings.drawCombinationsBounds = instance.inspector.isCombinationsGroupExpanded;
            if (instance.inspector.isCombinationsGroupExpanded)
            {
                EditorGUI.indentLevel += 1;

                List <GameObject> prefabs           = instance.EnvironmentalPainterSettings.GetPrefabs();
                List <Transform>  combinationGroups = GetAllCombinationGroups(instance);
                bool hasNonEmptyGroup = combinationGroups.Find(t => t.childCount != 0) != null;
                if (!hasNonEmptyGroup)
                {
                    EditorGUILayout.HelpBox("No combination created yet!", MessageType.None);
                }
                else
                {
                    Vector2 tileSize = new Vector2(50, 50);
                    for (int i = 0; i < combinationGroups.Count; ++i)
                    {
                        if (combinationGroups[i].childCount == 0)
                        {
                            continue;
                        }
                        EditorGUILayout.BeginHorizontal();
                        Rect    tileRect = EditorGUILayout.GetControlRect(GUILayout.Width(tileSize.x), GUILayout.Height(tileSize.y));
                        Texture t        = AssetPreview.GetAssetPreview(prefabs[i]);
                        if (AssetPreview.IsLoadingAssetPreview(prefabs[i].GetInstanceID()))
                        {
                            int dotCount = System.DateTime.Now.Millisecond / 300;
                            GUI.Label(tileRect, EditorCommon.DOT_ANIM[dotCount], EditorCommon.CenteredLabel);
                        }
                        else if (t == null)
                        {
                            string assetPath = AssetDatabase.GetAssetPath(prefabs[i]);
                            if (!string.IsNullOrEmpty(assetPath))
                            {
                                AssetDatabase.ImportAsset(assetPath, ImportAssetOptions.ForceSynchronousImport);
                            }
                        }
                        else
                        {
                            EditorGUI.DrawPreviewTexture(tileRect, t);
                        }

                        EditorGUILayout.BeginVertical();
                        EditorGUILayout.LabelField(prefabs[i].name);
                        EditorGUILayout.LabelField("Count: " + combinationGroups[i].childCount, EditorCommon.ItalicLabel);
                        EditorGUILayout.EndVertical();
                        EditorGUILayout.EndHorizontal();
                    }
                }

                EditorGUI.indentLevel -= 1;
            }

            EditorGUILayout.GetControlRect(GUILayout.Height(1));
        }
예제 #31
0
 public GeometryPainter(TerrainGenerator terrain)
 {
     if (terrain == null)
     {
         throw new System.ArgumentException("Terrain cannot be null");
     }
     this.terrain = terrain;
     settings     = new ToolsSettings();
 }
예제 #32
0
 void Awake()
 {
     if (Instance)
     {
         Destroy(gameObject);
         return;
     }
     Instance = this;
 }
예제 #33
0
 // Update is called once per frame
 void Update()
 {
     if (Input.GetKeyDown(KeyCode.Space))
     {
         TerrainGenerator terrgen = transform.GetComponent <TerrainGenerator>();
         terrgen.seed = Random.Range(-10000, 10000);
         terrgen.GenerateMap();
     }
 }
예제 #34
0
 public RiverInfo(TerrainGenerator terrain)
 {
     riverPath = new List<Vertex>();
     reachTop = false;
     reachRight = false;
     reachBot = false;
     reachLeft = false;
     this.terrain = terrain;
 }
        private static void DrawLibraryGroup(TerrainGenerator instance, ref int libraryObjectPickerControlId)
        {
            instance.inspector.isLibraryGroupExpanded = EditorCommon.GroupFoldout(instance.inspector.isLibraryGroupExpanded, "Library");
            List <GameObject> prefabs = instance.EnvironmentalPainterSettings.GetPrefabs();

            if (instance.inspector.isLibraryGroupExpanded)
            {
                EditorGUILayout.Space();
                if (prefabs != null && prefabs.Count > 0)
                {
                    float   width      = EditorGUIUtility.currentViewWidth - EditorGUI.indentLevel * EditorGUIUtility.singleLineHeight;
                    Vector2 tileSize   = new Vector2(75, 75);
                    int     itemPerRow = (int)(width / tileSize.x);
                    itemPerRow = Mathf.Clamp(itemPerRow, 1, prefabs.Count);
                    int numberOfRow = Mathf.CeilToInt(prefabs.Count * 1.0f / itemPerRow);
                    for (int i = 0; i < itemPerRow * numberOfRow; ++i)
                    {
                        if (i % itemPerRow == 0)
                        {
                            EditorGUILayout.BeginHorizontal(GUILayout.ExpandWidth(false));
                        }

                        DrawPrefabTile(instance, tileSize, i);

                        if ((i + 1) % itemPerRow == 0)
                        {
                            EditorGUILayout.EndHorizontal();
                            EditorGUILayout.Space();
                        }
                    }
                }
                else
                {
                    EditorGUILayout.HelpBox("Try adding a prefab!", MessageType.None);
                }

                EditorGUILayout.BeginHorizontal();
                GUILayout.FlexibleSpace();
                if (GUILayout.Button("Add", GUILayout.Width(EditorCommon.standardWidth), GUILayout.Height(EditorCommon.standardHeight)))
                {
                    HandleAddPrefabButtonClicked(ref libraryObjectPickerControlId);
                }
                GUI.enabled = prefabs != null && prefabs.Count > 0;
                if (GUILayout.Button("Remove", GUILayout.Width(EditorCommon.standardWidth), GUILayout.Height(EditorCommon.standardHeight)))
                {
                    HandleRemovePrefabButtonClicked(instance);
                }
                GUI.enabled = true;
                if (GUILayout.Button("Reset", GUILayout.Width(EditorCommon.standardWidth), GUILayout.Height(EditorCommon.standardHeight)))
                {
                    HandleResetButtonClicked(instance);
                }
                EditorGUILayout.EndHorizontal();
            }

            EditorGUILayout.GetControlRect(GUILayout.Height(1));
        }
	void Awake ()
	{
		if (Instance)
		{
			Destroy(gameObject);
			return;
		}
		Instance = this;
	}
    private void Awake()
    {
        TerrainGenerator generator = GetComponent <TerrainGenerator>();

        Assert.IsNotNull(generator);
        terrainData = generator.TerrainData;

        ecosystem = FindObjectOfType <Ecosystem>();
    }
예제 #38
0
    public void AssignFunctions(TerrainGenerator terrainGenerator, FilterGenerator filterGenerator, 
        RiverGenerator riverGenerator, ErosionGenerator erosionGenerator)
    {
        tg = terrainGenerator;
        fg = filterGenerator;
        rg = riverGenerator;
        eg = erosionGenerator;
        lt = tg.localTerrain;

        UpdateLayers();
    }
예제 #39
0
    public void AssignFunctions(GlobalCoordinates globalTerrainC, TerrainGenerator terrainGenerator, 
        FilterGenerator filterGenerator, RiverGenerator riverGenerator, ErosionGenerator erosionGenerator)
    {
        this.globalTerrainC = globalTerrainC;

        tg = terrainGenerator;
        fg = filterGenerator;
        rg = riverGenerator;
        eg = erosionGenerator;

        lm.AssignFunctions(tg, fg, rg, eg);
    }
예제 #40
0
    public GUIExport(GUIManager gm)
    {
        this.gm = gm;
        tg = gm.cm.terrainGenerator;

        menuWidth = gm.menuWidth;
        rightMenuOffset = gm.rightOffset;
        topOffset = gm.topOffset;
        buttonHeight = gm.menuButtonHeight;
        sideOffset = 10;
        scaleY = gm.scaleY;

        //path = "C:\\Users\\Vukmir\\Dropbox\\ŠKOLA\\SBAPR\\Fractal Nature II\\Assets\\Export";
        path = "C:";
        name = "";
    }
예제 #41
0
 void Start()
 {
     generator = GetComponent<TerrainGenerator>();
     filter = GetComponent<MeshFilter>();
     if (terrainMesh != null) {
         graph = new Graph(terrainMesh);
         terrain = generator.GenerateTerrain(graph);
         if (water != null) {
             water.sharedMesh = graph.BuildMesh(false,
                 (vertex) => {
                     return vertex.position + vertex.normal * waterGrow;
                 }
             );
         }
         GenerateMesh();
     }
 }
예제 #42
0
파일: BiomeMap.cs 프로젝트: 4026/worldgen
        public BiomeMap(TerrainGenerator newTerrainData)
        {
            m_terrainData = newTerrainData;
            m_data = new BiomeMapPixel[Size, Size];

            //Set biome weights for all pixels
            Point position;
            for (int x = 0; x < Size; ++x)
            {
                for (int y = 0; y < Size; ++y)
                {
                    position = new Point(x, y);

                    float heightAboveSeaLevel = m_terrainData.GetHeightAboveSeaLevelAt(position);
                    float latitude = Mathf.Clamp(position.y / (float)m_terrainData.Heightmap.size, 0f, 1f);
                    float precipitation = m_terrainData.Rainmap.GetValueAt(position);

                    m_data[y, x] = new BiomeMapPixel(latitude, heightAboveSeaLevel, precipitation);
                }
            }

            //Iterate through all pixels, setting their parent Biome
            for (int x = 0; x < Size; ++x)
            {
                for (int y = 0; y < Size; ++y)
                {
                    //Ignore pixels that have already had their parent biome set.
                    if (m_data[y, x].ParentBiome != null)
                    {
                        continue;
                    }

                    //Generate a new Biome object from the primary biome type of this pixel.
                    Biome biome = new Biome(m_data[y, x].GetPrimaryBiome());

                    //Flood fill the map with that biome.
                    floodFill(new Point(x, y), biome);

                    //Generate a name for that biome, now that it knows how big it is.
                    biome.GenerateName();
                }
            }
        }
예제 #43
0
    public void changeWorld()
    {
        foreach(GameObject go in _terrainGameObjects)
        {
            go.GetComponent<MeshCollider>().enabled = false;
            go.GetComponent<MeshRenderer>().enabled = false;
        }

        foreach(GameObject[] goa in _undergroundGameObjects)
        {
            foreach(GameObject go in goa)
            {
                go.GetComponent<MeshRenderer>().enabled = false;
            }
        }

        terrainGenerator = new TerrainGenerator(_camera);
        ResetTerrain();
        ChangeTerrainColor(new Color(Random.value/2+0.5f,Random.value/2+0.5f,Random.value/2+0.5f,1.0f));
    }
예제 #44
0
    //***********<RIVER...>*************
    public RiverGenerator(TerrainGenerator terrain)
    {
        this.terrain = terrain;
        filtermanager = terrain.filterManager;
        terrain.riverGenerator = this;

        vertices = terrain.vertices;
        terrainSize = terrain.terrainSize;
        heightMap = terrain.heightMap;

        frp = new FunctionRiverPlanner(this);
        frd = new FunctionRiverDigger(this);
        fmc = new FunctionMathCalculator(this);
        ftm = new FunctionTerrainManager(this);
        fd = new FunctionDebugger(this);

        currentRiver = new RiverInfo(terrain);

        AssignFunctions();
    }
예제 #45
0
    protected virtual void Init(int wSize)
    {
        worldSize = wSize;
        worldTree = new HybridTree((sbyte)worldSize);
        worldTree.Init();

        discoveryWorkTree = new HybridTree((sbyte)worldSize);
        discoveryWorkTree.Init();

        mainThreadSyncedTree = new WorldTree((sbyte)worldSize);
        mainThreadSyncedTree.Init();

        wtSyncingTree = new WorldTree((sbyte)worldSize);
        wtSyncingTree.Init();

        terrainGenerator = new TerrainGenerator(Mathf.Pow(2, worldSize));
    }
예제 #46
0
    public void DiscoverPointsWork()
    {
        discoveredPoints = new List<Vector3>();
        discoveredValues = new List<sbyte>();
        List<Vector3> openList = new List<Vector3>();
        openList.AddRange(pendingDiscoveryWork);
        pendingDiscoveryWork.Clear();

        TerrainGenerator tgen = new TerrainGenerator(Mathf.Pow(2, worldSize));

        Vector3 offset;
        int jindex;
        sbyte value;
        Stopwatch stopwatch1 = new Stopwatch();
        stopwatch1.Start();
        for (int i = openList.Count - 1; i >= 0; i--)
        {
            //jindex = discoveryWorkTree.GetIndexAtWorldPoint(openList[i]);
            value = discoveryWorkTree.GetValueAt(openList[i]);

            if (value == 1)
            {
                openList.RemoveAt(i);
            }
            else
            {
                //discoveryWorkTree.SetValueAt(jindex, 1);
            }
        }
        stopwatch1.Stop();
        int index = 0;

        int debugCounter = 0;
        int discoveredNonVoid = 0;

        int faultychecks = 0;
        Stopwatch stopwatch2 = new Stopwatch();
        Stopwatch stopwatch3generation = new Stopwatch();
        Stopwatch stopwatch4setvalue = new Stopwatch();
        while (index < openList.Count)
        {

            for (int i = 0; i < 6; i++)
            {
                offset = openList[index];
                offset[(int)(i / 2)] += -1 + ((i % 2) * 2);  //sixaxis
                stopwatch2.Start();

               // jindex = discoveryWorkTree.GetIndexAtWorldPointSimple(offset);
                value = discoveryWorkTree.GetValueAt(offset);
                stopwatch2.Stop();
                if (value < 1)
                {
                    stopwatch3generation.Start();
                    value = tgen.GetPointValue(offset);
                    stopwatch3generation.Stop();
                    //discoveryWorkTree.SetValueAt(jindex, value);
                    if (value > 1)
                    {
                        discoveredPoints.Add(offset);
                        discoveredValues.Add(value);
                    }

                    if (value == 1)
                    {
                        if (!openList.Contains(offset))
                        {
                            openList.Add(offset);
                        }
                    }
                    else
                    {
                        discoveredNonVoid++;
                        stopwatch4setvalue.Start();
                        discoveryWorkTree.SetValueAtPoint(offset, value);
                        stopwatch4setvalue.Stop();

                    }

                }
                else
                {
                    faultychecks++;
                }

                /*//int jindex = discoveryWorkTree.GetIndexAtWorldPointSimple(offset);
                //sbyte value = discoveryWorkTree.GetValueAt(jindex);
                if (value <= 0)
                {
                    if(!openList.Contains(offset))
                    {
                        value = tgen.GetPointValue(offset);
                        discoveredPoints.Add(offset);
                        discoveredValues.Add(value);
                        if (value == 1)
                        {
                            openList.Add(offset);
                        }
                    }
                }*/
            }
            stopwatch4setvalue.Start();

            discoveryWorkTree.SetValueAtPoint(openList[index], 1);
            stopwatch4setvalue.Stop();

            index++;

            if (discoveredNonVoid >= 40)
            {/*
                DebugOutput.Shout(openList.Count.ToString() + " and faulty checks " + faultychecks.ToString() + "indiceCount = " + discoveryWorkTree.GetIndiceCount().ToString());
                DebugOutput.Shout("cleanup: " + stopwatch1.ElapsedMilliseconds.ToString() +
                    "  getindex: " + stopwatch2.ElapsedMilliseconds.ToString() +
                "  generation: " + stopwatch3generation.ElapsedMilliseconds.ToString() +
               "  setvalue: " + stopwatch4setvalue.ElapsedMilliseconds.ToString());*/
                for (int k = index; k < openList.Count; k++)
                {
                    pendingDiscoveryWork.Add(openList[k]);
                }
                break;
            }

        }
    }
        /// <summary>
        /// Sets up the terrain functions
        /// </summary>
        /// <param name="heightFunction">The terrain height function</param>
        /// <param name="groundFunction">The terrain ground offset function</param>
        public void SetupTerrain( TerrainFunction heightFunction, TerrainFunction groundFunction )
        {
            if ( Planet == null )
            {
                throw new InvalidOperationException( "Terrain model does not have an associated planet. Cannot setup terrain" );
            }
            float radius = SpherePlanet.PlanetModel.Radius.ToRenderUnits;
            float height = MaximumHeight.ToRenderUnits;

            // NOTE: AP: Patch scale is irrelevant, because vertices are projected onto the function sphere anyway
            m_Gen = new TerrainGenerator( TerrainGeometry.Sphere, heightFunction, groundFunction );
            m_Gen.Setup( 1024, radius, radius + height );
            m_Gen.SetSmallestStepSize( MinimumStepSize, MinimumStepSize );

            OnModelChanged( false, true );
        }
예제 #48
0
 // Use this for initialization
 void Start()
 {
     thi = this;
     player = GameObject.Find("PlayerTest").transform;
     seed = Random.Range(1000f, 100000f);
     colorWave = new Texture2D(waveGradientLength, 1);
     heightWave = new Texture2D(heightGradientLength, 1);
     chromaticAbberation = Camera.main.GetComponent<UnityStandardAssets.ImageEffects.VignetteAndChromaticAberration>();
     randomSkyHueOffset = Random.value;
     if (textures.Length > 0)
         mat.SetTexture(Shader.PropertyToID("_MainTex"), textures[textureIndex]);
 }
	// Use this for initialization
	void Start () 
    {
        playerCamera = Camera.main;
        //the following lines should be their own class "PlayerViewManager"?
        border = (Transform)Instantiate(selectionBorder, new Vector2(0, 0), Quaternion.identity);
        //Terrain Generation will not be part of player class
        this.terrainGenerator = tg.gameObject.GetComponent<TerrainGenerator>();
        this.terrainGenerator.init();
        //player cursor
        this.border_x = (this.terrainGenerator.terrain_width / 2) - 1;
        this.border_y = (this.terrainGenerator.terrain_height / 2) - 1;
	}
예제 #50
0
    // START:
    /// <summary>
    /// Start this instance.
    /// </summary>
    public void Start()
    {
        // Get the components
        dungeonGenerator = GetComponent<DungeonGenerator> ();
        sceneryGenerator = GetComponent<SceneryGenerator> ();

        stairsGenerator = GetComponent<StairsGenerator> ();
        roomGenerator = GetComponent<RoomGenerator> ();
        perimeterGenerator = GetComponent<PerimeterGenerator> ();
        entranceGenerator = GetComponent<EntranceGenerator> ();
        corridorGenerator = GetComponent<CorridorGenerator> ();
        voidGenerator = GetComponent<VoidGenerator> ();
        pitGenerator = GetComponent<PitGenerator> ();
        chestGenerator = GetComponent<ChestGenerator> ();
        caveGenerator = GetComponent<CaveGenerator> ();

        terrainCarver = GetComponent<TerrainCarver> ();
        terrainGenerator = GetComponent<TerrainGenerator> ();
        textureGenerator = 	GetComponent<TerrainTextureGenerator> ();

        // Initialize the instances
        stairsGenerator.Start ();
        roomGenerator.Start ();
        perimeterGenerator.Start ();
        entranceGenerator.Start ();
        corridorGenerator.Start ();
        voidGenerator.Start ();
        pitGenerator.Start ();
        chestGenerator.Start ();
        caveGenerator.Start ();

        terrainCarver.Start ();
        terrainGenerator.Start ();
        textureGenerator.Start ();

        // Initialize the floor array
        allFloors = new Floor[dungeonGenerator.numFloors];
    }
예제 #51
0
 public FilterManager(TerrainGenerator terrain)
 {
     terrainSize = terrain.terrainSize;
     vertices = terrain.vertices;
     terrain.filterManager = this;
 }
예제 #52
0
    // Use this for initialization
    public void Start()
    {
        dungeonGenerator = GetComponent<DungeonGenerator> ();
        terrainGenerator = GetComponent<TerrainGenerator> ();
        textureGenerator = GetComponent<TerrainTextureGenerator> ();

        terrainToolkit = terrain.GetComponent<TerrainToolkit> ();
    }
예제 #53
0
    void Start()
    {
        // Initialise main Class object
        terrain = new TerrainGenerator();

        // Calling the constructor (Unity's C# does not allow conventional constructors)
        terrain.initialise(patchSize, patchMatrixSize);

        // Updating end-point of main mesh
        endPoint = new Vector3(terrain.terrainSize - 1, 0, terrain.terrainSize - 1);

        // Generate fractal Diamond-Square turbulence
        terrain.applyDiamondSquare(diSqStrength);

        // Initialise procedural texture variables
        terrain.applyProceduralTex(true, sandColor, sandLimit, sandStrength, sandCoverage, true, grassColor, grassStrength, true, snowColor, snowLimit, snowStrength, snowCoverage, true, rockColor, slopeLimit, slopeStrength, noiseTexValue);

        // Build mesh
        terrain.build();

        // erosionManager has to be created when
        erosionManager = new ErosionManager(terrain);
        erosionManager.initHydraulicMaps();
        filterManager = new FilterManager(terrain);
        //riverGenerator has to be after filterManager!
        riverGenerator = new RiverGenerator(terrain);

        //doesn't work well with on-fly generation
        riverGenerator.ftm.PerserveMountains(5, 30, 20);
    }
예제 #54
0
    void TerrainTest()
    {
        int testSize = 100;
        int stepSize = 1;
        //int octaves,double persistence
        TerrainGenerator tg = new TerrainGenerator(16384);

        Vector3 testVector = new Vector3(0, 0, 0);
        testSize = testSize / 2;
        double moreThan = 0.44;
        double lessThan = 0.58;

        for (int i = -testSize; i < testSize; i+=stepSize)
        {
            for (int j = -testSize; j < testSize; j += stepSize)
            {

                for (int k = -10; k < 10; k++)
                {
                    testVector.x = i;
                    testVector.y = j;
                    testVector.z = k;

                    if (tg.hollowTube(testVector))
                    {

                        //double d = tg.OctavePerlin(testVector, 11, 2.5);

                            //Color col = UtilityColor.hsv2rgb(1.0f - (float)d, 1, 1);

                        Color col = Color.green;
                        UnityEngine.Debug.DrawLine(testVector, testVector + Vector3.up, col,40.0f);
                        UnityEngine.Debug.DrawLine(testVector + (Vector3.up * 0.5f) + (Vector3.left * 0.5f), testVector + (Vector3.up * 0.5f) + (Vector3.right * 0.5f), col, 40.0f);
                        UnityEngine.Debug.DrawLine(testVector + (Vector3.up * 0.5f) + (Vector3.forward * 0.5f), testVector + (Vector3.up * 0.5f) + (Vector3.back * 0.5f), col, 40.0f);

                    }
                    else if (tg.PlatVeines(testVector))
                    {
                            double d = tg.OctavePerlin(testVector, 11, 2.5);

                        Color col = UtilityColor.hsv2rgb(1.0f - (float)d, 1, 1);
                        UnityEngine.Debug.DrawLine(testVector, testVector + Vector3.up, col, 40.0f);
                        UnityEngine.Debug.DrawLine(testVector + (Vector3.up * 0.5f) + (Vector3.left * 0.5f), testVector + (Vector3.up * 0.5f) + (Vector3.right * 0.5f), col, 40.0f);
                        UnityEngine.Debug.DrawLine(testVector + (Vector3.up * 0.5f) + (Vector3.forward * 0.5f), testVector + (Vector3.up * 0.5f) + (Vector3.back * 0.5f), col, 40.0f);

                    }
                    else if (tg.PallasiteDeposit(testVector))
                    {
                        Color col = Color.red;
                        UnityEngine.Debug.DrawLine(testVector, testVector + Vector3.up, col,40.0f);
                        UnityEngine.Debug.DrawLine(testVector + (Vector3.up * 0.5f) + (Vector3.left * 0.5f), testVector + (Vector3.up * 0.5f) + (Vector3.right * 0.5f), col, 40.0f);
                        UnityEngine.Debug.DrawLine(testVector + (Vector3.up * 0.5f) + (Vector3.forward * 0.5f), testVector + (Vector3.up * 0.5f) + (Vector3.back * 0.5f), col, 40.0f);

                    }
                    else if (tg.IceDeposit(testVector))
                    {
                        Color col = Color.white;
                        UnityEngine.Debug.DrawLine(testVector, testVector + Vector3.up, col, 20.0f);
                        UnityEngine.Debug.DrawLine(testVector + (Vector3.up * 0.5f) + (Vector3.left * 0.5f), testVector + (Vector3.up * 0.5f) + (Vector3.right * 0.5f), col, 20.0f);
                    }
                    else if (tg.subIceDeposit(testVector))
                    {
                        Color col = Color.cyan;
                        UnityEngine.Debug.DrawLine(testVector, testVector + Vector3.up, col, 20.0f);
                        UnityEngine.Debug.DrawLine(testVector + (Vector3.up * 0.5f) + (Vector3.left * 0.5f), testVector + (Vector3.up * 0.5f) + (Vector3.right * 0.5f), col, 20.0f);
                    }
                   /* else
                    {
                        double d = tg.OctavePerlin(testVector, 12, 15.5);
                        Color col = UtilityColor.hsv2rgb((1.0f - (float)d)*0.66f, 1, 1);

                       // Color col = Color.green;
                        UnityEngine.Debug.DrawLine(testVector, testVector + Vector3.up, col, 20.0f);
                        UnityEngine.Debug.DrawLine(testVector + (Vector3.up * 0.5f) + (Vector3.left * 0.5f), testVector + (Vector3.up * 0.5f) + (Vector3.right * 0.5f), col, 20.0f);
                    }*/

                   /* if (tg.subIceDeposit(testVector))
                    {
                        Color col = Color.cyan;
                        UnityEngine.Debug.DrawLine(testVector, testVector + Vector3.up, col, 20.0f);
                        UnityEngine.Debug.DrawLine(testVector + (Vector3.up * 0.5f) + (Vector3.left * 0.5f), testVector + (Vector3.up * 0.5f) + (Vector3.right * 0.5f), col, 20.0f);
                    }

                    */

                    /*if (tg.doubleANDVectorV1(testVector, 0.78, 0.88, 10, 10.5))
                    {

                        double d = tg.OctavePerlin(testVector, 10, 10.5);

                        Color col = UtilityColor.hsv2rgb((float)d, 1, 1);

                        //Color col = Color.gray;
                        //UnityEngine.Debug.DrawLine(testVector, testVector + Vector3.up, col, 20.0f);
                        //UnityEngine.Debug.DrawLine(testVector + (Vector3.up * 0.5f) + (Vector3.left * 0.5f), testVector + (Vector3.up * 0.5f) + (Vector3.right * 0.5f), col, 20.0f);

                    }*/

                    /*if (d > moreThan && d < lessThan )
                    {
                        UnityEngine.Debug.DrawLine(testVector, testVector + Vector3.up, UtilityColor.hsv2rgb(1.0f - (float)d, 1, 1), 20.0f);
                        UnityEngine.Debug.DrawLine(testVector + (Vector3.up * 0.5f) + (Vector3.left * 0.5f), testVector + (Vector3.up * 0.5f) + (Vector3.right * 0.5f), UtilityColor.hsv2rgb(1.0f - (float)d, 1, 1), 20.0f);
                    }*/

                   /* if (d>0.45 && d < 0.55)
                    {
                        UnityEngine.Debug.DrawLine(testVector, testVector + Vector3.up,Color.blue,23.0f);
                    }
                    else if (d > 0.45)
                    {
                        UnityEngine.Debug.DrawLine(testVector, testVector + Vector3.up,Color.red,23.0f);

                    }
                    else if (d > 0.40)
                    {
                        UnityEngine.Debug.DrawLine(testVector, testVector + Vector3.up, Color.green, 23.0f);

                    }*/

                }
            }
        }
    }
예제 #55
0
 public Terrain( GameObject originGameObject, TerrainGenerator mterrainGenerator)
 {
     _originGameObject = originGameObject;
     terrainGenerator = mterrainGenerator;
 }
예제 #56
0
    IEnumerator terrainTestNew()
    {
        int testSize = 400;
        int stepSize = 1;
        //int octaves,double persistence
        TerrainGenerator tg = new TerrainGenerator(16384);

        Vector3 testVector = new Vector3(0, 0, 0);
        testSize = testSize / 2;
        double moreThan = 0.44;
        double lessThan = 0.58;

        for (int i = -testSize; i < testSize; i += stepSize)
        {
            yield return 0;
            for (int j = -testSize; j < testSize; j += stepSize)
            {
                int height = 30;
                int kstep = 1;

                if (i > -height && i < height)
                {
                    height = testSize;
                }
                for (int k = -height; k < height; k+=kstep)
                {
                    testVector.x = i;
                    testVector.z = j;

                    testVector.y = k;

                    if (tg.MediumCavern(testVector))
                    {
                        Color col = Color.blue;
                        drawPoint(testVector, col);
                    }
                    else if (tg.SmallCavern(testVector))
                    {
                        Color col = Color.cyan;
                        drawPoint(testVector, col);

                    }
                   /* else if (tg.TestDeposit(testVector))
                    {
                        Color col = Color.grey;
                        drawPoint(testVector, col);

                    }*/
                }
            }
        }
    }
예제 #57
0
    public void recalculateDestination()
    {

        if (state == "GoToCenter")
        {
            if (terrain == null)
                terrain = GameObject.FindObjectOfType<TerrainGenerator>();

            List<Vector3> e = terrain.getListCase(transform.position, typetogo);

            if (e.Count == 0)
            {
                Vector2 newPos = Vector3.left * 999f;
                Vector3 pos2 = Vector3.left * 999f;

                while (pos2.x > 20f || pos2.x < 0f || pos2.z > 20f || pos2.z < 0f)
                {
                    newPos = Random.insideUnitCircle * 4f;
                    pos2 = transform.position + new Vector3(newPos.x, 0f, newPos.y);
                }

                pos2.y = 0f;

                GetComponent<NavMeshAgent>().SetDestination(pos2);
                return;
            }



            Vector3 test = new Vector3(500, 500, 500);

            foreach (Vector3 entry in e)
            {
                if (Vector3.Distance(transform.position, test) > Vector3.Distance(transform.position, entry))
                {
                    test = entry;
                }
            }


            cible = new Vector3(test.x, 0f, test.z);

            if (!GetComponent<NavMeshAgent>().isOnNavMesh)
            {
                NavMeshHit posTogo;
                NavMesh.SamplePosition(transform.position, out posTogo, 1000f, NavMesh.AllAreas);

                GetComponent<NavMeshAgent>().nextPosition = posTogo.position;

                return ;
            }

            GetComponent<NavMeshAgent>().SetDestination(cible);

        }
    }
        /// <summary>
        /// Sets up the terrain functions
        /// </summary>
        /// <param name="heightFunction">The terrain height function</param>
        /// <param name="groundFunction">The terrain ground offset function</param>
        public void SetupTerrain( TerrainFunction heightFunction, TerrainFunction groundFunction )
        {
            if ( PlanetModel == null )
            {
                throw new InvalidOperationException( "Terrain model does not have an associated planet. Cannot setup terrain" );
            }

            float height = MaximumHeight.ToRenderUnits;

            m_Gen = new TerrainGenerator( TerrainGeometry.Plane, heightFunction, groundFunction );
            m_Gen.Setup( 1024, 0, height );
            m_Gen.SetSmallestStepSize( 0.001f, 0.001f );

            OnModelChanged( );
        }
예제 #59
0
 public RandomTerrain(TerrainGenerator tg)
 {
     this.tg = tg;
 }
예제 #60
0
    void Awake()
    {
        transform.position = Vector3.zero;

        _camera = Camera.main;
        _camera.orthographicSize = Screen.height / 2;
        _cameraTransform = _camera.transform;

        //terrain setup
        terrainGenerator = new TerrainGenerator(_camera);
        ResetTerrain();
        ChangeTerrainColor(new Color(Random.value/2+0.5f,Random.value/2+0.5f,Random.value/2+0.5f,1.0f));

        for(var i = 0; i <= 1; i++)
        {
            var go = new GameObject( "mesh " + i);
            go.transform.parent = transform;
            go.isStatic = true;
            go.AddComponent<MeshFilter>();

            var collider = go.AddComponent<MeshCollider>();
            collider.material = physicsMaterial;
            collider.smoothSphereCollisions = true;

            var meshRenderer = go.AddComponent<MeshRenderer>();
            meshRenderer.sharedMaterial = terrainMaterialBorder;

            _terrainGameObjects[i] = go;
        }

        for(var i = 0; i < 2; i++)
        {
            _undergroundGameObjects[i] = new GameObject[numberOfSUndergroundTile];
            _undergroundMeshFilter[i] = new MeshFilter[numberOfSUndergroundTile];
            _objs[i] = new List<GameObject>();

            for(var j = 0; j < numberOfSUndergroundTile; j++)
            {
                var go = new GameObject( "undergound " + i + " " + j);
                go.transform.parent = transform;
                _undergroundMeshFilter[i][j] = go.AddComponent<MeshFilter>();

                var meshRenderer = go.AddComponent<MeshRenderer>();
                meshRenderer.sharedMaterial = terrainMaterialInside;

                _undergroundGameObjects[i][j] = go;
            }
        }
    }