示例#1
0
 protected new void SetupWeapon()
 {
     colliders = transform.root.GetComponentsInChildren <Collider>();
     newHit    = new BeamHit(false, Vector3.zero, false, Vector3.zero, false, 0, transform);
     oldHit    = new BeamHit(false, Vector3.zero, false, Vector3.zero, false, 0, transform);
     lookpoint = Instantiate(new GameObject(), Vector3.zero, Quaternion.identity);
     base.SetupWeapon();
     colliders = transform.root.GetComponentsInChildren <Collider>();
 }
示例#2
0
 protected void DestroyBeam()
 {
     localFirstFire   = true;
     isRemotelyFiring = false;
     Destroy(beamStart);
     Destroy(beamEnd);
     Destroy(beam);
     newHit = new BeamHit(false, Vector3.zero, false, Vector3.zero, false, 0, transform);
     oldHit = new BeamHit(false, Vector3.zero, false, Vector3.zero, false, 0, transform);
 }
示例#3
0
 public override void ActivateWeapon()
 {
     // weaponPhotonView.RPC(nameof(AnimatorSetTriggerNetwork), RpcTarget.All, weaponSelectTriggerName);
     colliders = transform.root.GetComponentsInChildren <Collider>();
     newHit    = new BeamHit(false, Vector3.zero, false, Vector3.zero, false, 0, transform);
     oldHit    = new BeamHit(false, Vector3.zero, false, Vector3.zero, false, 0, transform);
     lookpoint = Instantiate(new GameObject(), Vector3.zero, Quaternion.identity);
     base.ActivateWeapon();
     base.SetupWeapon();
     SetupWeapon();
 }
示例#4
0
    // if we instant beam is false, lerp beam to first hit position
    protected IEnumerator RemoteLerpFirstHit(BeamHit firstPos)
    {
        float maxLerpTime = fireRate;

        if (Vector3.Distance(firstPos.worldHitPoint, barrelTransform.position) < 10)
        {
            maxLerpTime = fireRate / 4;
        }
        else if (Vector3.Distance(firstPos.worldHitPoint, barrelTransform.position) < 20)
        {
            maxLerpTime = fireRate / 2;
        }

        float elapsedTime = 0f;

        while (elapsedTime < maxLerpTime)
        {
            float t = elapsedTime / maxLerpTime;
            elapsedTime += Time.deltaTime;
            Vector3 targetPoint = Vector3.zero;
            if (firstPos.hasHitPlayer)
            {
                // Debug.Log("firstPos: " + firstPos);
                //  Debug.Log("firstPos.hitTransform: " + firstPos.hitTransform);
                //  Debug.Log("firstPos.localHitpoint: " + firstPos.localHitpoint);

                targetPoint = firstPos.hitTransform.TransformPoint(firstPos.localHitpoint);
            }
            else
            {
                targetPoint = firstPos.worldHitPoint;
            }


            Vector3 lerpTargetPos = Vector3.Lerp(barrelTransform.position, targetPoint, t);
            ShootBeamAtPoint(barrelEndMuzzleTransform.position, lerpTargetPos);
            yield return(new WaitForEndOfFrame());
        }
    }
示例#5
0
    protected IEnumerator LerpRemoteHits(BeamHit hit1, BeamHit hit2, int currentHitId)
    {
        float elapsedTime = 0f;
        float maxLerpTime = fireRate;

        // save tracking speed
        float oldTrackingSpeed = turretFollowTarget.trackingSpeed;
        float oldDeadZone      = turretFollowTarget.deadZone;

        while (elapsedTime < (fireRate))
        {
            float t = elapsedTime / maxLerpTime;
            if (t < 1)
            {
                elapsedTime += Time.deltaTime;
            }
            Vector3 pos1 = Vector3.zero;
            Vector3 pos2 = Vector3.zero;


            if (hit1.hasHitPlayer)
            {
                // Debug.Log("hit1: " + hit1);
                //Debug.Log("hit1.hitTransform: " + hit1.hitTransform);
                //Debug.Log("hit1.localHitpoint: " + hit1.localHitpoint);
                pos1 = hit1.hitTransform.TransformPoint(hit1.localHitpoint);
            }
            else
            {
                pos1 = hit1.worldHitPoint;
            }

            if (hit2.hasHitPlayer)
            {
                //  Debug.Log("hit2: " + hit2);
                //  Debug.Log("hit2.hitTransform: " + hit2.hitTransform);
                //  Debug.Log("hit2.localHitpoint: " + hit2.localHitpoint);
                pos2 = hit2.hitTransform.TransformPoint(hit2.localHitpoint);
            }
            else
            {
                pos2 = hit2.worldHitPoint;
            }


            Vector3 lerpTargetPos = Vector3.Lerp(pos1, pos2, t);
            ShootBeamAtPoint(barrelEndMuzzleTransform.position, lerpTargetPos);
            // set the lookpoint of the turret script
            lookpoint.transform.position             = pos2;
            turretFollowTarget.trackingSpeed         = 100;
            turretFollowTarget.deadZone              = 0;
            turretFollowTarget.deadZoneTrackingSpeed = 100;
            yield return(new WaitForEndOfFrame());
        }

        while (lastHitId == currentHitId)
        {
            Vector3 pos2 = Vector3.zero;
            if (hit2.hasHitPlayer)
            {
                // Debug.Log("hit2: " + hit2);
                // Debug.Log("hit2.hitTransform: " + hit2.hitTransform);
                // Debug.Log("hit2.localHitpoint: " + hit2.localHitpoint);
                pos2 = hit2.hitTransform.TransformPoint(hit2.localHitpoint);
            }
            else
            {
                pos2 = hit2.worldHitPoint;
            }
            ShootBeamAtPoint(barrelEndMuzzleTransform.position, pos2);
            lookpoint.transform.position = pos2;

            yield return(new WaitForEndOfFrame());
        }


        // restore tracking speed
        turretFollowTarget.trackingSpeed = oldTrackingSpeed;
        turretFollowTarget.deadZone      = oldDeadZone;
    }
示例#6
0
    protected void FireBeamRoundEffect_RPC(bool validHit, Vector3 worldHit, bool hitPlayer, Vector3 localHit, int hitTeamId)
    {
        lastHitId        += 1;
        timeSinceLastFire = 0;
        bool      firstFire        = false;
        Transform newTargetVehicle = transform;

        if (newHit.active)
        {
            oldHit = newHit;
        }

        if (hitPlayer)
        {
            newTargetVehicle = _playerTransformTracker.GetVehicleTransformFromTeamId(newHit.hitTeamId);
        }

        newHit = new BeamHit(validHit, worldHit, hitPlayer, localHit, true, hitTeamId, newTargetVehicle);
        if (oldHit.active == false)
        {
            oldHit = newHit;
        }

        // AnimatorSetTriggerNetwork(primaryFireAnimatorTriggerName);
        turretFollowTarget.target = lookpoint;

        // if the beam effects are currently null, instantiate them
        if (beam == null || newHit.Equals(oldHit))
        {
            CreateBeam();
            firstFire = true;
        }

        // deal effect at last  point to maintain beam / effect consistency
        if (oldHit.hasHitPlayer)
        {
            // get transform from team id
            Transform targetVehicle = _playerTransformTracker.GetVehicleTransformFromTeamId(oldHit.hitTeamId);
            oldHit.hitTransform = targetVehicle;
            // convert local targetpoint into world point
            Vector3 worldPoint = targetVehicle.TransformPoint(oldHit.localHitpoint);
            // instantiate impact at worldPoint
            // InstantiateImpactEffect(imapactParticle, worldPoint, impactParticleSound, imapactParticleVolume, 2f);
            PlayImpactSound();
        }

        else if (oldHit.validHit)
        {
            // InstantiateImpactEffect(missImpactParticle, oldHit.worldHitPoint, impactParticleSoundMiss, missImpactParticleVolume, 2f);
        }


        // if first fire, then lerp from barrel to target (if option selected)
        if (firstFire && !instantBeam)
        {
            StartCoroutine(RemoteLerpFirstHit(newHit));
        }
        // otherwise lerp between the two last hitpoints
        else
        {
            StartCoroutine(LerpRemoteHits(oldHit, newHit, lastHitId));
        }
    }