/// <summary>
    /// e.g. for showItem sequence, also for use in dialogue
    /// </summary>
    /// <param name="itemObject"></param>
    public void HandleItemReceive(Script_ItemObject itemObject, Script_Player player)
    {
        Script_Item item = itemObject.Item;

        Debug.Log($"{name} Adding item: {item}");
        bool pickUpSuccess = game.AddItem(item);

        if (!pickUpSuccess)
        {
            // handle flow to drop an item in inventory
        }

        Script_ItemsEventsManager.ItemPickUp(item.id);

        // Display item above Player's head.
        player.SetIsPickingUp(item);
        player.ItemPickUpEffect(true, item);

        /// Item theatrics here
        if (itemObject.pickUpTheatricsPlayer != null)
        {
            itemObject.pickUpTheatricsPlayer.Play();
            return;
        }

        Script_Game.Game.dialogueManager.StartDialogueNode(
            itemObject.GetComponent <Script_DialogueNode>()
            );

        if (!itemObject.showTyping)
        {
            Debug.Log("Skipping typing item initial description on receiving item");
            Script_Game.Game.dialogueManager.SkipTypingSentence();
        }
    }
Пример #2
0
    // ----------------------------------------------------------------------
    // King's Intro Unity Events, Next Node Actions

    public void KingsIntroTimeline()
    {
        // Pause King's walking Timeline.

        // Check for Psychic Duck
        bool isPsychicDuckActive = Script_ActiveStickerManager.Control.IsActiveSticker(Const_Items.PsychicDuckId);

        if (isPsychicDuckActive && !isKingIntroCutSceneDone && !didStartKingsIntro)
        {
            didStartKingsIntro = true;

            game.ChangeStateCutScene();

            KingEclaire.State = Script_StaticNPC.States.Dialogue;

            Script_BackgroundMusicManager.Control.FadeOutMed(null, Const_AudioMixerParams.ExposedBGVolume);

            Script_TransitionManager.Control.TimelineFadeIn(timelineFaderFadeInTime, () => {
                Script_Player p = game.GetPlayer();

                p.Teleport(KingIntroPlayerSpawn.Position);
                p.FaceDirection(Directions.Up);

                MoveKingEclaireToMidpoint();

                // King's Explanation of Sealing
                timelineController.PlayableDirectorPlayFromTimelines(0, 0);

                // Play Elder's Tragedy Song
                game.PauseBgMusic();
                eldersTragedyBgThemePlayer.Play();
                Script_BackgroundMusicManager.Control.SetVolume(1f, Const_AudioMixerParams.ExposedBGVolume);
            });
        }
    }
Пример #3
0
 private void Awake()
 {
     if (instance == null)
     {
         instance = this;
     }
 }
    void Awake()
    {
        npc    = GetComponent <Script_MovingNPC>();
        player = game.GetPlayer();

        origin = npc.transform.position;
    }
    public void FacePlayer()
    {
        Script_Player player = Script_Game.Game.GetPlayer();
        Directions    dir    = Script_Utils.GetDirectionToTarget(
            transform.position, player.transform.position
            );

        GetComponent <Script_MovingNPC>().FaceDirection(dir);
    }
Пример #6
0
    private void Awake()
    {
        Script_Player player = Script_Game.Game.GetPlayer();
        Directions    dir    = Script_Utils.GetDirectionToTarget(
            player.transform.position, target.position
            );

        player.FaceDirection(dir);
    }
Пример #7
0
 public void Setup(
     Script_PlayerReflection _playerReflection,
     Script_Player _player,
     Vector3 _axis
     )
 {
     player           = _player;
     axis             = _axis;
     playerReflection = _playerReflection;
 }
    /// <summary>
    /// Frame rate independent damping
    /// https://www.rorydriscoll.com/2016/03/07/frame-rate-independent-damping-using-lerp/
    /// </summary>
    public void DampTowardsPlayer()
    {
        Script_Player player = game.GetPlayer();

        Vector3 playerPosition = player.FocalPoint.position;
        Vector3 myPosition     = transform.position;

        Vector3 newPosition = myPosition.FrameRateAwareDamp(playerPosition, weight, Time.deltaTime);

        transform.position = newPosition;
    }
    // Making this a coroutine forces it to happen after Player movement in execution loop.
    public void MoveTowardsPlayer()
    {
        Script_Player player = game.GetPlayer();

        Vector3 playerPosition = player.FocalPoint.position;
        Vector3 myPosition     = transform.position;

        Vector3 newPosition = (playerPosition * weight) + (myPosition * (1 - weight));

        transform.position = newPosition;
    }
Пример #10
0
 private void Awake()
 {
     if (Instance == null)
     {
         Instance = this;
     }
     else if (Instance != this)
     {
         Destroy(gameObject);
     }
 }
    public void SetupPlayerReflection(Transform reflection)
    {
        player = game.GetPlayer();
        Script_PlayerReflection pr = reflection.GetComponent <Script_PlayerReflection>();

        pr.Setup(
            player,
            pr.axisObject == null ? pr.axis : pr.axisObject.position // TODO: remove once we don't have to use CreateReflection
            );
        // pr.transform.SetParent(game.playerContainer, false);
        player.SetPlayerReflection(pr);
    }
Пример #12
0
    public override void Hit(Collider col)
    {
        print(col.tag);
        if (col.tag == Const_Tags.Player)
        {
            print($"{name} Player hit: {col}");
            Debug.Log($"Time Left (s): {Script_ClockManager.Control.TimeLeft}");

            if (Const_Dev.IsDevMode && Debug.isDebugBuild)
            {
                return;
            }

            // Ignore this behavior if the hit caused Time to run out.
            if (
                Script_ClockManager.Control.ClockState == Script_Clock.States.Done ||
                Script_ClockManager.Control.TimeLeft == 0
                )
            {
                return;
            }

            Script_Game.Game.ChangeStateCutScene();

            StartCoroutine(Script_Game.Game.TransitionFadeIn(
                               Script_TransitionManager.RestartPlayerFadeInTime, () =>
            {
                Script_Player p = col.transform.parent.GetComponent <Script_Player>();

                Vector3 prevPlayerPos = p.transform.position;

                p.Teleport(restartDestination.position);
                p.FaceDirection(facingDirection);

                Script_Game.Game.SnapActiveCam(prevPlayerPos);
                FadeOut();
            }
                               ));
        }

        void FadeOut()
        {
            StartCoroutine(Script_Game.Game.TransitionFadeOut(
                               Script_TransitionManager.RestartPlayerFadeOutTime, () =>
            {
                Script_Game.Game.ChangeStateInteract();

                Script_HurtBoxEventsManager.PlayerRestart(col);
            }
                               ));
        }
    }
Пример #13
0
    /// <summary>
    /// Can only drop from rounded ints because we do rounding on entrance
    /// </summary>
    public void PlayerEntranceFromEileenMind()
    {
        Script_Player player = Script_Game.Game.GetPlayer();

        /// To prevent input until after animation is done
        player.SetIsStandby();

        playerObjsToBind.Add(player.gameObject);
        playerObjsToBind.Add(dropSFX.gameObject);

        playerPlayableDirector.BindTimelineTracks(playerDropTimeline, playerObjsToBind);
        playerPlayableDirector.Play(playerDropTimeline);
    }
Пример #14
0
    public void Setup(
        Script_Player _player,
        Vector3 _axis
        )
    {
        reflectionMovement = GetComponent <Script_PlayerReflectionMovement>();
        reflectionMovement.Setup(this, _player, _axis);

        player = _player;
        axis   = axisObject == null ? axis = _axis : axis = axisObject.position;

        transform.position = reflectionMovement.GetReflectionPosition(player.transform.position);
    }
    public override int Hurt(int dmg, Script_HitBox hitBox)
    {
        // give player a callback to do after eating
        Script_Player player = hitBox.transform.GetParentRecursive <Script_Player>();

        if (player != null)
        {
            Debug.Log($"Player trying to attack {this.gameObject.name}");
            // recursively find the Script_Attack
            player.onAttackDone = () => AttackedByPlayerReaction();
        }

        return(0);
    }
Пример #16
0
    public void SwitchPlayer()
    {
        Debug.Log("I switch");

        Script_Player passenger = m_ActualPassenger;
        Script_Player driver    = m_ActualDriver;

        m_ActualPassenger = driver;
        m_ActualDriver    = passenger;
        m_ActualPassenger.BecomeDriver();
        m_ActualDriver.BecomePassenger();

        m_ActualDriver.transform.position    = l_transform_switch_target[0].position;
        m_ActualPassenger.transform.position = l_transform_switch_target[1].position;
    }
    // Start is called before the first frame update
    void Start()
    {
        player = Script_Game.Game.GetPlayer();
        UpdateFollowTarget();
        transform.position = endPosition;

        if (CheckBounds())
        {
            spriteFader.SetVisibility(true);
        }
        else
        {
            spriteFader.SetVisibility(false);
        }
    }
    private void InitializeTextObject(
        Script_InteractableObjectText iObj,
        List <Script_InteractableObject> interactableObjects,
        Script_DialogueManager dialogueManager,
        Script_Player player
        )
    {
        interactableObjects.Add(iObj);
        iObj.SetupDialogueNodeText(dialogueManager, player);
        iObj.Id = interactableObjects.Count - 1;

        Script_SortingOrder so = iObj.GetRendererChild().GetComponent <Script_SortingOrder>();

        iObj.Setup(so.enabled, so.sortingOrderIsAxisZ, so.offset);
    }
    public void OnPuzzleComplete(string arg)
    {
        Script_PuzzlesEventsManager.PuzzleProgress();

        isDone = true;

        game.ChangeStateCutScene();
        game.DisableExits(false, 0);

        float defaultFastFadeTime = Script_AudioEffectsManager.GetFadeTime(FadeSpeeds.Fast);

        StartCoroutine(
            Script_AudioMixerFader.Fade(
                audioMixer,
                Const_AudioMixerParams.ExposedBGVolume,
                beforeShakeFadeOutMusicTime,
                0f,
                () => { game.StopBgMusic(); }
                )
            );

        // Bind Player & Player Ghost to the Retreat Timeline & play.
        Script_Player player = Script_Game.Game.GetPlayer();

        playerObjsToBind.Clear();

        // Player Transform Track
        playerObjsToBind.Add(player.gameObject);
        // Player Signal Receiver Track
        playerObjsToBind.Add(player.gameObject);

        playerPlayableDirector.BindTimelineTracks(playerRetreatTimeline, playerObjsToBind);

        StartCoroutine(WaitForExplosionCutScene());

        // Zoom camera back in.
        IEnumerator WaitForExplosionCutScene()
        {
            Script_VCamManager.VCamMain.SwitchToMainVCam(staticZoomOutVCam);

            yield return(new WaitForSeconds(zoomBackInTime));

            // play manually do to dynamic handling of Player timeline via Script_TimelineController
            GetComponent <Script_TimelineController>().PlayableDirectorPlayFromTimelines(0, 0);

            playerPlayableDirector.Play(playerRetreatTimeline);
        }
    }
Пример #20
0
    public void HideItemPickUpTheatric(Script_ItemPickUpTheatric theatric)
    {
        Debug.Log("***Calling HideItemPickUpTheatric now***");

        ItemPickUpTheatricsCanvasGroup.alpha = 0f;
        ItemPickUpTheatricsCanvasGroup.gameObject.SetActive(false);

        theatric.gameObject.SetActive(false);

        Script_Game.Game.ChangeStateLastState(null);
        /// Return the player back to Picking Up State and then immediately force done
        Script_Player p = Script_Game.Game.GetPlayer();

        p.SetIsPickingUp(p.GetItemShown());
        p.HandleEndItemDescriptionDialogue();
        p.SetItemShown(null);
    }
    public void SetupInteractableObjectsText(
        Transform textObjectParent,
        List <Script_InteractableObject> interactableObjects,
        Script_DialogueManager dm,
        Script_Player player,
        bool isInitialize
        )
    {
        Script_InteractableObjectText[] texts = textObjectParent
                                                .GetComponentsInChildren <Script_InteractableObjectText>(true);

        for (int i = 0; i < texts.Length; i++)
        {
            Script_InteractableObjectText text = texts[i];
            if (isInitialize)
            {
                InitializeTextObject(text, interactableObjects, dm, player);
            }
        }
    }
 public void HandleContinuingDialogueActions(string action, Script_Player player)
 {
     if (action == Const_KeyCodes.Action1)
     {
         if (player.State == Const_States_Player.Dialogue)
         {
             if (Script_DialogueManager.DialogueManager.IsDialogueSkippable())
             {
                 Script_DialogueManager.DialogueManager.SkipTypingSentence();
             }
             else
             {
                 game.dialogueManager.ContinueDialogue();
             }
         }
         else if (player.State == Const_States_Player.PickingUp)
         {
             HandleEndItemDescriptionDialogue(player);
         }
     }
 }
Пример #23
0
    public void Interact(Script_Player player)
    {
        if (b_can_interact)
        {
            switch (object_type.ToString(""))
            {
            case "readable":
                Read();
                break;

            case "holdable":
                Hold(player);
                break;

            case "talkable":
                Talk();
                break;

            case "teleport":
                Teleport();
                break;

            case "card":
                AddCard();
                break;

            case "launchCinematic":
                Script_Cinematic_Controller.Instance.PlayCinematic(cinematic_to_play);
                break;

            case "button":
                ActiveButton();
                break;

            case "special":
                GetComponent <Script_IObject>().Use(null);
                break;
            }
        }
    }
Пример #24
0
    void Start()
    {
        m_Car = GetComponent <CarController>();
        int i = Random.Range(0, 2);

        if (i == 0)
        {
            m_ActualDriver    = l_player[0];
            m_ActualPassenger = l_player[1];
        }
        else
        {
            m_ActualDriver    = l_player[1];
            m_ActualPassenger = l_player[0];
        }

        m_ActualDriver.BecomeDriver();
        m_ActualPassenger.BecomePassenger();

        m_ActualDriver.transform.position    = l_transform_switch_target[0].position;
        m_ActualPassenger.transform.position = l_transform_switch_target[1].position;
    }
    public void SetupInteractableFullArt
    (
        Transform fullArtParent,
        List <Script_InteractableObject> interactableObjects,
        Script_DialogueManager dialogueManager,
        Script_Player player,
        bool isInitialize
    )
    {
        Script_InteractableFullArt[] fullArts = fullArtParent
                                                .GetComponentsInChildren <Script_InteractableFullArt>(true);

        for (int i = 0; i < fullArts.Length; i++)
        {
            Script_InteractableFullArt fullArt = fullArts[i];
            if (fullArt == null)
            {
                continue;
            }
            interactableObjects.Add(fullArt);

            print("fullArt is: " + fullArt);

            if (isInitialize)
            {
                fullArt.SetupDialogueNodeText(dialogueManager, player);
                fullArt.Id = interactableObjects.Count - 1;

                Script_SortingOrder so = fullArt.GetRendererChild().GetComponent <Script_SortingOrder>();
                fullArt.Setup(so.enabled, so.sortingOrderIsAxisZ, so.offset);
            }
        }

        if (Debug.isDebugBuild && Const_Dev.IsDevMode)
        {
            Debug.Log("interactable objects count: " + interactableObjects.Count);
        }
    }
Пример #26
0
    public override void OnInspectorGUI()
    {
        DrawDefaultInspector();

        Script_Player player = (Script_Player)target;

        if (GUILayout.Button("isInvisible = true"))
        {
            player.SetInvisible(true);
        }

        if (GUILayout.Button("isInvisible = false"))
        {
            player.SetInvisible(false);
        }

        if (GUILayout.Button("Force Push Down"))
        {
            player.ForcePush(Directions.Down);
        }

        if (GUILayout.Button("Teleport Up 1"))
        {
            Vector3 newPos = new Vector3(
                player.transform.position.x,
                player.transform.position.y + 1,
                player.transform.position.z
                );

            player.Teleport(newPos);
        }

        if (GUILayout.Button("Buff Effect"))
        {
            player.SetBuffEffectActive(true);
        }
    }
    /// <summary>
    /// used when needing to specify particular textObj array instead of a parent
    /// </summary>
    public void SetupInteractableObjectsTextManually(
        Script_InteractableObjectText[] textObjs,
        List <Script_InteractableObject> interactableObjects,
        Script_DialogueManager dm,
        Script_Player player,
        bool isInitialize
        )
    {
        for (int i = 0; i < textObjs.Length; i++)
        {
            Script_InteractableObjectText iObj = textObjs[i];
            interactableObjects.Add(iObj);

            if (isInitialize)
            {
                InitializeTextObject(iObj, interactableObjects, dm, player);
            }
        }

        if (Debug.isDebugBuild && Const_Dev.IsDevMode)
        {
            Debug.Log("interactable objects count: " + interactableObjects.Count);
        }
    }
Пример #28
0
 private void Hold(Script_Player player)
 {
     Script_Player.Instance.Hold(gameObject);
 }
 void HandleEndItemDescriptionDialogue(Script_Player player)
 {
     player.HandleEndItemDescriptionDialogue();
 }