예제 #1
0
    public void LaunchThrowCompetence(GameObject objLauncher)
    {
        OnDiscThrownAnimEvent?.Invoke(); //Event
        ChangeUsabilityState(UsabilityState.Using, ActionType.Throw);
        CameraManager.instance.GetPlayerCamera.ResetPlayerCamera();
        currentObjLauncher   = objLauncher;
        currentThrowPosition = currentWorldMouseResult.mouseWorldPosition;

        Vector3           lookPos             = currentThrowPosition;
        List <DiscScript> inRangeThrowedDiscs = new List <DiscScript>();
        List <DiscScript> inRangeDiscs        = DiscManager.Instance.GetInRangeDiscs;

        foreach (DiscScript disc in DiscManager.Instance.GetAllThrowedDiscs)
        {
            if (inRangeDiscs.Contains(disc))
            {
                inRangeThrowedDiscs.Add(disc);
            }
        }

        if (inRangeThrowedDiscs.Count > 0)
        {
            foreach (TrajectoryModifier modifier in throwCompetence.GetTrajectoryModifiers)
            {
                TrajectoryModifierLinkedDiscs linkModifier = modifier as TrajectoryModifierLinkedDiscs;
                if (linkModifier != null)
                {
                    switch (linkModifier.GetLinkedDiscTrajectoryType)
                    {
                    case DiscsOrder.FromOldestToNewest:
                        lookPos = inRangeThrowedDiscs[0].transform.position;
                        break;

                    case DiscsOrder.FromNewestToOldest:
                        lookPos = inRangeThrowedDiscs[inRangeThrowedDiscs.Count - 1].transform.position;
                        break;
                    }

                    break;
                }
            }
        }
        _player.StartLookAt(lookPos);
    }
예제 #2
0
    public static DiscTrajectoryParameters GetTrajectory(CompetenceDisc competence, Vector3 startPosition, Vector3 targetPosition, List <DiscScript> throwedDiscs, List <DiscScript> inRangeDiscs, DiscScript currentDisc)
    {
        DiscTrajectoryParameters discTrajectoryParameters = new DiscTrajectoryParameters();

        discTrajectoryParameters.disc = currentDisc;
        List <Vector3> trajectoryPositions = new List <Vector3>();
        Vector3        totalDirection      = (targetPosition - startPosition).normalized;

        List <TrajectoryModifier> trajectoryModifiers = competence.GetTrajectoryModifiers;
        DiscsOrder linkedDiscsTrajectory        = DiscsOrder.None;
        TrajectoryModifierCurved curvedModifier = null;

        foreach (TrajectoryModifier modifier in trajectoryModifiers)
        {
            if (linkedDiscsTrajectory == DiscsOrder.None)
            {
                TrajectoryModifierLinkedDiscs linkedDiscModifier = modifier as TrajectoryModifierLinkedDiscs;
                if (linkedDiscModifier != null)
                {
                    linkedDiscsTrajectory = linkedDiscModifier.GetLinkedDiscTrajectoryType;
                }
            }

            if (curvedModifier == null)
            {
                TrajectoryModifierCurved foundCurvedModifier = modifier as TrajectoryModifierCurved;
                if (foundCurvedModifier != null)
                {
                    curvedModifier = foundCurvedModifier;
                }
            }
        }

        trajectoryPositions.Add(startPosition);

        #region Discs Link
        switch (linkedDiscsTrajectory)
        {
        case DiscsOrder.FromOldestToNewest:
            for (int i = 0; i < throwedDiscs.Count; i++)
            {
                DiscScript linkDisc = throwedDiscs[i];
                if (linkDisc != currentDisc)
                {
                    if (inRangeDiscs.Contains(linkDisc))
                    {
                        trajectoryPositions.Add(linkDisc.transform.position);
                    }
                }
            }
            break;

        case DiscsOrder.FromNewestToOldest:

            for (int i = throwedDiscs.Count - 1; i >= 0; i--)
            {
                DiscScript linkDisc = throwedDiscs[i];
                if (linkDisc != currentDisc)
                {
                    if (inRangeDiscs.Contains(linkDisc))
                    {
                        trajectoryPositions.Add(linkDisc.transform.position);
                    }
                }
            }
            break;
        }
        #endregion

        #region
        if (curvedModifier != null)
        {
            trajectoryPositions.Add(targetPosition);
            List <Vector3> curvedTrajectoryPositions = new List <Vector3>();

            for (int i = 0; i < trajectoryPositions.Count - 1; i++)
            {
                curvedTrajectoryPositions.Add(trajectoryPositions[i]);
                AddCurvedTrajectoryBetweenTwoPoints(ref curvedTrajectoryPositions, trajectoryPositions[i], trajectoryPositions[i + 1], curvedModifier);
            }

            trajectoryPositions = curvedTrajectoryPositions;
        }
        #endregion

        trajectoryPositions.Add(targetPosition);

        discTrajectoryParameters.trajectoryPositions = trajectoryPositions;

        return(discTrajectoryParameters);
    }