Esempio n. 1
0
        public override void Run_Node()
        {
            if (ActorManager.Is_Actor_On_Scene(actor_name))
            {
                if (!slide_out && !fade_out)
                {
                    ActorManager.Remove_Actor(actor_name);
                    Finish_Node();
                }
                else
                {
                    Actor actor = ActorManager.Get_Actor(actor_name);

                    if (fade_out)
                    {
                        // Fade out
                        actor.Fade_Out(fade_out_time);
                    }
                    else
                    {
                        // Slide out
                        actor.Slide_Out(1f);
                    }

                    StartCoroutine(Wait(actor));
                }
            }
            else
            {
                Debug.Log(actor_name + " is not on the scene. Remember to correctly name your actor and use 'EnterActorNode'");

                Finish_Node();
            }
        }
Esempio n. 2
0
        IEnumerator Fade_Out_Coroutine(float over_time)
        {
            if (!ActorManager.exiting_actors.Contains(this))
            {
                ActorManager.exiting_actors.Add(this);
            }

            Image img       = this.GetComponent <Image>();
            Color tmp_color = img.color;

            tmp_color.a = 1;
            float value = 0;

            while (value < over_time)
            {
                value      += Time.deltaTime;
                tmp_color.a = Mathf.Lerp(1, 0, value / over_time);
                img.color   = tmp_color;
                yield return(0);
            }

            // Remove this actor after we're done
            Debug.Log("Removing actor " + actor_name);
            ActorManager.Remove_Actor(this.actor_name);

            yield break;
        }
Esempio n. 3
0
        // Instantly places the actor at the designated position
        public void Place_At_Position(Actor_Positions destination)
        {
            position = destination;

            ActorManager.Add_Actor_To(this, destination);
            this.rect = this.GetComponent <RectTransform>();
            this.rect.localPosition = this.desired_position;
        }
Esempio n. 4
0
        // Instantiates an actor from the Resources/Actors folder with the name actor_name.
        // It then sets the object as a child of the Actors object in the canvas
        public static Actor Instantiate_Actor(string actor_name, Actor_Positions destination, Transform custom_position = null)
        {
            // Check to see if the actor is already on the scene
            Actor a = ActorManager.Get_Actor(actor_name);

            if (a != null)
            {
                Debug.Log("Actor " + actor_name + " already on scene");
                return(a);
            }
            if (UIManager.ui_manager.actor_parent == null)
            {
                Debug.LogError("Unable to instantiate Actor " + actor_name + " because UIManager's actor_parent field is empty. Please set actor_parent field to an object.");
            }


            // Check if there is a disabled actor available to use
            if (use_inactive_actors)
            {
                Actor[] disabled_actors = UIManager.ui_manager.actor_parent.gameObject.GetComponentsInChildren <Actor>(true);
                foreach (Actor acto in disabled_actors)
                {
                    if (acto.actor_name == actor_name)
                    {
                        // Found a correct actor, set it up correctly
                        a = acto;
                        a.Reset();
                        a.gameObject.SetActive(true);
                    }
                }
            }


            if (a == null)
            {
                // Proceed with creating a gameobject
                GameObject actor = Instantiate(Resources.Load("Actors/" + actor_name, typeof(GameObject)), UIManager.ui_manager.actor_parent) as GameObject;
                a = actor.GetComponent <Actor>();
            }

            actors_on_scene.Add(a);  // Add to list of actors

            // Place actor at custom position
            if (destination == Actor_Positions.CUSTOM && custom_position != null)
            {
                //a.rect.localPosition = custom_position.position;
                a.desired_position = new Vector3(custom_position.GetComponent <RectTransform>().localPosition.x,
                                                 custom_position.GetComponent <RectTransform>().localPosition.y *a.transform.localScale.y);
                a.custom_position = custom_position;
            }
            // Use standard automatic position calculations
            else
            {
                ActorManager.Add_Actor_To(a, destination);
            }

            return(a);
        }
Esempio n. 5
0
        void Awake()
        {
            actor_manager = this;

            actors_on_scene = new List <Actor>();
            exiting_actors  = new List <Actor>();
            left_actors     = new List <Actor>();
            right_actors    = new List <Actor>();
        }
Esempio n. 6
0
        // Calls a coroutine to slide in this actor over a number of seconds specified by over_time
        public void Slide_In(Actor_Positions destination, float over_time)
        {
            rect = GetComponent <RectTransform>();

            ActorManager.Add_Actor_To(this, destination);

            // Set our starting point so we slide into our desired position
            ActorManager.actor_manager.Slide_Start_Position(this, position);
        }
        public override void Run_Node()
        {
            Actor actor = ActorManager.Get_Actor(actor_name);

            // Can only change the animation of an actor if they're already on the scene
            if (actor != null)
            {
                actor.Play_Animation(animation_name);
            }

            Finish_Node();
        }
Esempio n. 8
0
        public override void Run_Node()
        {
            if (ActorManager.Is_Actor_On_Scene(actor_name))
            {
                Actor actor = ActorManager.Get_Actor(actor_name);
                SaveManager.SetSaveFeature(this, actor.gameObject);

                Debug.Log("Actor on scene " + actor.actor_name);

                if (fade_in_new_image)
                {
                    Sprite old_sprite = actor.cur_image.overrideSprite;

                    if (lighten_actor)
                    {
                        actor.Lighten();
                    }
                    if (bring_actor_to_front)
                    {
                        ActorManager.Bring_Actor_To_Front(actor);
                    }

                    // Fade out old image
                    actor.fading_child_image.gameObject.SetActive(true);
                    actor.fading_child_image.overrideSprite = old_sprite;

                    // Set colour of old image to match current image
                    actor.fading_child_image.color = actor.cur_image.color;
                    actor.fading_child_image.GetComponent <RectTransform>().sizeDelta = actor.rect.sizeDelta;
                    StartCoroutine(Fade_Out_Coroutine(fade_out_time, actor.fading_child_image));

                    // Fade in new image
                    actor.cur_image.overrideSprite = new_image;
                    StartCoroutine(Fade_In_Coroutine(fade_out_time, actor.cur_image));

                    // Wait before we allow it to finish
                    StartCoroutine(Wait(actor, fade_out_time * 1.1f));
                }
                else
                {
                    Debug.Log("Actor on scene " + actor.actor_name);

                    actor.cur_image.overrideSprite = new_image;
                    Finish_Node();
                }
            }
            else
            {
                Finish_Node();

                Debug.Log(actor_name + " is not on the scene. Remember to correctly name your actor and use 'EnterActorNode'");
            }
        }
Esempio n. 9
0
        public override void Run_Node()
        {
            Actor   actor = ActorManager.Get_Actor(actor_name);
            Vector3 scale = actor.transform.localScale;

            scale.x = -scale.x;
            actor.transform.localScale = scale;

            SaveManager.SetSaveFeature(this, actor.gameObject);

            Finish_Node();
        }
Esempio n. 10
0
        public override void Run_Node()
        {
            Actor actor_script;

            // Check if the actor is already present
            if (ActorManager.Is_Actor_On_Scene(actor_name))
            {
                // Actor is already on the scene
                Debug.Log("Actor " + actor_name + " already on scene");
                actor_script = ActorManager.Get_Actor(actor_name).GetComponent <Actor>();
                Finish_Node();
                return;
            }
            else
            {
                // Actor is not in the scene. Instantiate it
                if (VNSceneManager.verbose_debug_logs)
                {
                    Debug.Log("Creating new actor " + actor_name);
                }

                if (destination == Actor_Positions.CUSTOM && custom_position != null)
                {
                    actor_script = ActorManager.Instantiate_Actor(actor_name, destination, custom_position);
                }
                else
                {
                    actor_script = ActorManager.Instantiate_Actor(actor_name, destination);
                }
            }
            SaveManager.SetSaveFeature(this, actor_script.gameObject);

            switch (entrance_type)
            {
            case Entrance_Type.Slide_In:
                actor_script.Slide_In(destination, 2.0f);
                Finish_Node();
                break;

            case Entrance_Type.Fade_In:
                actor_script.Place_At_Position(destination);
                actor_script.Fade_In(fade_in_time);
                StartCoroutine(Wait(fade_in_time + 0.2f));
                break;

            case Entrance_Type.None:
                Finish_Node();
                break;
            }
        }
Esempio n. 11
0
        public override void Run_Node()
        {
            VNSceneManager.scene_manager.Show_UI(true);  // Ensure dialogue panel is visible

            running = true;

            UIManager.ui_manager.text_panel.text = "";

            // Get localized text and sub in Stats values
            GetLocalizedText(false);

            StartCoroutine(Animate_Text(text));

            // If the actor field is filled in and the actor is present on the scene
            Actor speaker = ActorManager.Get_Actor(actor);

            if (actor != "" &&
                speaker != null)
            {
                // Slightly darken all other actors
                if (darken_all_other_characters)
                {
                    ActorManager.Darken_All_Actors_But(speaker);
                }

                // Lighten this actor to show this one is talking
                speaker.Lighten();

                // Bring this actor to the front
                if (bring_speaker_to_front)
                {
                    ActorManager.Bring_Actor_To_Front(speaker);
                }
            }

            if (voice_clip != null && voice_clip.clip != null)
            {
                // Play audio if there is any
                voice_clip.volume = AudioManager.audio_manager.voice_volume;
                voice_clip.Play();
            }
            else
            {
                done_voice_clip  = true;
                no_voice_playing = true;
            }
        }
Esempio n. 12
0
        // Slides the actor out, and remove the actor after it has gone
        public void Slide_Out(float over_time)
        {
            rect = GetComponent <RectTransform>();

            if (!remove_when_out_of_sight)
            {
                if (this.position == Actor_Positions.LEFT)
                {
                    ActorManager.left_actors.Remove(this);
                    desired_position = ActorManager.actor_manager.offscreen_left.localPosition;
                    if (!ActorManager.exiting_actors.Contains(this))
                    {
                        ActorManager.exiting_actors.Add(this);
                    }
                }
                else if (this.position == Actor_Positions.RIGHT)
                {
                    ActorManager.right_actors.Remove(this);
                    desired_position = ActorManager.actor_manager.offscreen_right.localPosition;
                    if (!ActorManager.exiting_actors.Contains(this))
                    {
                        ActorManager.exiting_actors.Add(this);
                    }
                }
                else if (this.position == Actor_Positions.CENTER)
                {
                    ActorManager.center_actors.Remove(this);
                    desired_position = ActorManager.actor_manager.offscreen_right.localPosition;
                    if (!ActorManager.exiting_actors.Contains(this))
                    {
                        ActorManager.exiting_actors.Add(this);
                    }
                }
                else if (this.position == Actor_Positions.CUSTOM)
                {
                    desired_position = ActorManager.Closest_Side_To_Exit(this);
                    if (!ActorManager.exiting_actors.Contains(this))
                    {
                        ActorManager.exiting_actors.Add(this);
                    }
                }
                desired_position.y = 0;// ActorManager.Get_Actor_Y_Position(this);

                remove_when_out_of_sight = true;
            }
        }
Esempio n. 13
0
        IEnumerator Wait_Until_Actor_Is_Stopped()
        {
            yield return(0);

            Actor actor = ActorManager.Get_Actor(actor_name);

            if (actor == null)
            {
                Debug.Log("Could not find actor");
                Finish_Node();
            }

            while (actor.is_moving)
            {
                yield return(0);
            }

            Finish_Node();
        }
Esempio n. 14
0
        public override void Run_Node()
        {
            // Check if the Actor is on the scene
            if (!ActorManager.Is_Actor_On_Scene(actor_name))
            {
                Debug.LogError(actor_name + " actor is not on the scene. Please use an Enter Actor Node for " + actor_name);
                Finish_Node();
                return;
            }

            ActorManager.Move_Actor_Outwards(ActorManager.Get_Actor(actor_name));

            if (wait_until_actor_has_stopped)
            {
                StartCoroutine(Wait_Until_Actor_Is_Stopped());
            }
            else
            {
                Finish_Node();
            }
        }
Esempio n. 15
0
        public void Update()
        {
            is_moving = false;
            // Move towards desired position if we are not at our desired position
            if (this.rect.localPosition != desired_position)
            {
                this.rect.localPosition = Vector3.Lerp(this.rect.localPosition, desired_position, 3f * Time.deltaTime);
                //this.transform.position = Vector3.Lerp(this.transform.position, desired_position, 3f * Time.deltaTime);

                if (Vector2.Distance(this.rect.localPosition, desired_position) > 1f)
                {
                    is_moving = true;
                }
            }

            // If sliding out, check if we're visible. If we're not visible, remove the actor
            if (remove_when_out_of_sight && Mathf.Abs(this.rect.localPosition.x - desired_position.x) <= 30)
            {
                ActorManager.Remove_Actor(this.actor_name);
            }
        }
Esempio n. 16
0
        public override void Run_Node()
        {
            if (!slide_out && !fade_out)
            {
                for (int x = ActorManager.actors_on_scene.Count - 1; x >= 0; x--)
                {
                    Debug.Log("Exit all immediately: " + ActorManager.actors_on_scene[x].actor_name);
                    ActorManager.Remove_Actor(ActorManager.actors_on_scene[x]);
                }
            }
            else
            {
                for (int x = ActorManager.actors_on_scene.Count - 1; x >= 0; x--)
                {
                    Debug.Log("Exit all: " + ActorManager.actors_on_scene[x].actor_name);
                    Actor actor = ActorManager.actors_on_scene[x];

                    if (fade_out)
                    {
                        // Fade out
                        actor.Fade_Out(1f);
                    }
                    else
                    {
                        // Slide out
                        actor.Slide_Out(1f);
                    }
                }
            }

            if (wait_for_actors_to_exit)
            {
                StartCoroutine(Wait());
            }
            else
            {
                Finish_Node();
            }
        }
Esempio n. 17
0
        public override void Run_Node()
        {
            if (string.IsNullOrEmpty(actor))
            {
                Debug.LogError("Actor " + actor + " name is null or empty", this.gameObject);
            }
            // Check if the actor is already present
            else if (ActorManager.Is_Actor_On_Scene(actor))
            {
                // Actor is already on the scene
                Actor actor_script = ActorManager.Get_Actor(actor);
                actor_script.position = destination;

                ActorManager.Remove_Actor_From_Positions_Lists(actor_script);
                ActorManager.Add_Actor_To(actor_script, destination);
            }
            else
            {
                Debug.LogError("Actor " + actor + " is not on the scene. Use EnterActorNode to place them on the scene", this.gameObject);
            }

            Finish_Node();
        }
Esempio n. 18
0
        // Loads a scene and sets the settings of this save file to the game
        // Must be called with a monobehaviour with StartCoroutine(Load())
        // Modify this method to add in your own custom loading code
        public IEnumerator Load()
        {
            Debug.Log("Loading..." + current_conv_node);

            StatsManager.Clear_All_Stats();

            string active_scene = UnityEngine.SceneManagement.SceneManager.GetActiveScene().name;

            // UI is unresponsive if there are 2 event systems
            if (UnityEngine.EventSystems.EventSystem.current.gameObject)
            {
                GameObject.Destroy(UnityEngine.EventSystems.EventSystem.current.gameObject);
            }

            // Load items
            StatsManager.items = saved_items;

            VNSceneManager.scene_manager = null;

            // Load the scene that was saved
            UnityEngine.SceneManagement.SceneManager.LoadScene(current_scene, UnityEngine.SceneManagement.LoadSceneMode.Additive);

            // Must wait 1 frame before initializing the new scene
            yield return(null);

            // Unpause in case the game was paused before loading
            Pause.pause.ResumeGame();

            // Stop the default things from happening
            VNSceneManager.scene_manager.starting_conversation = null;
            ConversationManager cur_conv = GameObject.Find(current_conv).GetComponent <ConversationManager>();

            // Set log
            VNSceneManager.scene_manager.Add_To_Log("", log_text);

            // Set play time
            VNSceneManager.scene_manager.play_time += time_played;

            ActorManager.actors_on_scene = new List <Actor>();
            ActorManager.exiting_actors  = new List <Actor>();
            ActorManager.left_actors     = new List <Actor>();
            ActorManager.right_actors    = new List <Actor>();
            ActorManager.center_actors   = new List <Actor>();

            /*
             * // Load the actors on the scene
             * foreach (string a in left_actors)
             * {
             *  ActorManager.Instantiate_Actor(a, Actor_Positions.LEFT);
             * }
             * foreach (string a in right_actors)
             * {
             *  ActorManager.Instantiate_Actor(a, Actor_Positions.RIGHT);
             * }
             * foreach (string a in center_actors)
             * {
             *  ActorManager.Instantiate_Actor(a, Actor_Positions.CENTER);
             * }
             */
            // Execute any Nodes that need to executed to create the scene (StaticImageNodes, SetBackground, SetMusicNode, ChangeActorImage, etc)
            foreach (string node_path in Nodes_to_Execute_on_Load)
            {
                // Figure out what type of Node we're dealing with
                string[] node_parts = node_path.Split(new string[] { feature_save_separation_character }, StringSplitOptions.None);

                // We can figure out which node is executed by the Node component embedded in the string
                if (node_parts.Length == 2)
                {
                    GameObject go = GameObject.Find(node_parts[1]);
                    if (go == null)
                    {
                        Debug.LogError("Load: Could not find node to execute; " + node_path);
                        continue;
                    }

                    Node n = (Node)go.GetComponent(node_parts[0]);
                    if (n != null)
                    {
                        n.executed_from_load = true;
                        n.Run_Node();
                    }
                    else
                    {
                        Debug.LogError("Load: Gameobject did not have attached node to execute; " + node_path);
                    }
                }
                // Can't figure out which node type this is, simply execute the first node on the found gameobject
                else if (node_parts.Length == 1)
                {
                    GameObject go = GameObject.Find(node_path);
                    if (go == null)
                    {
                        Debug.LogError("Load: Could not find node to execute; " + node_path);
                        continue;
                    }

                    Node n = go.GetComponent <Node>();
                    if (n != null)
                    {
                        n.executed_from_load = true;
                        n.Run_Node();
                    }
                    else
                    {
                        Debug.LogError("Load: Gameobject did not have attached node to execute; " + node_path);
                    }
                }
            }


            // Delete conversations not present in our saved conversations
            ConversationManager[] convs = (ConversationManager[])UnityEngine.Object.FindObjectsOfType(typeof(ConversationManager)) as ConversationManager[];
            foreach (ConversationManager c in convs)
            {
                // Find all conversations in our freshly loaded scene, check if we should keep or delete these conversations
                string name = (c.name);

                // Record the full name of the object (including its parents)
                Transform parent = c.transform.parent;
                while (parent != null)
                {
                    name   = name.Insert(0, parent.name + "/");
                    parent = parent.parent;
                }


                bool delete_conv = true;
                // Check against saved conversations
                foreach (string s in remaining_conversations)
                {
                    if (name == s)
                    {
                        delete_conv = false;
                        break;
                    }
                }

                if (delete_conv)
                {
                    GameObject.Destroy(c.gameObject);
                }
            }

            // Load stats
            StatsManager.boolean_stats  = saved_boolean_stats;
            StatsManager.numbered_stats = saved_numbered_stats;
            StatsManager.string_stats   = saved_string_stats;
            StatsManager.items          = saved_items;
            StatsManager.Print_All_Stats();

            // Load log text
            VNSceneManager.text_logs = log_categories;
            VNSceneManager.scene_manager.Conversation_log = log_text;



            //<< MODIFY THIS SECTION TO LOAD THINGS SPECIFIC TO YOUR GAME >>//



            //<< MODIFY THE ABOVE SECTION TO LOAD THINGS SPECIFIC TO YOUR GAME >>//


            // Start the conversation
            cur_conv.Start_Conversation_Partway_Through(current_conv_node);

            yield return(0);

            // Flip any actors that are meant to be flipped
            foreach (string a in flipped_actors)
            {
                Actor actor = ActorManager.Get_Actor(a);
                if (a != null)
                {
                    actor.transform.localScale = new Vector3(-actor.transform.localScale.x, actor.transform.localScale.y, actor.transform.localScale.z);
                }
            }

            UnityEngine.SceneManagement.SceneManager.SetActiveScene(UnityEngine.SceneManagement.SceneManager.GetSceneByName(current_scene));
            UnityEngine.SceneManagement.SceneManager.UnloadSceneAsync(active_scene);
            AudioListener.pause = false;

            yield return(0);
        }
Esempio n. 19
0
        public override void Run_Node()
        {
            ActorManager.Darken_All_Actors();

            Finish_Node();
        }
Esempio n. 20
0
        public string actor_name;   // Actor to darken

        public override void Run_Node()
        {
            ActorManager.Get_Actor(actor_name).Darken();

            Finish_Node();
        }
Esempio n. 21
0
        public string actor_name;   // Actor to bring backwards

        public override void Run_Node()
        {
            ActorManager.Bring_Actor_To_Back(ActorManager.Get_Actor(actor_name));

            Finish_Node();
        }