Beispiel #1
0
    /// <summary>
    /// Throws the object to a given position by converting the final position to velocity.
    /// </summary>
    /// <param name="_finalPosition">Final position where the object is supposed to be at the end of the trajectory.</param>
    /// <param name="_angle">Throw angle.</param>
    /// <param name="_bonusDamage">Bonus damages added to the attack.</param>
    public virtual void Throw(Vector3 _finalPosition, float _angle, int _bonusDamage)
    {
        if (!isHeld)
        {
            return;
        }

        if (owner.photonView.isMine)
        {
            // Throw the throwable for other players
            TDS_RPCManager.Instance.RPCPhotonView.RPC("CallMethodOnline", PhotonTargets.Others, TDS_RPCManager.GetInfo(photonView, GetType(), "Throw"), new object[] { transform.position.x, transform.position.y, transform.position.z, _finalPosition.x, _finalPosition.y, _finalPosition.z, _angle, _bonusDamage });
        }

        if (PhotonNetwork.isMasterClient)
        {
            ActivateHitbox(_bonusDamage);
        }

        transform.SetParent(null, true);

        rigidbody.isKinematic = false;
        rigidbody.velocity    = TDS_ThrowUtility.GetProjectileVelocityAsVector3(transform.position, _finalPosition, _angle);

        collider.enabled = true;
        isHeld           = false;

        owner.RemoveThrowable();
    }
Beispiel #2
0
    /// <summary>
    /// Set the animation state of the Fat Lady's animator.
    /// </summary>
    /// <param name="_state"></param>
    public void SetFatLadyAnim(FatLadyAnimState _state)
    {
        if (photonView.isMine)
        {
            TDS_RPCManager.Instance?.RPCPhotonView.RPC("CallMethodOnline", PhotonTargets.Others, TDS_RPCManager.GetInfo(photonView, GetType(), "SetFatLadyAnim"), new object[] { (int)_state });
        }

        switch (_state)
        {
        case FatLadyAnimState.Angry:
            animator.SetBool("IsAngry", true);
            break;

        case FatLadyAnimState.Cool:
            animator.SetBool("IsAngry", false);
            break;

        case FatLadyAnimState.Snack:
            animator.SetTrigger("Snack");
            break;

        case FatLadyAnimState.PrepareAttack:
            animator.SetTrigger("PrepareAttack");
            break;

        default:
            break;
        }
    }
 /// <summary>
 /// Spawns a specific FX at a given position.
 /// </summary>
 /// <param name="_fxtype">Type of FX to instantiate.</param>
 /// <param name="_position">Position where to spawn the FX.</param>
 public void SpawnEffect(FXType _fxtype, Vector3 _position)
 {
     TDS_RPCManager.Instance?.RPCPhotonView.RPC("CallMethodOnline", PhotonTargets.All, TDS_RPCManager.GetInfo(photonView, GetType(), "SpawnEffect"), new object[] { (int)_fxtype, _position.x, _position.y, _position.z });
 }
    /// <summary>
    /// Instantiate the fire effect for burning.
    /// </summary>
    protected virtual void InstantiateFireEffect()
    {
        if (photonView.isMine)
        {
            TDS_RPCManager.Instance?.RPCPhotonView.RPC("CallMethodOnline", PhotonTargets.Others, TDS_RPCManager.GetInfo(photonView, this.GetType(), "InstantiateFireEffect"), new object[] { });
        }

        burnEffect = ((GameObject)Instantiate(Resources.Load("Fire"), new Vector3(transform.position.x, transform.position.y, transform.position.z - .05f), Quaternion.identity)).GetComponent <Animator>();

        burnEffect.transform.SetParent(transform, true);
    }
Beispiel #5
0
    /// <summary>
    /// Try to grab a throwable.
    /// When grabbed, the object follows the character and can be thrown by this one.
    /// </summary>
    /// <param name="_throwable">Throwable to try to grab.</param>
    /// <returns>Returns true if the throwable was successfully grabbed, false either.</returns>
    public virtual bool GrabObject(TDS_Throwable _throwable)
    {
        // Call this method in master client only
        if (!PhotonNetwork.isMasterClient)
        {
            TDS_RPCManager.Instance.RPCPhotonView.RPC("CallMethodOnline", PhotonTargets.MasterClient, TDS_RPCManager.GetInfo(photonView, GetType(), "GrabObject"), new object[] { _throwable.photonView.viewID });
            return(false);
        }

        // Take the object if possible
        if (throwable || !_throwable.PickUp(this))
        {
            return(false);
        }

        return(true);
    }
Beispiel #6
0
    /// <summary>
    /// Set an animation state of the Fire Eater, used in the animator.
    /// </summary>
    /// <param name="_state">State to set in animation.</param>
    public void SetFireEaterAnim(FireEaterAnimState _state)
    {
        if (photonView.isMine)
        {
            TDS_RPCManager.Instance?.RPCPhotonView.RPC("CallMethodOnline", PhotonTargets.Others, TDS_RPCManager.GetInfo(photonView, GetType(), "SetFireEaterAnim"), new object[] { (int)_state });
        }

        switch (_state)
        {
        case FireEaterAnimState.Sober:
            animator.SetBool("IsDrunk", false);
            break;

        case FireEaterAnimState.Drunk:
            animator.SetBool("IsDrunk", true);
            break;

        case FireEaterAnimState.MiniGame:
            animator.ResetTrigger("Fire");
            animator.SetInteger("FireID", 9999999);
            break;

        case FireEaterAnimState.Spit:
            animator.SetInteger("FireID", 9999999);
            break;

        case FireEaterAnimState.DoNotSpit:
            animator.SetInteger("FireID", -9999999);
            break;

        case FireEaterAnimState.Fire:
            animator.SetTrigger("Fire");
            break;

        case FireEaterAnimState.Puke:
            animator.SetTrigger("Puke");
            break;

        default:
            break;
        }
    }
    /// <summary>
    /// Makes this object take damage and decrease its health if it is not invulnerable.
    /// </summary>
    /// <param name="_damage">Amount of damage this inflect to this object.</param>
    /// <returns>Returns true if some damages were inflicted, false if none.</returns>
    public virtual bool TakeDamage(int _damage)
    {
        if (IsInvulnerable || isDead)
        {
            return(false);
        }

        if (PhotonNetwork.isMasterClient)
        {
            TDS_RPCManager.Instance?.RPCPhotonView.RPC("CallMethodOnline", PhotonTargets.Others, TDS_RPCManager.GetInfo(photonView, GetType(), "TakeDamage"), new object[] { _damage });
        }

        HealthCurrent -= _damage;
        OnTakeDamage?.Invoke(_damage);

        return(true);
    }
Beispiel #8
0
    private void PlayRandomTaunt()
    {
        if (!audioSource || tauntAudioClips == null || tauntAudioClips.Length == 0)
        {
            return;
        }
        int       _index = (int)Random.Range((int)0, (int)tauntAudioClips.Length);
        AudioClip _clip  = tauntAudioClips[_index];

        if (!_clip)
        {
            return;
        }
        if (audioSource.isPlaying)
        {
            audioSource.Stop();
        }
        audioSource.clip   = _clip;
        audioSource.volume = .25f;
        audioSource.Play();
        if (PhotonNetwork.isMasterClient)
        {
            TDS_RPCManager.Instance?.RPCPhotonView.RPC("CallMethodOnline", PhotonTargets.Others, TDS_RPCManager.GetInfo(photonView, this.GetType(), "PlayTaunt"), new object[] { _index });
            Invoke("PlayRandomTaunt", Random.Range(tauntRateMin, tauntRateMax));
        }
    }
Beispiel #9
0
    private void PlayCallOutSound(string _enemyName)
    {
        if (!audioSource)
        {
            return;
        }
        AudioClip _clip = null;

        switch (_enemyName)
        {
        case "Fakir":
            _clip = fakirAudioClip;
            break;

        case "Mime":
            _clip = mimeAudioClip;
            break;

        case "Acrobat":
            _clip = acrobatAudioClip;
            break;

        case "MightyMan":
            _clip = mightyManAudioClip;
            break;

        case  "Cat":
            _clip = catAudioClip;
            break;

        default:
            return;
        }
        if (audioSource.isPlaying)
        {
            audioSource.Stop();
        }
        audioSource.clip   = _clip;
        audioSource.volume = .25f;
        audioSource.Play();
        if (PhotonNetwork.isMasterClient)
        {
            TDS_RPCManager.Instance?.RPCPhotonView.RPC("CallMethodOnline", PhotonTargets.Others, TDS_RPCManager.GetInfo(photonView, this.GetType(), "PlayCallOutSound"), new object[] { _enemyName });
        }
    }
    /// <summary>
    /// Load the next level
    /// If Master client, send the information to the other players
    /// </summary>
    public void LoadLevel()
    {
        if (!PhotonNetwork.offlineMode)
        {
            characterSelectionManager.CharacterSelectionMenu.LocalElement.ClearToggle();
            if (IsloadingNextScene)
            {
                //if (PhotonNetwork.isMasterClient)
                //  TDS_RPCManager.Instance?.RPCPhotonView.RPC("CallMethodOnline", PhotonTargets.Others, TDS_RPCManager.GetInfo(photonView, this.GetType(), "LoadLevel"), new object[] { });
                TDS_SceneManager.Instance?.PrepareOnlineSceneLoading(TDS_GameManager.CurrentSceneIndex + 1, (int)UIState.InGame);
            }
            else
            {
                if (PhotonNetwork.isMasterClient)
                {
                    TDS_RPCManager.Instance?.RPCPhotonView.RPC("CallMethodOnline", PhotonTargets.Others, TDS_RPCManager.GetInfo(photonView, GetType(), "LoadLevel"), new object[] { });
                }
                TDS_LevelManager.Instance.Spawn();
                ActivateMenu(UIState.InGame);
            }
            return;
        }

        if (IsloadingNextScene)
        {
            TDS_SceneManager.Instance?.PrepareSceneLoading(TDS_GameManager.CurrentSceneIndex + 1, (int)UIState.InGame);
        }
        else
        {
            TDS_LevelManager.Instance?.Spawn();
            ActivateMenu(UIState.InGame);
        }
        characterSelectionManager.CharacterSelectionMenu.CharacterSelectionElements.ToList().ForEach(e => e.ClearToggle());
    }
Beispiel #11
0
    private void SetAnimationState(int _animationID)
    {
        switch ((CatAnimationState)_animationID)
        {
        case CatAnimationState.Idle:
            animator.SetBool("isRunning", false);
            break;

        case CatAnimationState.Run:
            animator.SetBool("isRunning", true);
            break;

        case CatAnimationState.Hit:
            animator.SetTrigger("HitTrigger");
            break;

        case CatAnimationState.Jump:
            animator.SetTrigger("JumpTrigger");
            break;

        case CatAnimationState.EndJump:
            animator.SetTrigger("EndJumpTrigger");
            break;

        case CatAnimationState.Die:
            animator.SetBool("isDead", true);
            break;

        default:
            break;
        }
        if (PhotonNetwork.isMasterClient)
        {
            TDS_RPCManager.Instance?.RPCPhotonView.RPC("CallMethodOnline", PhotonTargets.Others, TDS_RPCManager.GetInfo(photonView, this.GetType(), "SetAnimationState"), new object[] { (int)_animationID });
        }
    }
    /// <summary>
    /// Activate or desactivate Menu depending of the uistate
    /// </summary>
    /// <param name="_state">State</param>
    public void ActivateMenu(UIState _state)
    {
        uiState = _state;
        switch (uiState)
        {
        case UIState.InMainMenu:
            TDS_SoundManager.Instance.PlayMusic(Music.TitleScreen, 1f);

            mainMenuParent.SetActive(true);
            roomSelectionMenuParent.SetActive(false);
            characterSelectionMenuParent.SetActive(false);
            inGameMenuParent.SetActive(false);
            pauseMenuParent.SetActive(false);
            gameOverScreenParent.SetActive(false);
            TDS_GameManager.PlayersInfo.Clear();
            characterSelectionManager.CharacterSelectionMenu.CharacterSelectionElements.ToList().ForEach(e => e.ClearToggle());
            Selectable.allSelectables.FirstOrDefault()?.Select();
            break;

        case UIState.InRoomSelection:
            if (!PhotonNetwork.connected)
            {
                StartCoroutine(PrepareConnectionToPhoton());
                break;
            }
            mainMenuParent.SetActive(false);
            roomSelectionMenuParent.SetActive(true);
            characterSelectionMenuParent.SetActive(false);
            inGameMenuParent.SetActive(false);
            pauseMenuParent.SetActive(false);
            gameOverScreenParent.SetActive(false);
            Selectable.allSelectables.FirstOrDefault()?.Select();

            if (roomSelectionManager)
            {
                StartCoroutine(roomSelectionManager.UpdatePlayerCount());
            }
            if (checkInputCoroutine != null)
            {
                StopCoroutine(checkInputCoroutine);
            }
            checkInputCoroutine = StartCoroutine(CheckInputMenu(UIState.InRoomSelection));
            break;

        case UIState.InCharacterSelection:
            if (addPlayerText)
            {
                addPlayerText.gameObject.SetActive(PhotonNetwork.offlineMode);
            }
            mainMenuParent.SetActive(false);
            roomSelectionMenuParent.SetActive(false);
            characterSelectionMenuParent.SetActive(true);
            inGameMenuParent.SetActive(false);
            pauseMenuParent.SetActive(false);
            gameOverScreenParent.SetActive(false);

            if (checkInputCoroutine != null)
            {
                StopCoroutine(checkInputCoroutine);
            }
            checkInputCoroutine = StartCoroutine(CheckInputMenu(UIState.InCharacterSelection));
            break;

        case UIState.InGame:
            mainMenuParent.SetActive(false);
            roomSelectionMenuParent.SetActive(false);
            characterSelectionMenuParent.SetActive(false);
            inGameMenuParent.SetActive(true);
            pauseMenuParent.SetActive(false);
            gameOverScreenParent.SetActive(false);
            if (checkInputCoroutine != null)
            {
                StopCoroutine(checkInputCoroutine);
            }
            checkInputCoroutine = StartCoroutine(CheckInputMenu(UIState.InGame));
            break;

        case UIState.InPause:
            pauseMenuParent.SetActive(true);
            Selectable.allSelectables.FirstOrDefault()?.Select();
            if (checkInputCoroutine != null)
            {
                StopCoroutine(checkInputCoroutine);
            }
            checkInputCoroutine = StartCoroutine(CheckInputMenu(UIState.InPause));
            break;

        case UIState.InGameOver:
            mainMenuParent.SetActive(false);
            roomSelectionMenuParent.SetActive(false);
            characterSelectionMenuParent.SetActive(false);
            inGameMenuParent.SetActive(false);
            pauseMenuParent.SetActive(false);
            gameOverScreenParent.SetActive(true);
            Selectable.allSelectables.FirstOrDefault()?.Select();
            StopAllCoroutines();
            if (!PhotonNetwork.isMasterClient)
            {
                TDS_RPCManager.Instance.RPCPhotonView.RPC("CallMethodOnline", PhotonTargets.MasterClient, TDS_RPCManager.GetInfo(photonView, this.GetType(), "UpdateReadySettings"), new object[] { PhotonNetwork.player.ID, false });
            }
            break;

        default:
            break;
        }
    }
 public void StartLeavingRoom()
 {
     TDS_GameManager.PlayersInfo.Clear();
     if (!TDS_GameManager.IsOnline)
     {
         PhotonNetwork.Disconnect();
         PhotonNetwork.offlineMode = false;
         ActivateMenu(UIState.InMainMenu);
         Selectable.allSelectables.First().Select();
         return;
     }
     if (PhotonNetwork.isMasterClient)
     {
         TDS_RPCManager.Instance?.RPCPhotonView.RPC("CallMethodOnline", PhotonTargets.Others, TDS_RPCManager.GetInfo(photonView, this.GetType(), "StartLeavingRoom"), new object[] { });
     }
     StartCoroutine(characterSelectionManager.PreapreLeavingRoom());
     roomSelectionManager.RoomSelectionElements.First().RoomSelectionButton.Select();
 }
 /// <summary>
 /// Call when the Restart Button is pressed
 /// If not master client, send a message to say the player is ready
 /// If master, send a message to everybody to reset the level
 /// </summary>
 public void OnRestartButtonPressed()
 {
     beardLadyLifeBar.ResetLifeBar();
     fatLadyLifeBar.ResetLifeBar();
     fireEaterLifeBar.ResetLifeBar();
     jugglerLifeBar.ResetLifeBar();
     if (PhotonNetwork.offlineMode)
     {
         ResetLevel();
         return;
     }
     if (PhotonNetwork.isMasterClient)
     {
         TDS_RPCManager.Instance?.RPCPhotonView.RPC("CallMethodOnline", PhotonTargets.Others, TDS_RPCManager.GetInfo(photonView, this.GetType(), "ResetLevel"), new object[] { });
         ResetLevel();
     }
     else
     {
         TDS_RPCManager.Instance.RPCPhotonView.RPC("CallMethodOnline", PhotonTargets.MasterClient, TDS_RPCManager.GetInfo(photonView, this.GetType(), "UpdateReadySettings"), new object[] { PhotonNetwork.player.ID, true });
     }
 }
Beispiel #15
0
    /// <summary>
    /// Makes the animal flee a certain collider.
    /// </summary>
    /// <param name="_collider">Collider to flee.</param>
    /// <returns></returns>
    protected override IEnumerator Flee(Collider _collider)
    {
        yield return(new WaitForSeconds(fleeDelay));

        // Trigger animation
        SetAnimationOnline(1);

        float _xMinDistance = _collider.bounds.extents.x + detector.Collider.bounds.size.x;
        float _zMinDistance = _collider.bounds.extents.z + detector.Collider.bounds.size.z;

        Vector3 _actualDestination = new Vector3();
        Vector3 _newDestination    = new Vector3();

        float _direction = 0;

        // Move while in range
        while ((Mathf.Abs(_direction = (detector.Collider.bounds.center.x - _collider.bounds.center.x)) < _xMinDistance) && (Mathf.Abs(_collider.bounds.center.z - detector.Collider.bounds.center.z) < _zMinDistance))
        {
            _direction      = Mathf.Sign(_direction);
            _newDestination = new Vector3(_collider.bounds.center.x + (_xMinDistance * 1.5f * _direction), transform.position.y, transform.position.z);

            if (_newDestination != _actualDestination)
            {
                if (_direction != isFacingRight.ToSign())
                {
                    transform.Rotate(Vector3.up, 180);
                    transform.localScale = new Vector3(transform.localScale.x, transform.localScale.y, transform.localScale.z * -1);
                    isFacingRight        = !isFacingRight;
                }

                // New destination ignored, got to be fixed
                _actualDestination = _newDestination;
                Debug.Log(_actualDestination);
                agent.SetDestination(_actualDestination);

                // Set destination for other clients
                TDS_RPCManager.Instance.RPCPhotonView.RPC("CallMethodOnline", PhotonTargets.Others, TDS_RPCManager.GetInfo(photonView, GetType(), "SetDestination"), new object[] { _actualDestination.x, _actualDestination.y, _actualDestination.z });
            }

            yield return(null);
        }

        // Trigger animation
        SetAnimationOnline(0);

        fleeCoroutine = null;
    }
    /// <summary>
    /// Inflict damages to a specified target.
    /// </summary>
    /// <param name="_target">Target to hit.</param>
    private void InflictDamages(TDS_Damageable _target)
    {
        // Attack the target
        if (CurrentAttack.Attack(this, _target) < -1)
        {
            return;
        }

        // Call local method on the character who hit
        if (Owner)
        {
            if (PhotonNetwork.offlineMode && (Owner is TDS_Player _player))
            {
                _player.HitCallback(_target.Collider.bounds.center.x, _target.Collider.bounds.max.y, _target.transform.position.z);
            }
            else
            {
                TDS_RPCManager.Instance?.RPCPhotonView.RPC("CallMethodOnline", Owner.photonView.owner, TDS_RPCManager.GetInfo(Owner.photonView, Owner.GetType(), "HitCallback"), new object[] { _target.Collider.bounds.center.x, _target.Collider.bounds.max.y, _target.transform.position.z });
            }
        }

        // Triggers event
        OnTouch?.Invoke();
    }
    /// <summary>
    /// Load the scene async and display the loading screen during the loading time
    /// </summary>
    /// <param name="_sceneIndex">Index of the scene in the build</param>
    /// <returns></returns>
    private IEnumerator LoadSceneOnline(int _sceneIndex, int _nextUIState)
    {
        if (PhotonNetwork.isMasterClient)
        {
            TDS_RPCManager.Instance?.RPCPhotonView.RPC("CallMethodOnline", PhotonTargets.Others, TDS_RPCManager.GetInfo(photonView, GetType(), "PrepareOnlineSceneLoading"), new object[] { _sceneIndex, _nextUIState });
        }

        TDS_UIManager.Instance?.DisplayLoadingScreen(true);
        yield return(new WaitForSeconds(1f));

        AsyncOperation _async = SceneManager.LoadSceneAsync(_sceneIndex, LoadSceneMode.Single);

        while (!_async.isDone)
        {
            yield return(null);
        }
        TDS_GameManager.CurrentSceneIndex = _sceneIndex;
        if (PhotonNetwork.connected && PhotonNetwork.isMasterClient && PlayerSceneLoaded.Count > 0)
        {
            while (PlayerSceneLoaded.Any(p => p.Value == false))
            {
                yield return(null);
            }
            TDS_RPCManager.Instance?.RPCPhotonView.RPC("CallMethodOnline", PhotonTargets.Others, TDS_RPCManager.GetInfo(photonView, this.GetType(), "OnEverySceneReady"), new object[] { });
        }
        else if (PhotonNetwork.connected && !PhotonNetwork.isMasterClient)
        {
            TDS_RPCManager.Instance?.RPCPhotonView.RPC("CallMethodOnline", PhotonTargets.MasterClient, TDS_RPCManager.GetInfo(photonView, this.GetType(), "PlayerHasLoadScene"), new object[] { PhotonNetwork.player.ID });
            while (!sceneIsReady)
            {
                yield return(null);
            }
        }
        // Call OnEveryOneSceneLoaded online
        OnEveryOneSceneLoaded();
        TDS_UIManager.Instance.ActivateMenu(_nextUIState);
    }
    /// <summary>
    /// Get the next destination of the rabbit and set it on the navmeshagent
    /// Flip the rabbit and invert its goright boolean
    /// </summary>
    private void Run()
    {
        if (!PhotonNetwork.isMasterClient)
        {
            return;
        }
        float   _x = goRight ? boundRight : boundLeft;
        Vector3 _targetPosition = new Vector3(_x, transform.position.y, transform.position.z);

        goRight = !goRight;
        agent.SetDestination(_targetPosition);
        TDS_RPCManager.Instance?.RPCPhotonView.RPC("CallMethodOnline", PhotonTargets.All, TDS_RPCManager.GetInfo(photonView, this.GetType(), "Flip"), new object[] { });
    }
    /// <summary>
    /// Makes this object be healed and restore its health.
    /// </summary>
    /// <param name="_heal">Amount of health point to restore.</param>
    public virtual void Heal(int _heal)
    {
        if (PhotonNetwork.isMasterClient)
        {
            TDS_RPCManager.Instance?.RPCPhotonView.RPC("CallMethodOnline", PhotonTargets.Others, TDS_RPCManager.GetInfo(photonView, this.GetType(), "Heal"), new object[] { _heal });
        }

        HealthCurrent += _heal;
        OnHeal?.Invoke(_heal);
    }
    /// <summary>
    /// Called when a player catch the rabbit
    /// Heal the player and Destroy the rabbit
    /// </summary>
    /// <param name="_player"></param>
    public override void Use(TDS_Player _player)
    {
        if (!PhotonNetwork.isMasterClient)
        {
            TDS_RPCManager.Instance.RPCPhotonView.RPC("CallMethodOnline", PhotonTargets.MasterClient, TDS_RPCManager.GetInfo(photonView, GetType(), "UseOnline"), new object[] { _player.PhotonID });
            return;
        }
        int _healingValue = UnityEngine.Random.Range(healingValueMin, healingValueMax);

        _player.Heal(_healingValue);

        OnUseRabbit?.Invoke();
        TDS_VFXManager.Instance.SpawnEffect(FXType.RabbitPoof, transform.position + Vector3.up);
        PhotonNetwork.Destroy(gameObject);
    }
    /// <summary>
    /// Destroys the fire effect object.
    /// </summary>
    protected virtual void DestroyFireEffect()
    {
        if (photonView.isMine)
        {
            TDS_RPCManager.Instance?.RPCPhotonView.RPC("CallMethodOnline", PhotonTargets.Others, TDS_RPCManager.GetInfo(photonView, this.GetType(), "DestroyFireEffect"), new object[] { });
        }

        if (burnEffect)
        {
            burnEffect.SetTrigger("Vanish");
        }
    }
Beispiel #22
0
    /// <summary>
    /// Select a new character (used in UnityEvent)
    /// </summary>
    /// <param name="_newPlayerType">Index of the enum PlayerType</param>
    public void SelectCharacterOnline()
    {
        if (TDS_GameManager.LocalIsReady)
        {
            OnLocalPlayerReadyOnline(false);
            return;
        }
        int _newPlayerType = (int)characterSelectionMenu.LocalElement.CurrentSelection.CharacterType;

        TDS_GameManager.LocalPlayer = (PlayerType)_newPlayerType;
        TDS_RPCManager.Instance?.RPCPhotonView.RPC("CallMethodOnline", PhotonTargets.Others, TDS_RPCManager.GetInfo(photonView, this.GetType(), "UpdatePlayerSelectionInfo"), new object[] { _newPlayerType, PhotonNetwork.player.ID });
        OnLocalPlayerReadyOnline(true);
    }
Beispiel #23
0
    /// <summary>
    /// Drop the weared throwable.
    /// </summary>
    /// <returns>Returns true if successfully dropped the object, false if not having an object to drop.</returns>
    public virtual bool DropObject()
    {
        // Call this method in owner only
        if (!photonView.isMine)
        {
            TDS_RPCManager.Instance.RPCPhotonView.RPC("CallMethodOnline", photonView.owner, TDS_RPCManager.GetInfo(photonView, GetType(), "DropObject"), new object[] { });
            return(false);
        }

        // If no throwable, return
        if (!throwable)
        {
            return(false);
        }

        // Drooop
        throwable.Drop();
        return(true);
    }
Beispiel #24
0
 private void SendInfoToNewPlayer(PhotonPlayer _newPlayer)
 {
     TDS_RPCManager.Instance?.RPCPhotonView.RPC("CallMethodOnline", _newPlayer, TDS_RPCManager.GetInfo(photonView, this.GetType(), "ReceiveOnConnectionInfo"), new object[] { PhotonNetwork.player.ID, TDS_GameManager.LocalIsReady, (int)characterSelectionMenu.LocalElement.CurrentSelection.CharacterType });
 }
Beispiel #25
0
    /// <summary>
    /// Throws the weared throwable.
    /// </summary>
    /// <param name="_targetPosition">Position where the object should land</param>
    public virtual bool ThrowObject(Vector3 _targetPosition)
    {
        // Call this method in owner only
        if (!photonView.isMine)
        {
            TDS_RPCManager.Instance.RPCPhotonView.RPC("CallMethodOnline", photonView.owner, TDS_RPCManager.GetInfo(photonView, GetType(), "ThrowObject_A"), new object[] { });
            return(false);
        }

        // Return false if no throwable
        if (!throwable)
        {
            return(false);
        }

        // Alright, then throw it !
        throwable.Throw(_targetPosition, aimAngle, RandomThrowBonusDamages);
        return(true);
    }
Beispiel #26
0
 /// <summary>
 /// When a player select a new character, display the image of the character on the others players
 /// </summary>
 /// <param name="_player">Updated player</param>
 /// <param name="_newCharacterSelectionIndex">New Index</param>
 public void UpdateLocalCharacterIndex(PhotonPlayer _player, int _newCharacterSelectionIndex)
 {
     TDS_RPCManager.Instance?.RPCPhotonView.RPC("CallMethodOnline", PhotonTargets.Others, TDS_RPCManager.GetInfo(photonView, this.GetType(), "UpdateOnlineCharacterIndex"), new object[] { _player.ID, _newCharacterSelectionIndex });
 }
    /// <summary>
    /// Set this destructible animation state.
    /// </summary>
    /// <param name="_state">New animation state of the destructible.</param>
    public void SetAnimationState(DestructibleAnimState _state)
    {
        // Online
        if (PhotonNetwork.isMasterClient)
        {
            // if (!animator) return;
            TDS_RPCManager.Instance?.RPCPhotonView.RPC("CallMethodOnline", PhotonTargets.Others, TDS_RPCManager.GetInfo(photonView, this.GetType(), "SetAnimationState"), new object[] { (int)_state });
        }

        switch (_state)
        {
        case DestructibleAnimState.Hit:
            animator.SetTrigger("Hit");
            break;

        case DestructibleAnimState.Destruction:
            animator.SetTrigger("Destruction");
            break;

        default:
            break;
        }
    }
Beispiel #28
0
    /// <summary>
    /// Called when the toggle is pressed
    /// Update the ready settings
    /// If the player has an Unknown PlayerType, the game cannot start
    /// </summary>
    public void OnLocalPlayerReadyOnline(bool _isReady)
    {
        TDS_CharacterSelectionElement _elem = characterSelectionMenu.CharacterSelectionElements.Where(e => (e.PlayerInfo != null) && (e.PlayerInfo.PhotonPlayer == PhotonNetwork.player)).FirstOrDefault();

        if (_elem == null)
        {
            return;
        }
        _elem.IsLocked = _isReady;
        TDS_RPCManager.Instance.RPCPhotonView.RPC("CallMethodOnline", PhotonTargets.All, TDS_RPCManager.GetInfo(photonView, this.GetType(), "SetOnlinePlayerReady"), new object[] { PhotonNetwork.player.ID, TDS_GameManager.LocalIsReady });
        if (!_isReady)
        {
            TDS_RPCManager.Instance.RPCPhotonView.RPC("CallMethodOnline", PhotonTargets.All, TDS_RPCManager.GetInfo(photonView, this.GetType(), "UnlockPlayerType"), new object[] { (int)characterSelectionMenu.LocalElement.CurrentSelection.CharacterType });
        }
        if (!PhotonNetwork.isMasterClient)
        {
            TDS_RPCManager.Instance.RPCPhotonView.RPC("CallMethodOnline", PhotonTargets.MasterClient, TDS_RPCManager.GetInfo(photonView, typeof(TDS_UIManager), "UpdateReadySettings"), new object[] { PhotonNetwork.player.ID, TDS_GameManager.LocalIsReady });
            return;
        }
        TDS_UIManager.Instance?.UpdateReadySettings(PhotonNetwork.player.ID, TDS_GameManager.LocalIsReady);
    }
    /// <summary>
    /// Spawns a specific FX at a given position.
    /// </summary>
    /// <param name="_fxRype">Type of FX to instantiate.</param>
    /// <param name="_transformPhoton">PhotonView of the transform to use as FX parent.</param>
    public void SpawnEffect(FXType _fxRype, PhotonView _transformPhotonView)
    {
        if (PhotonNetwork.offlineMode)
        {
            Instantiate(GetFX((FXType)_fxRype), _transformPhotonView.transform, false);
            return;
        }

        TDS_RPCManager.Instance?.RPCPhotonView.RPC("CallMethodOnline", PhotonTargets.All, TDS_RPCManager.GetInfo(photonView, GetType(), "SpawnEffect"), new object[] { (int)_fxRype, _transformPhotonView });
    }
Beispiel #30
0
    /// <summary>
    /// Let a character pickup the object.
    /// </summary>
    /// <param name="_owner">Character attempting to pick up the object.</param>
    /// <returns>Returns true is successfully picked up the object, false if a issue has been encountered.</returns>
    public virtual bool PickUp(TDS_Character _owner)
    {
        if (isHeld || owner)
        {
            return(false);
        }

        isHeld = true;
        owner  = _owner;
        owner.SetThrowable(this);

        if (PhotonNetwork.isMasterClient)
        {
            if (hitBox.IsActive)
            {
                hitBox.Desactivate();
            }

            // Pickup the throwable for other players
            TDS_RPCManager.Instance.RPCPhotonView.RPC("CallMethodOnline", PhotonTargets.Others, TDS_RPCManager.GetInfo(photonView, GetType(), "PickUp"), new object[] { _owner.PhotonID });
        }

        gameObject.layer = _owner.gameObject.layer;

        if (shadow && !shadow.activeInHierarchy)
        {
            shadow.SetActive(true);
        }
        rigidbody.isKinematic = true;
        collider.enabled      = false;

        return(true);
    }