1657 lines
48 KiB
C#
1657 lines
48 KiB
C#
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
using UnityEngine.Events;
|
|
|
|
public class bowSystem : MonoBehaviour
|
|
{
|
|
[Header ("Main Settings")]
|
|
[Space]
|
|
|
|
public int regularBowMovementID;
|
|
public int loadedBowMovementID;
|
|
|
|
public bool activateStrafeOnlyWhenAimingBow;
|
|
|
|
[Space]
|
|
|
|
public float targetRotation;
|
|
|
|
public float minTimeToShootArrows = 2;
|
|
|
|
public float minTimeToAimBow = 1.5f;
|
|
|
|
public bool arrowsManagedByInventory;
|
|
|
|
public bool activateBowCollisionWhenAiming;
|
|
|
|
public bool stopAimBowOnLanding;
|
|
|
|
public bool resetArrowIndexOnBowStateChangeEnabled = true;
|
|
|
|
public bool activateAimingStateOnPlayerControllerEnabled = true;
|
|
|
|
[Space]
|
|
[Header ("Animation Settings")]
|
|
[Space]
|
|
|
|
public bool useDrawHolsterActionAnimations = true;
|
|
public string drawBowActionName = "Draw Bow";
|
|
public string holsterBowActionName = "Holster Bow";
|
|
|
|
public string loadArrowActionName = "Load Arrow";
|
|
public string fireArrowActionName = "Fire Arrow";
|
|
|
|
[Space]
|
|
[Header ("Damage Settings")]
|
|
[Space]
|
|
|
|
public bool useCustomIgnoreTags;
|
|
|
|
public List<string> customTagsToIgnoreList = new List<string> ();
|
|
|
|
[Space]
|
|
[Header ("Third Person Camera State Settings")]
|
|
[Space]
|
|
|
|
public bool setNewCameraStateOnThirdPerson;
|
|
|
|
public string newCameraStateOnThirdPerson;
|
|
|
|
public bool setNewCameraStateOnFBA;
|
|
|
|
public string newCameraStateOnFBA = "Full Body Awareness Aim Bow";
|
|
|
|
[Space]
|
|
[Header ("Fire Bow Without Aim Settings")]
|
|
[Space]
|
|
|
|
public bool canFireBowWithoutAimEnabled;
|
|
|
|
public float delayToFireBowWithoutAim;
|
|
|
|
public bool autoFireArrowsWithoutAim;
|
|
public float waitTimeToStopAutoFire = 0.5f;
|
|
|
|
public bool setCameraStateIfNoAimInputUsedEnabled;
|
|
|
|
[Space]
|
|
[Header ("Bow Weapon Types List")]
|
|
[Space]
|
|
|
|
public List<bowWeaponSystemInfo> bowWeaponSystemInfoList = new List<bowWeaponSystemInfo> ();
|
|
|
|
[Space]
|
|
|
|
public int currentBowWeaponID;
|
|
|
|
[Space]
|
|
[Header ("Bullet Time Settings")]
|
|
[Space]
|
|
|
|
public bool activateBulletTimeOnAir;
|
|
public float bulletTimeScale;
|
|
public float animationSpeedOnBulletTime = 1;
|
|
|
|
public bool reduceGravityMultiplerOnBulletTimeOnAir;
|
|
public float gravityMultiplerOnBulletTimeOnAir;
|
|
|
|
public bool useBulletTimeOnBowExternallyEnabled;
|
|
|
|
[Space]
|
|
|
|
public bool useEventOnBulletTime;
|
|
|
|
[Space]
|
|
|
|
public UnityEvent eventOnBulletTimeStart;
|
|
public UnityEvent eventOnBulletTimeEnd;
|
|
|
|
[Space]
|
|
[Header ("Other Settings")]
|
|
[Space]
|
|
|
|
public bool useUpperBodyRotationSystemToAim = true;
|
|
|
|
public bool setNewUpperBodyRotationValues;
|
|
|
|
public float horizontalBendingMultiplier = 1;
|
|
public float verticalBendingMultiplier = 1;
|
|
|
|
public float extraUpperBodyRotation = 90;
|
|
|
|
public float headTrackBodyWeightOnAim = 1;
|
|
|
|
public bool canMoveWhileUsingBowEnabled = true;
|
|
|
|
public float cancelBowStateOnEmptyArrowsWaitDelay = 0.5f;
|
|
|
|
[Space]
|
|
[Header ("Durability Settings")]
|
|
[Space]
|
|
|
|
public bool ignoreDurability;
|
|
public float generalAttackDurabilityMultiplier = 1;
|
|
|
|
[Space]
|
|
[Header ("Debug")]
|
|
[Space]
|
|
|
|
public bool showDebugPrint;
|
|
|
|
public bool bowActive;
|
|
|
|
public bool bowLoadedActive;
|
|
|
|
public bool arrowIsFired;
|
|
|
|
public bool aimingBowActive;
|
|
|
|
public bool arrowsAvailableToFire = true;
|
|
|
|
public bool checkArrowsOnInventory;
|
|
|
|
public bool aimInputPressedDown;
|
|
|
|
public bool bulletTimeOnAirActive;
|
|
|
|
public bool aimInputPressedOnFireArrowWithoutAim;
|
|
|
|
public bool fireArrowWithoutAimActive;
|
|
|
|
public bool cancelBowCoroutineActive;
|
|
|
|
public float lastTimePullBow;
|
|
|
|
[Space]
|
|
|
|
public int currentMultipleArrowTypeIndex;
|
|
|
|
[Space]
|
|
[Header ("Events Settings")]
|
|
[Space]
|
|
|
|
public UnityEvent eventOnBowEnabled;
|
|
public UnityEvent eventOnBowDisabled;
|
|
|
|
[Space]
|
|
|
|
public UnityEvent eventOnStartAim;
|
|
public UnityEvent eventOnEndAim;
|
|
|
|
[Space]
|
|
|
|
public UnityEvent eventOnFireArrow;
|
|
|
|
[Space]
|
|
|
|
public UnityEvent eventOnCancelLoadBowOnStopAim;
|
|
|
|
[Space]
|
|
[Header ("Components")]
|
|
[Space]
|
|
|
|
public playerActionSystem mainPlayerActionSystem;
|
|
public playerController mainPlayerController;
|
|
public playerCamera mainPlayerCamera;
|
|
|
|
public upperBodyRotationSystem mainUpperBodyRotationSystem;
|
|
|
|
public headTrack mainHeadTrack;
|
|
|
|
public simpleWeaponSystem currentSimpleWeaponSystem;
|
|
|
|
public Transform positionToPlaceArrow;
|
|
public Transform arrowPositionReference;
|
|
|
|
public grabbedObjectMeleeAttackSystem mainGrabbedObjectMeleeAttackSystem;
|
|
|
|
public bowHolderSystem currentBowHolderSystem;
|
|
|
|
public GameObject arrowMeshPrefab;
|
|
public GameObject arrowMesh;
|
|
|
|
public arrowManager mainArrowManager;
|
|
|
|
float lastTimeShootArrow = 0;
|
|
|
|
bowWeaponSystemInfo currentBowWeaponSystemInfo;
|
|
|
|
durabilityInfo currentBowDurabilityInfo;
|
|
|
|
float lastTimeAimBow;
|
|
|
|
Coroutine checOnGrounCoroutine;
|
|
|
|
Coroutine changeExtraRotation;
|
|
|
|
Coroutine updateBowCoroutine;
|
|
|
|
bool onGroundState;
|
|
|
|
string previousCameraState = "";
|
|
|
|
float lastTimeCheckFireArrowWithoutAim;
|
|
|
|
bool pauseMoveInputActive;
|
|
|
|
Coroutine cancelBowStateCoroutine;
|
|
|
|
bool ignoreUseDrawHolsterActionAnimations;
|
|
|
|
bool mainPlayerCameraLocated;
|
|
|
|
bool originalArrowsManagedByInventory;
|
|
|
|
|
|
void Start ()
|
|
{
|
|
originalArrowsManagedByInventory = arrowsManagedByInventory;
|
|
}
|
|
|
|
public void stopUpdateBowStateCoroutine ()
|
|
{
|
|
if (updateBowCoroutine != null) {
|
|
StopCoroutine (updateBowCoroutine);
|
|
}
|
|
|
|
onGroundState = false;
|
|
}
|
|
|
|
IEnumerator updateBowStateCoroutine ()
|
|
{
|
|
var waitTime = new WaitForFixedUpdate ();
|
|
|
|
while (true) {
|
|
yield return waitTime;
|
|
|
|
if (onGroundState) {
|
|
if (!mainPlayerController.isPlayerOnGround ()) {
|
|
onGroundState = false;
|
|
}
|
|
|
|
if (!canMoveWhileUsingBowEnabled) {
|
|
if (aimingBowActive || fireArrowWithoutAimActive) {
|
|
if (!pauseMoveInputActive) {
|
|
mainPlayerController.setMoveInputPausedState (true);
|
|
mainPlayerController.resetPlayerControllerInput ();
|
|
|
|
pauseMoveInputActive = true;
|
|
}
|
|
} else {
|
|
if (pauseMoveInputActive) {
|
|
mainPlayerController.setMoveInputPausedState (false);
|
|
|
|
pauseMoveInputActive = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (onGroundState) {
|
|
if (mainPlayerController.isCrouching ()) {
|
|
cancelBowState ();
|
|
|
|
aimInputPressedDown = false;
|
|
}
|
|
}
|
|
} else {
|
|
if (mainPlayerController.isPlayerOnGround ()) {
|
|
onGroundState = true;
|
|
|
|
if (stopAimBowOnLanding) {
|
|
if (aimingBowActive) {
|
|
cancelBowState ();
|
|
|
|
aimInputPressedDown = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (pauseMoveInputActive) {
|
|
mainPlayerController.setMoveInputPausedState (false);
|
|
|
|
pauseMoveInputActive = false;
|
|
}
|
|
}
|
|
|
|
if (fireArrowWithoutAimActive) {
|
|
if (Time.unscaledTime > lastTimeCheckFireArrowWithoutAim + delayToFireBowWithoutAim) {
|
|
inputFireArrow ();
|
|
|
|
if (!autoFireArrowsWithoutAim) {
|
|
stopAimAfterFiringArrowWithoutAimActive = true;
|
|
}
|
|
|
|
lastTimeCheckFireArrowWithoutAim = Time.unscaledTime;
|
|
} else {
|
|
if (stopAimAfterFiringArrowWithoutAimActive) {
|
|
if (Time.unscaledTime > lastTimeCheckFireArrowWithoutAim + waitTimeToStopAutoFire) {
|
|
fireArrowWithoutAimActive = false;
|
|
|
|
setAimState (false);
|
|
|
|
stopAimAfterFiringArrowWithoutAimActive = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (bowLoadedActive && lastTimePullBow != 0) {
|
|
if (currentBowWeaponSystemInfo.usePullBowMultipliers &&
|
|
currentBowWeaponSystemInfo.useEventOnMaxPullBowMultiplier &&
|
|
!currentBowWeaponSystemInfo.eventOnMaxPullBowMultiplierActivated) {
|
|
|
|
bool checkPullBowMultipliersResult = true;
|
|
|
|
if (currentBowWeaponSystemInfo.ignorePullMultiplierIfShootingArrowWithoutAim && fireArrowWithoutAimActive) {
|
|
checkPullBowMultipliersResult = false;
|
|
}
|
|
|
|
if (checkPullBowMultipliersResult) {
|
|
checkEventOnMaxPullBowMultiplierStartOrEnd (true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool stopAimAfterFiringArrowWithoutAimActive;
|
|
|
|
public void setBowLoadedState (bool state)
|
|
{
|
|
bowLoadedActive = state;
|
|
|
|
if (bowLoadedActive) {
|
|
mainPlayerController.setCurrentStrafeIDValue (loadedBowMovementID);
|
|
|
|
if (activateStrafeOnlyWhenAimingBow || (mainPlayerCameraLocated && mainPlayerCamera.is2_5ViewActive ())) {
|
|
mainPlayerController.activateOrDeactivateStrafeMode (true);
|
|
}
|
|
|
|
mainPlayerActionSystem.activateCustomAction (loadArrowActionName);
|
|
|
|
arrowIsFired = false;
|
|
|
|
checkSpawnArrowInPlayerHand ();
|
|
} else {
|
|
mainPlayerController.setCurrentStrafeIDValue (regularBowMovementID);
|
|
|
|
if (activateStrafeOnlyWhenAimingBow || (mainPlayerCameraLocated && mainPlayerCamera.is2_5ViewActive ())) {
|
|
mainPlayerController.activateOrDeactivateStrafeMode (false);
|
|
}
|
|
|
|
setPositionToPlaceArrowActiveState (false);
|
|
|
|
fireArrowWithoutAimActive = false;
|
|
}
|
|
|
|
if (useUpperBodyRotationSystemToAim) {
|
|
mainUpperBodyRotationSystem.enableOrDisableIKUpperBody (bowLoadedActive);
|
|
|
|
checkUpperBodyRotationSystemValues (bowLoadedActive);
|
|
} else {
|
|
if (bowLoadedActive) {
|
|
mainHeadTrack.setCameraBodyWeightValue (headTrackBodyWeightOnAim);
|
|
} else {
|
|
mainHeadTrack.setOriginalCameraBodyWeightValue ();
|
|
}
|
|
}
|
|
|
|
mainHeadTrack.setHeadTrackActiveWhileAimingState (bowLoadedActive);
|
|
|
|
mainHeadTrack.setCanUseHeadTrackOnLockedCameraActiveState (bowLoadedActive);
|
|
|
|
if (activateAimingStateOnPlayerControllerEnabled) {
|
|
mainPlayerController.enableOrDisableAiminig (bowLoadedActive);
|
|
}
|
|
|
|
if (useUpperBodyRotationSystemToAim) {
|
|
checkSetExtraRotationCoroutine (bowLoadedActive);
|
|
}
|
|
|
|
setAimBowState (bowLoadedActive);
|
|
|
|
stopCancelBowStateCoroutine ();
|
|
|
|
cancelBowCoroutineActive = false;
|
|
|
|
checkEventOnMaxPullBowMultiplierStartOrEnd (false);
|
|
}
|
|
|
|
void checkUpperBodyRotationSystemValues (bool state)
|
|
{
|
|
if (setNewUpperBodyRotationValues) {
|
|
if (state) {
|
|
mainUpperBodyRotationSystem.setHorizontalBendingMultiplierValue (horizontalBendingMultiplier);
|
|
|
|
mainUpperBodyRotationSystem.setVerticalBendingMultiplierValue (verticalBendingMultiplier);
|
|
} else {
|
|
mainUpperBodyRotationSystem.setOriginalHorizontalBendingMultiplier ();
|
|
|
|
mainUpperBodyRotationSystem.setOriginalVerticalBendingMultiplier ();
|
|
}
|
|
}
|
|
}
|
|
|
|
int lastAmountOfFiredProjectiles;
|
|
|
|
public void resetLastAmountOfFiredProjectiles ()
|
|
{
|
|
lastAmountOfFiredProjectiles = 0;
|
|
}
|
|
|
|
public int getLastAmountOfFiredProjectiles ()
|
|
{
|
|
return lastAmountOfFiredProjectiles;
|
|
}
|
|
|
|
public void fireLoadedArrow ()
|
|
{
|
|
if (bowActive && bowLoadedActive) {
|
|
mainPlayerActionSystem.activateCustomAction (fireArrowActionName);
|
|
|
|
arrowIsFired = true;
|
|
|
|
lastTimeShootArrow = Time.unscaledTime;
|
|
|
|
eventOnFireArrow.Invoke ();
|
|
|
|
// setPullBowState (false);
|
|
|
|
if (arrowsManagedByInventory) {
|
|
if (checkArrowsOnInventory) {
|
|
mainArrowManager.useArrowFromInventory (1);
|
|
|
|
checkIfArrowsFoundOnInventoryToCancelBowState ();
|
|
}
|
|
}
|
|
|
|
mainGrabbedObjectMeleeAttackSystem.checkDurabilityOnAttackOnCurrentWeapon (ignoreDurability, generalAttackDurabilityMultiplier);
|
|
|
|
lastAmountOfFiredProjectiles++;
|
|
}
|
|
}
|
|
|
|
public void checkIfArrowsFoundOnInventoryToCancelBowState ()
|
|
{
|
|
if (arrowsManagedByInventory) {
|
|
if (checkArrowsOnInventory) {
|
|
mainArrowManager.checkIfArrowsFoundOnInventory ();
|
|
|
|
if (!arrowsAvailableToFire) {
|
|
// cancelBowState ();
|
|
|
|
stopCancelBowStateCoroutine ();
|
|
|
|
cancelBowStateCoroutine = StartCoroutine (activatCancelBowStateCoroutine ());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void stopCancelBowStateCoroutine ()
|
|
{
|
|
if (cancelBowStateCoroutine != null) {
|
|
StopCoroutine (cancelBowStateCoroutine);
|
|
}
|
|
|
|
cancelBowCoroutineActive = false;
|
|
}
|
|
|
|
IEnumerator activatCancelBowStateCoroutine ()
|
|
{
|
|
cancelBowCoroutineActive = true;
|
|
|
|
yield return new WaitForSecondsRealtime (cancelBowStateOnEmptyArrowsWaitDelay);
|
|
|
|
cancelBowCoroutineActive = false;
|
|
|
|
cancelBowState ();
|
|
}
|
|
|
|
public void activateLoadBowAction ()
|
|
{
|
|
if (!aimingBowActive) {
|
|
if (showDebugPrint) {
|
|
print ("no aiming active, cancelling load bow action");
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if (arrowsManagedByInventory) {
|
|
if (checkArrowsOnInventory) {
|
|
mainArrowManager.checkIfArrowsFoundOnInventory ();
|
|
|
|
if (!arrowsAvailableToFire) {
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
mainPlayerActionSystem.activateCustomAction (loadArrowActionName);
|
|
}
|
|
|
|
public void setAimBowState (bool state)
|
|
{
|
|
if (bowActive) {
|
|
aimingBowActive = state;
|
|
|
|
mainGrabbedObjectMeleeAttackSystem.setAimBowState (state);
|
|
|
|
if (aimingBowActive) {
|
|
eventOnStartAim.Invoke ();
|
|
|
|
checkBowEventOnStartAim ();
|
|
} else {
|
|
eventOnEndAim.Invoke ();
|
|
|
|
checkBowEventOnEndAim ();
|
|
}
|
|
|
|
if (!fireArrowWithoutAimActive) {
|
|
checkCameraState (state);
|
|
}
|
|
|
|
if (activateBowCollisionWhenAiming) {
|
|
mainGrabbedObjectMeleeAttackSystem.setGrabbedObjectClonnedColliderEnabledState (aimingBowActive);
|
|
}
|
|
|
|
if (activateBulletTimeOnAir) {
|
|
setTimeBulletOnBowSystem (aimingBowActive);
|
|
} else {
|
|
stopCheckIfPlayerOnGroundCoroutine ();
|
|
|
|
checOnGrounCoroutine = StartCoroutine (checkIfPlayerOnGroundCoroutine (false));
|
|
}
|
|
}
|
|
}
|
|
|
|
bool ignorePlayerOnGroundCheckOnTimeBulletActive;
|
|
|
|
public void setTimeBulletOnBowSystemExternally (bool state)
|
|
{
|
|
if (useBulletTimeOnBowExternallyEnabled) {
|
|
if (bowActive || (bulletTimeOnAirActive && !state)) {
|
|
ignorePlayerOnGroundCheckOnTimeBulletActive = true;
|
|
|
|
setTimeBulletOnBowSystem (state);
|
|
|
|
ignorePlayerOnGroundCheckOnTimeBulletActive = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
void setTimeBulletOnBowSystem (bool state)
|
|
{
|
|
if (state) {
|
|
if (!mainPlayerController.isPlayerOnGround () || ignorePlayerOnGroundCheckOnTimeBulletActive) {
|
|
GKC_Utils.activateTimeBulletXSeconds (0, bulletTimeScale);
|
|
|
|
bulletTimeOnAirActive = true;
|
|
|
|
if (!ignorePlayerOnGroundCheckOnTimeBulletActive) {
|
|
stopCheckIfPlayerOnGroundCoroutine ();
|
|
|
|
checOnGrounCoroutine = StartCoroutine (checkIfPlayerOnGroundCoroutine (true));
|
|
}
|
|
|
|
if (animationSpeedOnBulletTime != 1) {
|
|
mainPlayerController.setReducedVelocity (animationSpeedOnBulletTime);
|
|
}
|
|
|
|
checkEventOnBulletTimeState (true);
|
|
}
|
|
} else {
|
|
if (bulletTimeOnAirActive) {
|
|
GKC_Utils.activateTimeBulletXSeconds (0, 1);
|
|
|
|
bulletTimeOnAirActive = false;
|
|
|
|
if (animationSpeedOnBulletTime != 1) {
|
|
mainPlayerController.setNormalVelocity ();
|
|
}
|
|
|
|
if (reduceGravityMultiplerOnBulletTimeOnAir) {
|
|
mainPlayerController.setGravityMultiplierValue (true, 0);
|
|
}
|
|
|
|
checkEventOnBulletTimeState (false);
|
|
}
|
|
}
|
|
}
|
|
|
|
void checkEventOnBulletTimeState (bool state)
|
|
{
|
|
if (useEventOnBulletTime) {
|
|
if (state) {
|
|
eventOnBulletTimeStart.Invoke ();
|
|
} else {
|
|
eventOnBulletTimeEnd.Invoke ();
|
|
}
|
|
}
|
|
}
|
|
public void setBowActiveState (bool state)
|
|
{
|
|
if (bowActive == state) {
|
|
return;
|
|
}
|
|
|
|
bowActive = state;
|
|
|
|
if (bowActive) {
|
|
mainPlayerCameraLocated = mainPlayerCamera != null;
|
|
|
|
if (useDrawHolsterActionAnimations && !ignoreUseDrawHolsterActionAnimations) {
|
|
if (Time.unscaledTime > mainGrabbedObjectMeleeAttackSystem.getLastTimeObjectReturn () + 0.7f &&
|
|
!mainGrabbedObjectMeleeAttackSystem.isCurrentWeaponThrown ()) {
|
|
|
|
mainPlayerActionSystem.activateCustomAction (drawBowActionName);
|
|
}
|
|
}
|
|
|
|
eventOnBowEnabled.Invoke ();
|
|
|
|
Transform currentGrabbedObjectTransform = mainGrabbedObjectMeleeAttackSystem.getCurrentGrabbedObjectTransform ();
|
|
|
|
if (currentGrabbedObjectTransform == null) {
|
|
|
|
return;
|
|
}
|
|
|
|
currentBowHolderSystem = currentGrabbedObjectTransform.GetComponent<bowHolderSystem> ();
|
|
|
|
currentBowDurabilityInfo = currentGrabbedObjectTransform.GetComponent<durabilityInfo> ();
|
|
|
|
currentBowWeaponID = currentBowHolderSystem.getBowWeaponID ();
|
|
|
|
if (resetArrowIndexOnBowStateChangeEnabled) {
|
|
currentMultipleArrowTypeIndex = 0;
|
|
} else {
|
|
if (currentBowHolderSystem.canUseMultipleArrowType) {
|
|
if (currentBowHolderSystem.bowWeaponIDList.Count > 0) {
|
|
if (currentMultipleArrowTypeIndex >= currentBowHolderSystem.bowWeaponIDList.Count) {
|
|
currentMultipleArrowTypeIndex = 0;
|
|
}
|
|
|
|
currentBowWeaponID = currentBowHolderSystem.bowWeaponIDList [currentMultipleArrowTypeIndex];
|
|
} else {
|
|
currentMultipleArrowTypeIndex = 0;
|
|
}
|
|
} else {
|
|
currentMultipleArrowTypeIndex = 0;
|
|
}
|
|
}
|
|
|
|
setCurrentBowWeaponSystemByID (currentBowWeaponID);
|
|
|
|
if (arrowsManagedByInventory) {
|
|
if (checkArrowsOnInventory) {
|
|
mainArrowManager.updateArrowAmountText ();
|
|
|
|
mainArrowManager.checkIfArrowsFoundOnInventory ();
|
|
}
|
|
}
|
|
} else {
|
|
bool canPlayHolsterAction = true;
|
|
|
|
if (mainPlayerController.isActionActive ()) {
|
|
if (!mainPlayerController.canPlayerMove ()) {
|
|
canPlayHolsterAction = false;
|
|
}
|
|
} else {
|
|
if (!mainPlayerController.canPlayerMove ()) {
|
|
canPlayHolsterAction = false;
|
|
}
|
|
}
|
|
|
|
// print (canPlayHolsterAction);
|
|
|
|
if (currentBowDurabilityInfo != null) {
|
|
if (currentBowDurabilityInfo.isDurabilityEmpty ()) {
|
|
canPlayHolsterAction = false;
|
|
}
|
|
}
|
|
|
|
if (canPlayHolsterAction) {
|
|
if (useDrawHolsterActionAnimations && !ignoreUseDrawHolsterActionAnimations) {
|
|
if (Time.unscaledTime > mainGrabbedObjectMeleeAttackSystem.getLastTimeObjectThrown () + 0.7f &&
|
|
!mainGrabbedObjectMeleeAttackSystem.isCurrentWeaponThrown ()) {
|
|
|
|
mainPlayerActionSystem.activateCustomAction (holsterBowActionName);
|
|
}
|
|
}
|
|
}
|
|
|
|
eventOnBowDisabled.Invoke ();
|
|
|
|
if (bowLoadedActive) {
|
|
if (arrowIsFired) {
|
|
mainPlayerActionSystem.stopCustomAction (loadArrowActionName);
|
|
}
|
|
|
|
if (useUpperBodyRotationSystemToAim) {
|
|
mainUpperBodyRotationSystem.enableOrDisableIKUpperBody (false);
|
|
|
|
checkUpperBodyRotationSystemValues (false);
|
|
} else {
|
|
mainHeadTrack.setOriginalCameraBodyWeightValue ();
|
|
}
|
|
|
|
mainHeadTrack.setHeadTrackActiveWhileAimingState (false);
|
|
|
|
mainHeadTrack.setCanUseHeadTrackOnLockedCameraActiveState (false);
|
|
|
|
if (activateAimingStateOnPlayerControllerEnabled) {
|
|
mainPlayerController.enableOrDisableAiminig (false);
|
|
}
|
|
|
|
if (useUpperBodyRotationSystemToAim) {
|
|
checkSetExtraRotationCoroutine (false);
|
|
}
|
|
|
|
if (aimingBowActive && activateBowCollisionWhenAiming) {
|
|
mainGrabbedObjectMeleeAttackSystem.setGrabbedObjectClonnedColliderEnabledState (false);
|
|
}
|
|
|
|
if (activateBulletTimeOnAir) {
|
|
setTimeBulletOnBowSystem (false);
|
|
}
|
|
|
|
aimingBowActive = false;
|
|
|
|
mainGrabbedObjectMeleeAttackSystem.setAimBowState (false);
|
|
|
|
bowLoadedActive = false;
|
|
|
|
if (activateStrafeOnlyWhenAimingBow || (mainPlayerCameraLocated && mainPlayerCamera.is2_5ViewActive ())) {
|
|
mainPlayerController.activateOrDeactivateStrafeMode (false);
|
|
}
|
|
|
|
eventOnEndAim.Invoke ();
|
|
|
|
checkBowEventOnEndAim ();
|
|
|
|
checkCameraState (false);
|
|
|
|
if (lastTimePullBow == 0 || !mainGrabbedObjectMeleeAttackSystem.isCarryingObject ()) {
|
|
if (showDebugPrint) {
|
|
print ("cancel bow action");
|
|
}
|
|
|
|
checkEventOnCancelBowAction ();
|
|
}
|
|
|
|
checkEventOnMaxPullBowMultiplierStartOrEnd (false);
|
|
}
|
|
|
|
setPositionToPlaceArrowActiveState (false);
|
|
|
|
currentBowHolderSystem = null;
|
|
|
|
currentBowDurabilityInfo = null;
|
|
|
|
if (arrowsManagedByInventory) {
|
|
if (checkArrowsOnInventory) {
|
|
mainArrowManager.enableOrDisableArrowInfoPanel (bowActive);
|
|
}
|
|
}
|
|
|
|
if (currentSimpleWeaponSystem != null) {
|
|
currentSimpleWeaponSystem.enabled = false;
|
|
}
|
|
}
|
|
|
|
aimInputPressedDown = false;
|
|
|
|
stopUpdateBowStateCoroutine ();
|
|
|
|
if (bowActive) {
|
|
updateBowCoroutine = StartCoroutine (updateBowStateCoroutine ());
|
|
}
|
|
|
|
if (!bowActive) {
|
|
if (pauseMoveInputActive) {
|
|
mainPlayerController.setMoveInputPausedState (false);
|
|
|
|
pauseMoveInputActive = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void cancelBowLoadedStateIfActive ()
|
|
{
|
|
if (bowActive) {
|
|
cancelBowState ();
|
|
|
|
aimInputPressedDown = false;
|
|
}
|
|
}
|
|
|
|
public void cancelBowState ()
|
|
{
|
|
if (bowLoadedActive) {
|
|
setBowLoadedState (false);
|
|
}
|
|
}
|
|
|
|
//if the player is in aim mode, enable the upper body to rotate with the camera movement
|
|
public void checkSetExtraRotationCoroutine (bool state)
|
|
{
|
|
if (changeExtraRotation != null) {
|
|
StopCoroutine (changeExtraRotation);
|
|
}
|
|
|
|
changeExtraRotation = StartCoroutine (setExtraRotation (state));
|
|
}
|
|
|
|
IEnumerator setExtraRotation (bool state)
|
|
{
|
|
if (extraUpperBodyRotation != 0 || (!state && targetRotation != extraUpperBodyRotation)) {
|
|
for (float t = 0; t < 1;) {
|
|
t += Time.unscaledDeltaTime;
|
|
|
|
if (state) {
|
|
targetRotation = Mathf.Lerp (targetRotation, extraUpperBodyRotation, t);
|
|
} else {
|
|
targetRotation = Mathf.Lerp (targetRotation, 0, t);
|
|
}
|
|
|
|
mainUpperBodyRotationSystem.setCurrentBodyRotation (targetRotation);
|
|
|
|
yield return null;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void stopCheckIfPlayerOnGroundCoroutine ()
|
|
{
|
|
if (checOnGrounCoroutine != null) {
|
|
StopCoroutine (checOnGrounCoroutine);
|
|
}
|
|
}
|
|
|
|
IEnumerator checkIfPlayerOnGroundCoroutine (bool checkBulletTime)
|
|
{
|
|
bool targetReached = false;
|
|
|
|
bool checkGravityMultiplier = false;
|
|
|
|
float lastTimeGravityMultiplierChecked = Time.unscaledTime;
|
|
|
|
while (!targetReached) {
|
|
|
|
if (checkBulletTime) {
|
|
if (reduceGravityMultiplerOnBulletTimeOnAir) {
|
|
if (!checkGravityMultiplier) {
|
|
if (Time.unscaledTime > lastTimeGravityMultiplierChecked + 0.3f) {
|
|
if (reduceGravityMultiplerOnBulletTimeOnAir) {
|
|
mainPlayerController.setGravityMultiplierValue (false, gravityMultiplerOnBulletTimeOnAir);
|
|
|
|
checkGravityMultiplier = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (mainPlayerController.isPlayerOnGround ()) {
|
|
targetReached = true;
|
|
}
|
|
|
|
yield return null;
|
|
}
|
|
|
|
if (checkBulletTime) {
|
|
if (activateBulletTimeOnAir) {
|
|
setTimeBulletOnBowSystem (false);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void checkSpawnArrowInPlayerHand ()
|
|
{
|
|
if (arrowMesh == null) {
|
|
arrowMesh = (GameObject)Instantiate (arrowMeshPrefab);
|
|
arrowMesh.transform.SetParent (positionToPlaceArrow);
|
|
arrowMesh.transform.localPosition = arrowPositionReference.localPosition;
|
|
arrowMesh.transform.localRotation = arrowPositionReference.localRotation;
|
|
}
|
|
}
|
|
|
|
public void checkBowHolderLoadArrow ()
|
|
{
|
|
if (!aimingBowActive) {
|
|
if (showDebugPrint) {
|
|
print ("trying to load arrow when the bow is not being aimed, cancelling");
|
|
}
|
|
|
|
setPositionToPlaceArrowActiveState (false);
|
|
|
|
return;
|
|
}
|
|
|
|
getCurrentBowHolderSystem ();
|
|
|
|
if (currentBowHolderSystem != null) {
|
|
currentBowHolderSystem.checkEventOnLoadArrow ();
|
|
}
|
|
}
|
|
|
|
public void checkBowHolderFireArrow ()
|
|
{
|
|
getCurrentBowHolderSystem ();
|
|
|
|
if (currentBowHolderSystem != null) {
|
|
currentBowHolderSystem.checkEventOnFireArrow ();
|
|
}
|
|
}
|
|
|
|
public void checkUsePullBowMultipliersOnFireArrow ()
|
|
{
|
|
bool checkPullBowMultipliersResult = false;
|
|
|
|
if (currentBowWeaponSystemInfo != null && currentBowWeaponSystemInfo.usePullBowMultipliers) {
|
|
checkPullBowMultipliersResult = true;
|
|
}
|
|
|
|
if (checkPullBowMultipliersResult) {
|
|
if (currentBowWeaponSystemInfo.ignorePullMultiplierIfShootingArrowWithoutAim && fireArrowWithoutAimActive) {
|
|
checkPullBowMultipliersResult = false;
|
|
}
|
|
}
|
|
|
|
if (checkPullBowMultipliersResult) {
|
|
if (lastTimePullBow > 0 && currentSimpleWeaponSystem != null) {
|
|
float timeTime = Time.unscaledTime;
|
|
|
|
if (showDebugPrint) {
|
|
print ("bow hold time " + (timeTime - lastTimePullBow));
|
|
}
|
|
|
|
float totalPullBowForce = (timeTime - lastTimePullBow) / currentBowWeaponSystemInfo.pullBowForceRateMultiplier;
|
|
|
|
totalPullBowForce = currentBowWeaponSystemInfo.initialPullBowForceRateMultiplier - totalPullBowForce;
|
|
|
|
if (totalPullBowForce <= 0) {
|
|
totalPullBowForce = 1;
|
|
}
|
|
|
|
|
|
float totalPullBowDamageMultiplier = (timeTime - lastTimePullBow) * currentBowWeaponSystemInfo.pullBowDamageRateMultiplier;
|
|
|
|
totalPullBowDamageMultiplier += 1;
|
|
|
|
totalPullBowDamageMultiplier = Mathf.Clamp (totalPullBowDamageMultiplier, 1, currentBowWeaponSystemInfo.maxPullBowDamageRateMultiplier);
|
|
|
|
if (showDebugPrint) {
|
|
print ("total pull down force " + totalPullBowForce + " total damage multiplier " + totalPullBowDamageMultiplier);
|
|
}
|
|
|
|
List<projectileSystem> lastProjectilesSystemListFired = currentSimpleWeaponSystem.getLastProjectilesSystemListFired ();
|
|
|
|
if (lastProjectilesSystemListFired.Count > 0) {
|
|
for (int i = 0; i < lastProjectilesSystemListFired.Count; i++) {
|
|
|
|
if (lastProjectilesSystemListFired [i] != null) {
|
|
if (showDebugPrint) {
|
|
print ("setting projectile info");
|
|
}
|
|
|
|
lastProjectilesSystemListFired [i].setProjectileDamageMultiplier (totalPullBowDamageMultiplier);
|
|
|
|
arrowProjectile currentArrowProjectile = lastProjectilesSystemListFired [i].gameObject.GetComponent<arrowProjectile> ();
|
|
|
|
if (currentArrowProjectile != null) {
|
|
|
|
currentArrowProjectile.setNewArrowDownForce (totalPullBowForce);
|
|
|
|
if (currentBowWeaponSystemInfo.checkSurfaceTypeDetected) {
|
|
currentArrowProjectile.setArrowSurfaceTypeInfoList (currentBowWeaponSystemInfo.arrowSurfaceTypeInfoList);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
checkEventOnMaxPullBowMultiplierStartOrEnd (false);
|
|
}
|
|
}
|
|
|
|
void checkEventOnMaxPullBowMultiplierStartOrEnd (bool state)
|
|
{
|
|
if (state) {
|
|
if (!currentBowWeaponSystemInfo.eventOnMaxPullBowMultiplierActivated) {
|
|
if (Time.unscaledTime > lastTimePullBow + currentBowWeaponSystemInfo.pullBowMultiplierDelay) {
|
|
currentBowWeaponSystemInfo.eventOnMaxPullBowMultiplierStart.Invoke ();
|
|
|
|
currentBowHolderSystem.checkEventOnMaxPullBowMultiplierStart ();
|
|
|
|
currentBowWeaponSystemInfo.eventOnMaxPullBowMultiplierActivated = true;
|
|
|
|
if (showDebugPrint) {
|
|
print ("checkEventOnMaxPullBowMultiplierStartOrEnd true");
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
if (currentBowWeaponSystemInfo.eventOnMaxPullBowMultiplierActivated) {
|
|
currentBowWeaponSystemInfo.eventOnMaxPullBowMultiplierEnd.Invoke ();
|
|
|
|
currentBowHolderSystem.checkEventOnMaxPullBowMultiplierEnd ();
|
|
|
|
currentBowWeaponSystemInfo.eventOnMaxPullBowMultiplierActivated = false;
|
|
|
|
if (showDebugPrint) {
|
|
print ("checkEventOnMaxPullBowMultiplierStartOrEnd false");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void checkBowEventOnStartAim ()
|
|
{
|
|
getCurrentBowHolderSystem ();
|
|
|
|
if (currentBowHolderSystem != null) {
|
|
currentBowHolderSystem.checkEventOnStartAim ();
|
|
}
|
|
}
|
|
|
|
public void checkBowEventOnEndAim ()
|
|
{
|
|
getCurrentBowHolderSystem ();
|
|
|
|
if (currentBowHolderSystem != null) {
|
|
currentBowHolderSystem.checkEventOnEndAim ();
|
|
}
|
|
}
|
|
|
|
public void checkEventOnCancelBowAction ()
|
|
{
|
|
getCurrentBowHolderSystem ();
|
|
|
|
if (currentBowHolderSystem != null) {
|
|
currentBowHolderSystem.checkEventOnCancelBowAction ();
|
|
}
|
|
}
|
|
|
|
void getCurrentBowHolderSystem ()
|
|
{
|
|
if (currentBowHolderSystem == null) {
|
|
currentBowHolderSystem = mainPlayerController.GetComponentInChildren<bowHolderSystem> ();
|
|
|
|
if (currentBowHolderSystem != null) {
|
|
currentBowDurabilityInfo = currentBowHolderSystem.gameObject.GetComponent<durabilityInfo> ();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setCurrentBowWeaponSystemByID (int bowWeaponID)
|
|
{
|
|
for (int i = 0; i < bowWeaponSystemInfoList.Count; i++) {
|
|
if (bowWeaponSystemInfoList [i].bowWeaponID == bowWeaponID) {
|
|
currentBowWeaponSystemInfo = bowWeaponSystemInfoList [i];
|
|
|
|
currentBowWeaponSystemInfo.isCurrentBowWeapon = true;
|
|
|
|
currentSimpleWeaponSystem = currentBowWeaponSystemInfo.mainSimpleWeaponSystem;
|
|
|
|
currentSimpleWeaponSystem.enabled = true;
|
|
|
|
if (useCustomIgnoreTags) {
|
|
currentSimpleWeaponSystem.setCustomTagsToIgnore (customTagsToIgnoreList);
|
|
}
|
|
|
|
currentBowWeaponID = bowWeaponID;
|
|
|
|
currentMultipleArrowTypeIndex = currentBowHolderSystem.bowWeaponIDList.IndexOf (currentBowWeaponID);
|
|
|
|
if (currentMultipleArrowTypeIndex < 0) {
|
|
currentMultipleArrowTypeIndex = currentBowWeaponID;
|
|
}
|
|
|
|
mainArrowManager.enableOrDisableArrowInfoPanel (currentBowWeaponSystemInfo.showArrowTypeIcon);
|
|
|
|
mainArrowManager.setArrowTypeIcon (currentBowWeaponSystemInfo.bowIcon, !currentBowWeaponSystemInfo.checkArrowsOnInventory);
|
|
|
|
if (arrowsManagedByInventory) {
|
|
checkArrowsOnInventory = currentBowWeaponSystemInfo.checkArrowsOnInventory;
|
|
|
|
if (checkArrowsOnInventory) {
|
|
mainArrowManager.setCurrentArrowInventoryObjectName (currentBowWeaponSystemInfo.arrowInventoryObjectName);
|
|
}
|
|
}
|
|
|
|
if (currentBowWeaponSystemInfo.useEventOnBowSelected) {
|
|
currentBowWeaponSystemInfo.eventOnBowSelected.Invoke ();
|
|
}
|
|
} else {
|
|
if (bowWeaponSystemInfoList [i].isCurrentBowWeapon) {
|
|
if (bowWeaponSystemInfoList [i].useEventOnBowSelected) {
|
|
bowWeaponSystemInfoList [i].eventOnBowUnselected.Invoke ();
|
|
}
|
|
|
|
bowWeaponSystemInfoList [i].mainSimpleWeaponSystem.enabled = false;
|
|
}
|
|
|
|
bowWeaponSystemInfoList [i].isCurrentBowWeapon = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void fireCurrentBowWeapon ()
|
|
{
|
|
if (bowActive) {
|
|
currentSimpleWeaponSystem.inputShootWeaponOnPressDown ();
|
|
|
|
currentSimpleWeaponSystem.inputShootWeaponOnPressUp ();
|
|
}
|
|
}
|
|
|
|
public void setPullBowState (bool state)
|
|
{
|
|
bool checkPullBowMultipliersResult = false;
|
|
|
|
if (currentBowWeaponSystemInfo != null && currentBowWeaponSystemInfo.usePullBowMultipliers) {
|
|
checkPullBowMultipliersResult = true;
|
|
}
|
|
|
|
if (checkPullBowMultipliersResult) {
|
|
if (currentBowWeaponSystemInfo.ignorePullMultiplierIfShootingArrowWithoutAim && fireArrowWithoutAimActive) {
|
|
checkPullBowMultipliersResult = false;
|
|
}
|
|
}
|
|
|
|
if (checkPullBowMultipliersResult) {
|
|
if (state) {
|
|
if (showDebugPrint) {
|
|
print ("start to pull");
|
|
}
|
|
|
|
lastTimePullBow = Time.unscaledTime;
|
|
|
|
if (showDebugPrint) {
|
|
print ("set pull bow state true");
|
|
}
|
|
|
|
checkEventOnMaxPullBowMultiplierStartOrEnd (false);
|
|
} else {
|
|
lastTimePullBow = 0;
|
|
}
|
|
} else {
|
|
if (state) {
|
|
lastTimePullBow = Time.unscaledTime;
|
|
} else {
|
|
lastTimePullBow = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setArrowsAvailableToFireState (bool state)
|
|
{
|
|
arrowsAvailableToFire = state;
|
|
}
|
|
|
|
public void setPositionToPlaceArrowActiveState (bool state)
|
|
{
|
|
if (positionToPlaceArrow.gameObject.activeSelf != state) {
|
|
positionToPlaceArrow.gameObject.SetActive (state);
|
|
}
|
|
}
|
|
|
|
public bool canUseWeaponsInput ()
|
|
{
|
|
if (mainPlayerController.canPlayerMove () && !mainPlayerController.playerIsBusy ()) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void checkCameraState (bool state)
|
|
{
|
|
if (mainPlayerCamera == null) {
|
|
return;
|
|
}
|
|
|
|
bool isFirstPersonActive = mainPlayerController.isPlayerOnFirstPerson ();
|
|
|
|
bool isFullBodyAwarenessActive = mainPlayerCamera.isFullBodyAwarenessActive ();
|
|
|
|
bool canChangeViewResult = false;
|
|
|
|
if (!isFirstPersonActive) {
|
|
if (isFullBodyAwarenessActive) {
|
|
if (setNewCameraStateOnFBA) {
|
|
canChangeViewResult = true;
|
|
}
|
|
} else {
|
|
if (setNewCameraStateOnThirdPerson) {
|
|
canChangeViewResult = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (canChangeViewResult) {
|
|
if (state) {
|
|
previousCameraState = mainPlayerCamera.getCurrentStateName ();
|
|
|
|
if (isFullBodyAwarenessActive) {
|
|
if (setNewCameraStateOnFBA) {
|
|
mainPlayerCamera.setCameraState (newCameraStateOnFBA);
|
|
}
|
|
} else {
|
|
mainPlayerCamera.setCameraStateOnlyOnThirdPerson (newCameraStateOnThirdPerson);
|
|
}
|
|
} else {
|
|
|
|
if (previousCameraState != "") {
|
|
if (isFullBodyAwarenessActive) {
|
|
if (previousCameraState != newCameraStateOnFBA) {
|
|
mainPlayerCamera.setCameraState (previousCameraState);
|
|
}
|
|
} else {
|
|
if (previousCameraState != newCameraStateOnThirdPerson) {
|
|
mainPlayerCamera.setCameraStateOnlyOnThirdPerson (previousCameraState);
|
|
}
|
|
}
|
|
|
|
previousCameraState = "";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void setAimState (bool state)
|
|
{
|
|
if (bowActive) {
|
|
if (showDebugPrint) {
|
|
print ("input aim bow " + state + " " + bowActive);
|
|
}
|
|
|
|
if (!canUseWeaponsInput ()) {
|
|
if (state) {
|
|
return;
|
|
} else {
|
|
if (!aimInputPressedDown) {
|
|
print ("no input down pressed before, cancelling");
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!bowLoadedActive && state) {
|
|
if (arrowsManagedByInventory) {
|
|
mainArrowManager.checkIfArrowsFoundOnInventory ();
|
|
|
|
if (!arrowsAvailableToFire) {
|
|
if (currentSimpleWeaponSystem != null && bowWeaponSystemInfoList [currentMultipleArrowTypeIndex].checkArrowsOnInventory) {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
if (!state && !bowLoadedActive) {
|
|
if (arrowsManagedByInventory) {
|
|
mainArrowManager.checkIfArrowsFoundOnInventory ();
|
|
|
|
if (!arrowsAvailableToFire) {
|
|
if (showDebugPrint) {
|
|
print ("no arrows available when releasing the aim button");
|
|
}
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
aimInputPressedDown = state;
|
|
|
|
bool bowLoadedButNotFired = bowLoadedActive && !arrowIsFired;
|
|
|
|
if (bowLoadedButNotFired) {
|
|
if (showDebugPrint) {
|
|
print ("bow loaded but not fired");
|
|
}
|
|
|
|
mainPlayerActionSystem.stopCustomActionIfCurrentlyActive (loadArrowActionName);
|
|
|
|
eventOnCancelLoadBowOnStopAim.Invoke ();
|
|
}
|
|
|
|
setBowLoadedState (state);
|
|
|
|
lastTimeAimBow = Time.unscaledTime;
|
|
|
|
lastTimePullBow = 0;
|
|
|
|
if (!state) {
|
|
setPositionToPlaceArrowActiveState (false);
|
|
}
|
|
|
|
if (showDebugPrint) {
|
|
print ("aim " + state);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setIgnoreUseDrawHolsterActionAnimationsState (bool state)
|
|
{
|
|
ignoreUseDrawHolsterActionAnimations = state;
|
|
}
|
|
|
|
public void setUseDrawHolsterActionAnimationsState (bool state)
|
|
{
|
|
useDrawHolsterActionAnimations = state;
|
|
}
|
|
|
|
public void setArrowsManagedByInventoryState (bool state)
|
|
{
|
|
arrowsManagedByInventory = state;
|
|
}
|
|
|
|
public void setOriginalArrowsManagedByInventoryState ()
|
|
{
|
|
setArrowsManagedByInventoryState (originalArrowsManagedByInventory);
|
|
}
|
|
|
|
public bool isAimingBowActive ()
|
|
{
|
|
return aimingBowActive;
|
|
}
|
|
|
|
//INPUT FUNCTIONS
|
|
public void inputSetAimBowState (bool state)
|
|
{
|
|
if (!bowActive) {
|
|
return;
|
|
}
|
|
|
|
if (state) {
|
|
|
|
if (mainPlayerController.isCrouching ()) {
|
|
mainPlayerController.crouch ();
|
|
|
|
if (mainPlayerController.isCrouching ()) {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (fireArrowWithoutAimActive) {
|
|
checkCameraState (true);
|
|
|
|
if (state) {
|
|
aimInputPressedOnFireArrowWithoutAim = true;
|
|
}
|
|
} else {
|
|
setAimState (state);
|
|
}
|
|
|
|
fireArrowWithoutAimActive = false;
|
|
|
|
stopAimAfterFiringArrowWithoutAimActive = false;
|
|
|
|
if (!state) {
|
|
aimInputPressedOnFireArrowWithoutAim = false;
|
|
}
|
|
}
|
|
|
|
public void inputFireArrow ()
|
|
{
|
|
if (bowActive) {
|
|
if (!canUseWeaponsInput ()) {
|
|
return;
|
|
}
|
|
|
|
if (Time.unscaledTime > minTimeToShootArrows + lastTimeShootArrow &&
|
|
Time.unscaledTime > lastTimeAimBow + minTimeToAimBow && lastTimePullBow > 0 && bowLoadedActive) {
|
|
|
|
fireLoadedArrow ();
|
|
|
|
if (showDebugPrint) {
|
|
print ("fire");
|
|
}
|
|
|
|
if (showDebugPrint) {
|
|
print ("bowLoadedActive " + bowLoadedActive);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if (canFireBowWithoutAimEnabled && !bowLoadedActive) {
|
|
fireArrowWithoutAimActive = true;
|
|
|
|
lastTimeCheckFireArrowWithoutAim = Time.unscaledTime;
|
|
|
|
setAimState (true);
|
|
|
|
if (setCameraStateIfNoAimInputUsedEnabled) {
|
|
checkCameraState (true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void inputStopFireArrowWithoutAim ()
|
|
{
|
|
if (bowActive) {
|
|
if (fireArrowWithoutAimActive) {
|
|
if (!aimInputPressedOnFireArrowWithoutAim) {
|
|
setAimState (false);
|
|
}
|
|
|
|
lastTimeCheckFireArrowWithoutAim = 0;
|
|
|
|
fireArrowWithoutAimActive = false;
|
|
|
|
stopAimAfterFiringArrowWithoutAimActive = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void inputChangeArrowType ()
|
|
{
|
|
if (bowActive) {
|
|
if (!canUseWeaponsInput ()) {
|
|
return;
|
|
}
|
|
|
|
if (aimingBowActive) {
|
|
return;
|
|
}
|
|
|
|
if (currentBowHolderSystem.canUseMultipleArrowType) {
|
|
|
|
currentMultipleArrowTypeIndex++;
|
|
|
|
if (currentMultipleArrowTypeIndex >= currentBowHolderSystem.bowWeaponIDList.Count) {
|
|
currentMultipleArrowTypeIndex = 0;
|
|
}
|
|
|
|
setCurrentBowWeaponSystemByID (currentBowHolderSystem.bowWeaponIDList [currentMultipleArrowTypeIndex]);
|
|
|
|
if (arrowsManagedByInventory) {
|
|
if (checkArrowsOnInventory) {
|
|
mainArrowManager.updateArrowAmountText ();
|
|
|
|
mainArrowManager.checkIfArrowsFoundOnInventory ();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void inputSetTimeBulletOnBowSystem (bool state)
|
|
{
|
|
if (bowActive) {
|
|
if (!canUseWeaponsInput ()) {
|
|
return;
|
|
}
|
|
|
|
setTimeBulletOnBowSystemExternally (state);
|
|
}
|
|
}
|
|
|
|
public void inputToggleTimeBulletOnBowSystem ()
|
|
{
|
|
inputSetTimeBulletOnBowSystem (!bulletTimeOnAirActive);
|
|
}
|
|
|
|
public void changeArrowTypeByIndex (int newIndex)
|
|
{
|
|
if (currentBowHolderSystem != null) {
|
|
if (currentBowHolderSystem.canUseMultipleArrowType) {
|
|
|
|
currentMultipleArrowTypeIndex = newIndex;
|
|
|
|
if (currentMultipleArrowTypeIndex >= currentBowHolderSystem.bowWeaponIDList.Count) {
|
|
currentMultipleArrowTypeIndex = 0;
|
|
}
|
|
|
|
setCurrentBowWeaponSystemByID (currentBowHolderSystem.bowWeaponIDList [currentMultipleArrowTypeIndex]);
|
|
|
|
if (arrowsManagedByInventory) {
|
|
if (checkArrowsOnInventory) {
|
|
mainArrowManager.updateArrowAmountText ();
|
|
|
|
mainArrowManager.checkIfArrowsFoundOnInventory ();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setUseUpperBodyRotationSystemToAimState (bool state)
|
|
{
|
|
useUpperBodyRotationSystemToAim = state;
|
|
}
|
|
|
|
|
|
//EDITOR FUNCTIONS
|
|
public void setUseDrawHolsterActionAnimationsStateFromEditor (bool state)
|
|
{
|
|
setUseDrawHolsterActionAnimationsState (state);
|
|
|
|
updateComponent ();
|
|
}
|
|
|
|
public void setUseUpperBodyRotationSystemToAimStateFromEditor (bool state)
|
|
{
|
|
setUseUpperBodyRotationSystemToAimState (state);
|
|
|
|
updateComponent ();
|
|
}
|
|
|
|
public void updateComponent ()
|
|
{
|
|
GKC_Utils.updateComponent (this);
|
|
|
|
GKC_Utils.updateDirtyScene ("Update Info " + gameObject.name, gameObject);
|
|
}
|
|
|
|
|
|
[System.Serializable]
|
|
public class bowWeaponSystemInfo
|
|
{
|
|
[Header ("Main Settings")]
|
|
[Space]
|
|
|
|
public string Name;
|
|
|
|
public int bowWeaponID;
|
|
|
|
public bool isCurrentBowWeapon;
|
|
|
|
[Space]
|
|
[Header ("Inventory Settings")]
|
|
[Space]
|
|
|
|
public bool checkArrowsOnInventory;
|
|
|
|
public string arrowInventoryObjectName;
|
|
|
|
[Space]
|
|
[Header ("Surface Settings")]
|
|
[Space]
|
|
|
|
public bool checkSurfaceTypeDetected;
|
|
|
|
public List<arrowSurfaceTypeInfo> arrowSurfaceTypeInfoList = new List<arrowSurfaceTypeInfo> ();
|
|
|
|
[Space]
|
|
[Header ("Other Settings")]
|
|
[Space]
|
|
|
|
public simpleWeaponSystem mainSimpleWeaponSystem;
|
|
|
|
public bool showArrowTypeIcon = true;
|
|
|
|
public Texture bowIcon;
|
|
|
|
[Space]
|
|
[Header ("Arrow Force And Damage Settings")]
|
|
[Space]
|
|
|
|
public bool usePullBowMultipliers;
|
|
|
|
public float pullBowForceRateMultiplier = 0.1f;
|
|
|
|
public float initialPullBowForceRateMultiplier = 30;
|
|
|
|
public float pullBowDamageRateMultiplier = 0.1f;
|
|
|
|
public float maxPullBowDamageRateMultiplier = 10;
|
|
|
|
public float pullBowMultiplierDelay;
|
|
|
|
public bool ignorePullMultiplierIfShootingArrowWithoutAim;
|
|
|
|
[Space]
|
|
[Header ("Events Settings")]
|
|
[Space]
|
|
|
|
public bool useEventOnBowSelected;
|
|
|
|
[Space]
|
|
|
|
public UnityEvent eventOnBowSelected;
|
|
|
|
public UnityEvent eventOnBowUnselected;
|
|
|
|
[Space]
|
|
|
|
public bool useEventOnMaxPullBowMultiplier;
|
|
|
|
[Space]
|
|
|
|
public UnityEvent eventOnMaxPullBowMultiplierStart;
|
|
|
|
public UnityEvent eventOnMaxPullBowMultiplierEnd;
|
|
|
|
[HideInInspector] public bool eventOnMaxPullBowMultiplierActivated;
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class arrowSurfaceTypeInfo
|
|
{
|
|
public string Name;
|
|
|
|
public bool isObstacle;
|
|
|
|
public bool arrowBounceOnSurface;
|
|
|
|
public bool dropArrowPickupOnBounce;
|
|
|
|
public bool addExtraForceOnBounce;
|
|
|
|
public float extraForceOnBounce;
|
|
}
|
|
}
|