Example #1
0
        public static void TryRegisterItems()
        {
            if (Consumables == null || ZNetScene.instance == null || ObjectDB.instance == null || ObjectDB.instance.m_items.Count == 0)
            {
                return;
            }

            PrefabCreator.Reset();
            var success = 0;
            var fail    = 0;

            foreach (var item in Consumables.items)
            {
                var newPrefab = PrefabCreator.CreatePrefab(item);
                if (newPrefab == null)
                {
                    fail++;
                }
                else
                {
                    success++;
                }
            }

            if (fail > 0)
            {
                Debug.LogError($"Failed to initialize {fail} prefabs!");
            }
            if (success > 0)
            {
                Debug.LogWarning($"Successfully initialized {success} prefabs in Jam.Update");
            }
        }
Example #2
0
        // ---------------------------------------------------------------------------------------------------------------------------
        // Draw ProceduralTree inspector GUI
        // ---------------------------------------------------------------------------------------------------------------------------

        public override void OnInspectorGUI()
        {
            var building = (Building)target;

            /*var pt = PrefabUtility.GetPrefabType(building);
             * if (pt != PrefabType.None && pt != PrefabType.DisconnectedPrefabInstance) // Prefabs are not dynamic
             * {
             *  GUI.enabled = false;
             *  DrawDefaultInspector();
             *  return;
             * }*/

            DrawDefaultInspector();

            GUILayout.BeginHorizontal();
            {
                if (GUILayout.Button("Rand Building")) // Randomize all building parameters
                {
                    Undo.RecordObject(building, "Random building " + building.name);
                    building.RandomizeSettings();
                    building.Generate();
                }

                if (GUI.changed)
                {
                    building.Generate();
                }

                if (GUILayout.Button("Create Prefab"))
                {
                    PrefabCreator.CreatePrefab(building.gameObject);
                }
            }
            GUILayout.EndHorizontal();
        }
Example #3
0
        // ---------------------------------------------------------------------------------------------------------------------------
        // Draw ProceduralTree inspector GUI
        // ---------------------------------------------------------------------------------------------------------------------------

        public override void OnInspectorGUI()
        {
            var tree = (ProcTree)target;

            /*var pt = PrefabUtility.GetPrefabType(tree);
             * if (pt != PrefabType.None && pt != PrefabType.DisconnectedPrefabInstance) // Prefabs are not dynamic
             * {
             *  GUI.enabled = false;
             *  DrawDefaultInspector();
             *  return;
             * }*/

            DrawDefaultInspector();

            GUILayout.BeginHorizontal();
            {
                if (GUILayout.Button("Rand Tree")) // Randomize all tree parameters
                {
                    Undo.RecordObject(tree, "Random Tree " + tree.name);
                    tree.RandomizeSettings();
                    tree.Generate(Random.Range(0f, 1f) <= 0.5 ? true : false);
                }

                if (GUILayout.Button("Rand Seed")) // Generates a tree of the same type
                {
                    Undo.RecordObject(tree, "Random Tree " + tree.name);
                    //tree.RandomizeSettings();
                    tree.seed = Random.Range(0, 64000);
                    tree.Generate(tree.coneTree);
                }

                if (GUI.changed)
                {
                    tree.Generate(tree.coneTree);
                }

                if (GUILayout.Button("Create Prefab"))
                {
                    PrefabCreator.CreatePrefab(tree.gameObject);
                }
            }
            GUILayout.EndHorizontal();
        }
Example #4
0
        public override void OnInspectorGUI()
        {
            var undoStack = grid.undoStack;
            var redoStack = grid.redoStack;
            var current   = grid.current;

            GUILayout.BeginHorizontal();
            GUILayout.Label("Grid Width:");
            var oldWidth = grid.width;

            grid.width = EditorGUILayout.IntSlider(grid.width, 0, 100);
            GUILayout.EndHorizontal();

            GUILayout.BeginHorizontal();
            GUILayout.Label("Grid height:");
            var oldHeight = grid.height;

            grid.height = EditorGUILayout.IntSlider(grid.height, 0, 100);
            GUILayout.EndHorizontal();

            if (grid.width != oldWidth || grid.height != oldHeight)
            {
                grid.GenerateMaps(false);
            }

            for (int i = 0; i < grid.streets.Count; i++)
            {
                if (grid.streets [grid.streets.Count - 1].Count > 1)
                {
                    GUILayout.BeginHorizontal();
                    GUILayout.Label("Street" + (i + 1) + ": ");

                    if (GUILayout.Button("Select"))
                    {
                        for (int j = 0; j < grid.selectedStreet.Count; j++)
                        {
                            grid.selectedStreet [j] = false;
                        }
                        grid.selectedStreet [i] = true;
                    }
                    if (GUILayout.Button("Deselect"))
                    {
                        grid.selectedStreet [i] = false;
                    }
                    if (GUILayout.Button("Delete"))
                    {
                        grid.streets.RemoveAt(i);
                        grid.selectedStreet.RemoveAt(i);
                        if (grid.selectedStreet.Count > i)
                        {
                            grid.selectedStreet [i] = false;
                        }
                    }
                    GUILayout.EndHorizontal();
                }
            }

            //select number of building types and add building prefabs
            showBuildingTypes = EditorGUILayout.Foldout(showBuildingTypes, "Show Building Types");

            if (showBuildingTypes)
            {
                GUILayout.BeginVertical("Box", GUILayout.ExpandWidth(true));

                EditorGUILayout.Space();
                AddTypesOfPrefabs("House Types", grid.housePrefab);

                EditorGUILayout.Space();
                AddTypesOfPrefabs("Skyscraper Types", grid.skyscraperPrefab);

                GUILayout.EndVertical();
            }

            EditorGUILayout.Space();
            //select number of building types and add building prefabs
            showTreeTypes = EditorGUILayout.Foldout(showTreeTypes, "Show Building Types");

            if (showTreeTypes)
            {
                GUILayout.BeginVertical("Box", GUILayout.ExpandWidth(true));

                AddTypesOfPrefabs("ConeTree Types", grid.conetreePrefab);

                EditorGUILayout.Space();
                AddTypesOfPrefabs("WoodTree Types", grid.woodtreePrefab);

                GUILayout.EndVertical();
            }



            DrawBasicEditTools();

            if (GUILayout.Button("Generate City", GUILayout.Height(30)))
            {
                grid.showGrid = false;
                if (grid.terrainData == null || grid.city == null)
                {
                    grid.city = GameObject.Find("MyProceduralCity");
                    if (grid.city)
                    {
                        grid.terrainData = grid.city.GetComponent <TerrainData> ();
                    }
                    else
                    {
                        // create new city GO
                        grid.terrainData             = new TerrainData();
                        grid.city                    = Terrain.CreateTerrainGameObject(grid.terrainData);
                        grid.city.name               = "MyProceduralCity";
                        grid.city.transform.position = Vector3.zero;
                        grid.city.AddComponent <CityPopulator> ();
                    }
                }
                grid.city.GetComponent <CityPopulator> ().Populate(grid);
            }

            if (GUILayout.Button("Reset Map", GUILayout.Height(30)))
            {
                grid.showGrid = true;
                redoStack     = new LinkedList <GridCreator.CellType[, ]> ();
                undoStack     = new LinkedList <GridCreator.CellType[, ]> ();
                grid.GenerateMaps(true);
                current = (GridCreator.CellType[, ])grid.worldMap.Clone();
                undoStack.AddLast(new LinkedListNode <GridCreator.CellType[, ]> (grid.worldMap));
            }

            if (GUILayout.Button("Save!", GUILayout.Height(30)))
            {
                var city = grid.city;

                if (city == null)
                {
                    Debug.Log("Please generate map first");
                }
                else
                {
                    city.GetComponent <CityPopulator> ().ClearFromScripts();
                    PrefabCreator.CreatePrefab(city.gameObject);
                }
            }
            GUI.enabled = true;


            SceneView.RepaintAll();

            if (GUI.changed)
            {
                grid.firstTimeBuild = true;
            }


            //base.OnInspectorGUI ();
        }