2940 lines
108 KiB
C#
2940 lines
108 KiB
C#
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
using UnityEngine.Events;
|
|
|
|
public class meleeWeaponsGrabbedManager : MonoBehaviour
|
|
{
|
|
[Header ("Main Settings")]
|
|
[Space]
|
|
|
|
public bool meleeWeaponsGrabbedManagerEnabled = true;
|
|
|
|
public bool storeEachGrabbedWeapon;
|
|
|
|
public bool storeOnlyOneWeapon;
|
|
|
|
public bool canSpawnAnyWeaponStoredInfiniteTimes;
|
|
|
|
public bool storePickedWeaponsOnInventory;
|
|
|
|
public bool drawWeaponAtStartIfFoundOnInitializingInventory;
|
|
|
|
public bool numberKeysToChangeBetweenMeleeWeaponsEnabled = true;
|
|
|
|
public bool dropThrownWeaponIfChangingToAnotherWeaponEnabled;
|
|
|
|
public bool dropThrownWeaponWhenUsingDeviceEnabled;
|
|
|
|
[Space]
|
|
[Header ("Hide Weapon Meshes Settings")]
|
|
[Space]
|
|
|
|
public bool overrideOptionToHideWeaponMeshWhenNotUsed;
|
|
public bool hideWeaponMeshWhenNotUsed;
|
|
|
|
[Space]
|
|
[Header ("Start Game With Melee Weapon Settings")]
|
|
[Space]
|
|
|
|
public bool startGameWithWeapon;
|
|
|
|
public bool drawWeaponOnStartEnabled = true;
|
|
|
|
public string weaponNameToStartGame;
|
|
|
|
[Space]
|
|
[Space]
|
|
|
|
public bool startGameWithListOfWeapons;
|
|
public List<string> listOfWeaponsToStart = new List<string> ();
|
|
|
|
[Space]
|
|
|
|
public bool startWithRandomWeapon;
|
|
|
|
public bool startWithRandomWeaponFromListOfWeaponsToStart;
|
|
|
|
public bool startWithWeaponOnlyIfAlreadyAvailable;
|
|
|
|
public bool drawWeaponAtStartIfConfiguredExternally;
|
|
|
|
[Space]
|
|
[Header ("Start Game With Melee Shield Settings")]
|
|
[Space]
|
|
|
|
public bool startGameWithShield;
|
|
public string shieldNameToStartGame;
|
|
|
|
[Space]
|
|
[Header ("Weapon List")]
|
|
[Space]
|
|
|
|
public List<meleeWeaponGrabbedInfo> meleeWeaponGrabbedInfoList = new List<meleeWeaponGrabbedInfo> ();
|
|
|
|
public List<meleeWeaponPrefabInfo> meleeWeaponPrefabInfoList = new List<meleeWeaponPrefabInfo> ();
|
|
|
|
[Space]
|
|
[Header ("Shield List")]
|
|
[Space]
|
|
|
|
public List<shieldPrefabInfo> shieldPrefabInfoList = new List<shieldPrefabInfo> ();
|
|
|
|
public List<shieldGrabbedInfo> shieldGrabbedInfoList = new List<shieldGrabbedInfo> ();
|
|
|
|
[Space]
|
|
[Header ("Events Settings")]
|
|
[Space]
|
|
|
|
public bool useEventsOnStateChange;
|
|
public UnityEvent eventOnStateActive;
|
|
public UnityEvent eventOnStateDeactivate;
|
|
|
|
[Space]
|
|
|
|
public bool useEventsOnMeleeWeaponEquipped;
|
|
public UnityEvent eventOnMeleeWeaponEquipped;
|
|
|
|
[Space]
|
|
|
|
public bool useEventOnGrabDropWeapon;
|
|
public UnityEvent eventOnGrabWeapon;
|
|
public UnityEvent eventOnDropWeapon;
|
|
|
|
[Space]
|
|
[Header ("Stolen Weapon Settings")]
|
|
[Space]
|
|
|
|
public bool useEventOnWeaponStolen;
|
|
public UnityEvent eventOnWeaponStolen;
|
|
|
|
[Space]
|
|
[Header ("Save Settings")]
|
|
[Space]
|
|
|
|
public bool saveCurrentMeleeWeaponListToSaveFile = true;
|
|
|
|
[Space]
|
|
[Header ("IK Settings")]
|
|
[Space]
|
|
|
|
public bool useIKOnHands;
|
|
public bool useIKOnHandsOnlyOnFba;
|
|
|
|
public IKSystem mainIKSystem;
|
|
|
|
public OnAnimatorIKComponent handsOnMeleeWeaponIKSystem;
|
|
|
|
[Space]
|
|
[Header ("Debug")]
|
|
[Space]
|
|
|
|
public bool showDebugPrint;
|
|
|
|
public bool meleeWeaponsGrabbedManagerActive;
|
|
|
|
public int currentNumberOfWeaponsAvailable;
|
|
|
|
public int currentWeaponIndex = 0;
|
|
|
|
public bool equipMeleeWeaponPaused;
|
|
|
|
public bool currentMeleeWeaponSheathedOrCarried;
|
|
|
|
public bool isLoadingGame;
|
|
|
|
public bool carryingObject;
|
|
|
|
public bool fullBodyAwarenessActive;
|
|
|
|
[Space]
|
|
[Header ("Components")]
|
|
[Space]
|
|
|
|
public GameObject playerGameObject;
|
|
public playerInputManager playerInput;
|
|
public grabObjects mainGrabObjects;
|
|
public grabbedObjectMeleeAttackSystem mainGrabbedObjectMeleeAttackSystem;
|
|
public inventoryManager mainInventoryManager;
|
|
|
|
bool startWithWeaponChecked;
|
|
|
|
bool startWithShieldChecked;
|
|
|
|
bool drawMeleeWeaponsPaused;
|
|
|
|
shieldGrabbedInfo currentShieldGrabbedInfo;
|
|
|
|
Coroutine weaponDrawKeepAnimationCoroutine;
|
|
|
|
bool lastDroppeWeaponDurabilityStored;
|
|
float lastDroppedWeaponDurabilityValue;
|
|
string lastDroppedWeaponName;
|
|
|
|
|
|
public void initializeMeleeManagerValues ()
|
|
{
|
|
|
|
}
|
|
|
|
void Start ()
|
|
{
|
|
currentNumberOfWeaponsAvailable = getCurrentNumberOfWeaponsAvailable ();
|
|
|
|
if (playerGameObject == null) {
|
|
playerGameObject = mainGrabObjects.gameObject;
|
|
}
|
|
}
|
|
|
|
public void drawNextWeaponAvailable ()
|
|
{
|
|
getCurrentNumberOfWeaponsAvailable ();
|
|
|
|
if (currentNumberOfWeaponsAvailable > 0) {
|
|
|
|
checkMeleeWeaponToUse (meleeWeaponGrabbedInfoList [0].Name, startWithWeaponOnlyIfAlreadyAvailable);
|
|
}
|
|
}
|
|
|
|
public void drawRandomWeaponFromPrefabList (string previousWeaponName)
|
|
{
|
|
int previousWeaponIndex = -1;
|
|
|
|
if (previousWeaponName != "") {
|
|
previousWeaponIndex = meleeWeaponPrefabInfoList.FindIndex (s => s.Name == previousWeaponName);
|
|
}
|
|
|
|
int newWeaponIndex = -1;
|
|
|
|
if (previousWeaponIndex > -1) {
|
|
|
|
bool exit = false;
|
|
|
|
int loopCount = 0;
|
|
|
|
while (!exit) {
|
|
int randomWeaponIndex = Random.Range (0, meleeWeaponPrefabInfoList.Count);
|
|
|
|
if (randomWeaponIndex != previousWeaponIndex) {
|
|
newWeaponIndex = randomWeaponIndex;
|
|
|
|
exit = true;
|
|
}
|
|
|
|
loopCount++;
|
|
|
|
if (loopCount > 100) {
|
|
return;
|
|
}
|
|
}
|
|
} else {
|
|
newWeaponIndex = Random.Range (0, meleeWeaponPrefabInfoList.Count);
|
|
}
|
|
|
|
if (newWeaponIndex > -1) {
|
|
checkMeleeWeaponToUse (meleeWeaponPrefabInfoList [newWeaponIndex].Name, false);
|
|
}
|
|
}
|
|
|
|
public void inputSetWeaponByIndex (int currentNumberInput)
|
|
{
|
|
if (currentNumberInput > -1) {
|
|
if (currentNumberInput == 0) {
|
|
currentNumberInput = 9;
|
|
} else {
|
|
currentNumberInput--;
|
|
}
|
|
|
|
if (meleeWeaponGrabbedInfoList.Count == 0 || currentNumberInput >= meleeWeaponGrabbedInfoList.Count) {
|
|
return;
|
|
}
|
|
|
|
if (getCurrentNumberOfWeaponsAvailable () == 0) {
|
|
return;
|
|
}
|
|
|
|
if (isGrabObjectsEnabled ()) {
|
|
checkWeaponByNumber (currentNumberInput);
|
|
}
|
|
}
|
|
}
|
|
|
|
void Update ()
|
|
{
|
|
if (!startInitialized) {
|
|
startInitialized = true;
|
|
}
|
|
|
|
if (meleeWeaponsGrabbedManagerActive) {
|
|
if (!storePickedWeaponsOnInventory) {
|
|
if (numberKeysToChangeBetweenMeleeWeaponsEnabled) {
|
|
if (!mainGrabbedObjectMeleeAttackSystem.isObjectThrownTravellingToTarget () &&
|
|
canUseInput ()) {
|
|
|
|
int currentNumberInput = playerInput.checkNumberInput (currentNumberOfWeaponsAvailable + 1);
|
|
|
|
if (currentNumberInput > -1) {
|
|
inputSetWeaponByIndex (currentNumberInput);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!startWithShieldChecked) {
|
|
if (startGameWithShield && isGrabObjectsEnabled ()) {
|
|
setShieldActiveState (true, shieldNameToStartGame);
|
|
|
|
startWithShieldChecked = true;
|
|
}
|
|
}
|
|
|
|
if (!startWithWeaponChecked) {
|
|
|
|
if (startGameWithWeapon) {
|
|
if (isGrabObjectsEnabled ()) {
|
|
if (!mainGrabbedObjectMeleeAttackSystem.isCarryingObject ()) {
|
|
if (startGameWithListOfWeapons && !isLoadingGame) {
|
|
setInitialWeaponsList ();
|
|
}
|
|
|
|
if (startWithRandomWeapon) {
|
|
if (startWithRandomWeaponFromListOfWeaponsToStart && startGameWithListOfWeapons) {
|
|
int randomWeaponIndex = Random.Range (0, meleeWeaponGrabbedInfoList.Count);
|
|
|
|
weaponNameToStartGame = meleeWeaponGrabbedInfoList [randomWeaponIndex].Name;
|
|
} else {
|
|
int randomWeaponIndex = Random.Range (0, meleeWeaponPrefabInfoList.Count);
|
|
|
|
weaponNameToStartGame = meleeWeaponPrefabInfoList [randomWeaponIndex].Name;
|
|
}
|
|
}
|
|
|
|
if (weaponNameToStartGame != "" && drawWeaponOnStartEnabled) {
|
|
checkMeleeWeaponToUse (weaponNameToStartGame, startWithWeaponOnlyIfAlreadyAvailable);
|
|
}
|
|
}
|
|
|
|
startWithWeaponChecked = true;
|
|
}
|
|
} else {
|
|
if (drawWeaponAtStartIfConfiguredExternally) {
|
|
if (isGrabObjectsEnabled ()) {
|
|
if (!mainGrabbedObjectMeleeAttackSystem.isCarryingObject ()) {
|
|
if (meleeWeaponGrabbedInfoList.Count > 0) {
|
|
checkMeleeWeaponToUse (meleeWeaponGrabbedInfoList [0].Name, false);
|
|
|
|
if (showDebugPrint) {
|
|
print ("checking to draw weapon when starting game and checking for grabbed object list");
|
|
}
|
|
}
|
|
} else {
|
|
string currentWeaponName = getCurrentWeaponName ();
|
|
|
|
if (currentWeaponName != null && currentWeaponName != "") {
|
|
if (showDebugPrint) {
|
|
print ("weapon already carried " + getCurrentWeaponName ());
|
|
}
|
|
|
|
updateQuickAccesSlotOnInventory (currentWeaponName);
|
|
}
|
|
}
|
|
}
|
|
|
|
startWithWeaponChecked = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool startInitialized;
|
|
|
|
public void resetStartWithWeaponCheckedOnCharacterSpawn ()
|
|
{
|
|
startWithWeaponChecked = false;
|
|
}
|
|
|
|
void setInitialWeaponsList ()
|
|
{
|
|
int listOfWeaponsToStartCount = listOfWeaponsToStart.Count;
|
|
|
|
for (int i = 0; i < listOfWeaponsToStartCount; i++) {
|
|
int weaponIndex = meleeWeaponPrefabInfoList.FindIndex (s => s.Name == listOfWeaponsToStart [i]);
|
|
|
|
if (weaponIndex > -1) {
|
|
meleeWeaponPrefabInfo currentMeleeWeaponPrefabInfo = meleeWeaponPrefabInfoList [weaponIndex];
|
|
|
|
if (currentMeleeWeaponPrefabInfo != null) {
|
|
int grabbedWeaponIndex = meleeWeaponGrabbedInfoList.FindIndex (s => s.Name == currentMeleeWeaponPrefabInfo.Name);
|
|
|
|
if (grabbedWeaponIndex <= -1) {
|
|
meleeWeaponGrabbedInfo newMeleeWeaponGrabbedInfo = new meleeWeaponGrabbedInfo ();
|
|
|
|
newMeleeWeaponGrabbedInfo.Name = currentMeleeWeaponPrefabInfo.Name;
|
|
|
|
newMeleeWeaponGrabbedInfo.weaponPrefabIndex = currentMeleeWeaponPrefabInfo.weaponPrefabIndex;
|
|
|
|
meleeWeaponGrabbedInfoList.Add (newMeleeWeaponGrabbedInfo);
|
|
} else {
|
|
if (showDebugPrint) {
|
|
print ("melee weapon was already on the initial list");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!isGrabObjectsEnabled ()) {
|
|
return;
|
|
}
|
|
|
|
int meleeWeaponGrabbedInfoListCount = meleeWeaponGrabbedInfoList.Count;
|
|
|
|
for (int k = 0; k < meleeWeaponGrabbedInfoListCount; k++) {
|
|
meleeWeaponGrabbedInfo currentMeleeWeaponGrabbedInfo = meleeWeaponGrabbedInfoList [k];
|
|
|
|
currentMeleeWeaponGrabbedInfo.weaponInstantiated = true;
|
|
|
|
currentMeleeWeaponGrabbedInfo.carryingWeapon = true;
|
|
|
|
meleeWeaponPrefabInfo currentMeleeWeaponPrefabInfo = getWeaponPrefabByName (currentMeleeWeaponGrabbedInfo.Name);
|
|
|
|
if (currentMeleeWeaponPrefabInfo != null) {
|
|
currentMeleeWeaponGrabbedInfo.weaponStored = (GameObject)Instantiate (currentMeleeWeaponPrefabInfo.weaponPrefab, Vector3.up * 1000, Quaternion.identity);
|
|
|
|
currentMeleeWeaponGrabbedInfo.weaponPrefabIndex = currentMeleeWeaponPrefabInfo.weaponPrefabIndex;
|
|
|
|
bool hideWeaponMeshResult = checkIfHideWeaponMeshWhenNotUsed (currentMeleeWeaponGrabbedInfo.hideWeaponMeshWhenNotUsed);
|
|
|
|
checkObjectMeshToEnableOrDisable (!hideWeaponMeshResult, currentMeleeWeaponGrabbedInfo);
|
|
|
|
if (currentMeleeWeaponGrabbedInfo.weaponStored.activeSelf) {
|
|
currentMeleeWeaponGrabbedInfo.weaponStored.SetActive (false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool checkIfHideWeaponMeshWhenNotUsed (bool currentValue)
|
|
{
|
|
if (overrideOptionToHideWeaponMeshWhenNotUsed) {
|
|
return hideWeaponMeshWhenNotUsed;
|
|
}
|
|
|
|
return currentValue;
|
|
}
|
|
|
|
public bool checkMeleeWeaponToUse (string weaponNameToSearch, bool checkIfWeaponNotFound)
|
|
{
|
|
bool canSearchWeapon = true;
|
|
|
|
if (showDebugPrint) {
|
|
print (weaponNameToSearch);
|
|
}
|
|
|
|
int weaponIndex = meleeWeaponGrabbedInfoList.FindIndex (s => s.Name == weaponNameToSearch);
|
|
|
|
if (checkIfWeaponNotFound) {
|
|
if (weaponIndex == -1) {
|
|
canSearchWeapon = false;
|
|
}
|
|
}
|
|
|
|
if (canSearchWeapon) {
|
|
|
|
if (weaponIndex > -1 && meleeWeaponGrabbedInfoList [weaponIndex].weaponInstantiated) {
|
|
if (showDebugPrint) {
|
|
print ("check weapon by number");
|
|
}
|
|
|
|
checkWeaponByNumber (weaponIndex);
|
|
|
|
return true;
|
|
} else {
|
|
if (showDebugPrint) {
|
|
print ("instantiate new weapon");
|
|
}
|
|
|
|
int weaponPrefabIndex = meleeWeaponPrefabInfoList.FindIndex (s => s.Name == weaponNameToSearch);
|
|
|
|
if (weaponPrefabIndex > -1) {
|
|
GameObject newWeaponToCarry = (GameObject)Instantiate (meleeWeaponPrefabInfoList [weaponPrefabIndex].weaponPrefab, Vector3.up * 1000, Quaternion.identity);
|
|
|
|
grabPhysicalObjectSystem currentGrabPhysicalObjectSystem = newWeaponToCarry.GetComponent<grabPhysicalObjectSystem> ();
|
|
|
|
currentGrabPhysicalObjectSystem.setCurrentPlayer (playerGameObject);
|
|
|
|
mainGrabbedObjectMeleeAttackSystem.setRemoveWeaponsFromManagerState (false);
|
|
|
|
mainGrabObjects.grabPhysicalObjectExternally (newWeaponToCarry);
|
|
|
|
mainGrabbedObjectMeleeAttackSystem.setRemoveWeaponsFromManagerState (true);
|
|
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public void setCheckDrawKeepWeaponAnimationPauseState (bool state)
|
|
{
|
|
mainGrabbedObjectMeleeAttackSystem.setCheckDrawKeepWeaponAnimationPauseState (state);
|
|
}
|
|
|
|
public void checkIfDrawWeapon ()
|
|
{
|
|
if (meleeWeaponsGrabbedManagerActive) {
|
|
checkWeaponByNumber (currentWeaponIndex);
|
|
|
|
mainGrabbedObjectMeleeAttackSystem.checkEventWhenKeepingOrDrawingMeleeWeapon (false);
|
|
}
|
|
}
|
|
|
|
//Check for the melee draw/keep actions if using animations for those actions
|
|
void activateDrawkeepMeleeWeaponAnimation (meleeWeaponGrabbedInfo currentMeleeWeaponGrabbedInfo, bool useExtraDelay)
|
|
{
|
|
stopActivateDrawkeepMeleeWeaponAnimationCoroutine ();
|
|
|
|
weaponDrawKeepAnimationCoroutine = StartCoroutine (activateDrawkeepMeleeWeaponAnimationCoroutine (currentMeleeWeaponGrabbedInfo, useExtraDelay));
|
|
}
|
|
|
|
public void stopActivateDrawkeepMeleeWeaponAnimationCoroutine ()
|
|
{
|
|
if (weaponDrawKeepAnimationCoroutine != null) {
|
|
StopCoroutine (weaponDrawKeepAnimationCoroutine);
|
|
}
|
|
}
|
|
|
|
IEnumerator activateDrawkeepMeleeWeaponAnimationCoroutine (meleeWeaponGrabbedInfo currentMeleeWeaponGrabbedInfo, bool useExtraDelay)
|
|
{
|
|
bool targetReached = false;
|
|
|
|
if (useExtraDelay) {
|
|
yield return new WaitForSeconds (0.3f);
|
|
}
|
|
|
|
while (!targetReached) {
|
|
if (!mainGrabbedObjectMeleeAttackSystem.mainPlayerController.isActionActive ()) {
|
|
targetReached = true;
|
|
}
|
|
|
|
|
|
yield return null;
|
|
}
|
|
|
|
confirmToDrawNextWeapon (false, currentMeleeWeaponGrabbedInfo);
|
|
}
|
|
|
|
void checkWeaponByNumber (int currentNumberInput)
|
|
{
|
|
if (currentNumberInput >= meleeWeaponGrabbedInfoList.Count || currentNumberInput < 0) {
|
|
return;
|
|
}
|
|
|
|
meleeWeaponGrabbedInfo currentMeleeWeaponGrabbedInfo = meleeWeaponGrabbedInfoList [currentNumberInput];
|
|
|
|
bool isCurrentWeapon = currentMeleeWeaponGrabbedInfo.isCurrentWeapon;
|
|
|
|
bool previousWeaponIsKept = false;
|
|
|
|
bool previousWeaponUseDrawKeepAnimations = false;
|
|
|
|
if (!isCurrentWeapon) {
|
|
|
|
currentMeleeWeaponGrabbedInfo.isCurrentWeapon = true;
|
|
|
|
currentMeleeWeaponGrabbedInfo.carryingWeapon = true;
|
|
|
|
currentMeleeWeaponSheathedOrCarried = true;
|
|
|
|
currentWeaponIndex = currentNumberInput;
|
|
|
|
bool weaponToKeepFound = false;
|
|
|
|
for (int k = 0; k < meleeWeaponGrabbedInfoList.Count; k++) {
|
|
if (k != currentNumberInput) {
|
|
if (meleeWeaponGrabbedInfoList [k].isCurrentWeapon) {
|
|
keepWeapon (k);
|
|
|
|
weaponToKeepFound = true;
|
|
|
|
previousWeaponIsKept = true;
|
|
|
|
if (meleeWeaponGrabbedInfoList [k].weaponStored != null) {
|
|
grabPhysicalObjectMeleeAttackSystem currentGrabPhysicalObjectMeleeAttackSystem = meleeWeaponGrabbedInfoList [k].weaponStored.GetComponent<grabPhysicalObjectMeleeAttackSystem> ();
|
|
|
|
previousWeaponUseDrawKeepAnimations = currentGrabPhysicalObjectMeleeAttackSystem.useDrawKeepWeaponAnimation;
|
|
}
|
|
}
|
|
|
|
meleeWeaponGrabbedInfoList [k].isCurrentWeapon = false;
|
|
}
|
|
}
|
|
|
|
if (!weaponToKeepFound && !storeEachGrabbedWeapon) {
|
|
if (mainGrabbedObjectMeleeAttackSystem.isCarryingObject ()) {
|
|
mainGrabObjects.dropObject ();
|
|
|
|
mainGrabObjects.clearPhysicalObjectToGrabFoundList ();
|
|
}
|
|
}
|
|
}
|
|
|
|
bool confirmToDrawNextWeaponResult = true;
|
|
|
|
if (previousWeaponIsKept) {
|
|
if (!isCurrentWeapon) {
|
|
if (previousWeaponUseDrawKeepAnimations && !mainGrabbedObjectMeleeAttackSystem.ignoreUseDrawKeepWeaponAnimation) {
|
|
confirmToDrawNextWeaponResult = false;
|
|
|
|
activateDrawkeepMeleeWeaponAnimation (currentMeleeWeaponGrabbedInfo, true);
|
|
}
|
|
}
|
|
}
|
|
|
|
// print ("confirmToDrawNextWeaponResult result " + confirmToDrawNextWeaponResult);
|
|
|
|
if (confirmToDrawNextWeaponResult) {
|
|
confirmToDrawNextWeapon (isCurrentWeapon, currentMeleeWeaponGrabbedInfo);
|
|
}
|
|
}
|
|
|
|
void confirmToDrawNextWeapon (bool isCurrentWeapon, meleeWeaponGrabbedInfo currentMeleeWeaponGrabbedInfo)
|
|
{
|
|
if (!isCurrentWeapon) {
|
|
bool weaponInstantiated = false;
|
|
|
|
if (!currentMeleeWeaponGrabbedInfo.weaponInstantiated || currentMeleeWeaponGrabbedInfo.canBeSpawnedInfiniteTimes || canSpawnAnyWeaponStoredInfiniteTimes) {
|
|
if (currentMeleeWeaponGrabbedInfo.weaponStored == null) {
|
|
|
|
currentMeleeWeaponGrabbedInfo.weaponInstantiated = true;
|
|
|
|
meleeWeaponPrefabInfo currentMeleeWeaponPrefabInfo = getWeaponPrefabByName (currentMeleeWeaponGrabbedInfo.Name);
|
|
|
|
if (currentMeleeWeaponPrefabInfo != null) {
|
|
currentMeleeWeaponGrabbedInfo.weaponStored = (GameObject)Instantiate (currentMeleeWeaponPrefabInfo.weaponPrefab, Vector3.up * 1000, Quaternion.identity);
|
|
|
|
currentMeleeWeaponGrabbedInfo.weaponPrefabIndex = currentMeleeWeaponPrefabInfo.weaponPrefabIndex;
|
|
|
|
grabPhysicalObjectSystem currentGrabPhysicalObjectSystem = currentMeleeWeaponGrabbedInfo.weaponStored.GetComponent<grabPhysicalObjectSystem> ();
|
|
|
|
currentGrabPhysicalObjectSystem.setCurrentPlayer (playerGameObject);
|
|
|
|
mainGrabbedObjectMeleeAttackSystem.setRemoveWeaponsFromManagerState (false);
|
|
|
|
mainGrabObjects.grabPhysicalObjectExternally (currentMeleeWeaponGrabbedInfo.weaponStored);
|
|
|
|
mainGrabbedObjectMeleeAttackSystem.setRemoveWeaponsFromManagerState (true);
|
|
|
|
weaponInstantiated = true;
|
|
|
|
mainGrabbedObjectMeleeAttackSystem.activateStartDrawAnimation ();
|
|
|
|
//update quick slot here
|
|
|
|
if (mainGrabbedObjectMeleeAttackSystem.isCarryingObject ()) {
|
|
updateQuickAccesSlotOnInventory (currentMeleeWeaponGrabbedInfo.Name);
|
|
}
|
|
} else {
|
|
print ("WARNING: melee weapon prefab with the name " + currentMeleeWeaponGrabbedInfo.Name + " not found, make sure to configure a weapon" +
|
|
" with that info.");
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!weaponInstantiated) {
|
|
if (!currentMeleeWeaponGrabbedInfo.weaponStored.activeSelf) {
|
|
currentMeleeWeaponGrabbedInfo.weaponStored.SetActive (true);
|
|
}
|
|
|
|
bool hideWeaponMeshResult = checkIfHideWeaponMeshWhenNotUsed (currentMeleeWeaponGrabbedInfo.hideWeaponMeshWhenNotUsed);
|
|
|
|
if (!hideWeaponMeshResult) {
|
|
checkObjectMeshToEnableOrDisable (false, currentMeleeWeaponGrabbedInfo);
|
|
}
|
|
|
|
grabPhysicalObjectSystem currentGrabPhysicalObjectSystem = currentMeleeWeaponGrabbedInfo.weaponStored.GetComponent<grabPhysicalObjectSystem> ();
|
|
|
|
currentGrabPhysicalObjectSystem.setCurrentPlayer (playerGameObject);
|
|
|
|
mainGrabbedObjectMeleeAttackSystem.setRemoveWeaponsFromManagerState (false);
|
|
|
|
mainGrabObjects.grabPhysicalObjectExternally (currentMeleeWeaponGrabbedInfo.weaponStored);
|
|
|
|
mainGrabbedObjectMeleeAttackSystem.setRemoveWeaponsFromManagerState (true);
|
|
|
|
mainGrabbedObjectMeleeAttackSystem.activateStartDrawAnimation ();
|
|
|
|
//update quick slot here
|
|
|
|
if (mainGrabbedObjectMeleeAttackSystem.isCarryingObject ()) {
|
|
updateQuickAccesSlotOnInventory (currentMeleeWeaponGrabbedInfo.Name);
|
|
}
|
|
}
|
|
}
|
|
|
|
mainGrabbedObjectMeleeAttackSystem.drawOrSheatheShield (true);
|
|
}
|
|
|
|
public void enableOrDisableMeleeWeaponsGrabbedManager (bool state)
|
|
{
|
|
if (!meleeWeaponsGrabbedManagerEnabled) {
|
|
return;
|
|
}
|
|
|
|
if (meleeWeaponsGrabbedManagerActive == state) {
|
|
return;
|
|
}
|
|
|
|
meleeWeaponsGrabbedManagerActive = state;
|
|
|
|
if (meleeWeaponsGrabbedManagerActive) {
|
|
if (!drawMeleeWeaponsPaused) {
|
|
bool canDrawWeapon = true;
|
|
|
|
if (startGameWithWeapon && !startWithWeaponChecked) {
|
|
canDrawWeapon = false;
|
|
}
|
|
|
|
if (canDrawWeapon) {
|
|
if (!mainGrabbedObjectMeleeAttackSystem.isCarryingObject () && startInitialized) {
|
|
checkWeaponByNumber (currentWeaponIndex);
|
|
|
|
// print ("check melee");
|
|
|
|
if (mainGrabbedObjectMeleeAttackSystem.isCarryingObject () && currentWeaponIndex >= 0 && currentWeaponIndex < meleeWeaponGrabbedInfoList.Count) {
|
|
updateQuickAccesSlotOnInventory (meleeWeaponGrabbedInfoList [currentWeaponIndex].Name);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
bool currentWeaponIsThrow = isCurrentWeaponThrown ();
|
|
|
|
for (int k = 0; k < meleeWeaponGrabbedInfoList.Count; k++) {
|
|
if (meleeWeaponGrabbedInfoList [k].isCurrentWeapon) {
|
|
|
|
if (!currentWeaponIsThrow) {
|
|
keepWeapon (k);
|
|
}
|
|
}
|
|
|
|
meleeWeaponGrabbedInfoList [k].isCurrentWeapon = false;
|
|
}
|
|
|
|
if (currentWeaponIsThrow) {
|
|
mainGrabObjects.dropObject ();
|
|
}
|
|
|
|
mainGrabbedObjectMeleeAttackSystem.enableOrDisableMainMeleeUISystem (false);
|
|
}
|
|
|
|
if (useEventsOnStateChange) {
|
|
if (meleeWeaponsGrabbedManagerActive) {
|
|
eventOnStateActive.Invoke ();
|
|
} else {
|
|
eventOnStateDeactivate.Invoke ();
|
|
}
|
|
}
|
|
|
|
if (storePickedWeaponsOnInventory) {
|
|
mainInventoryManager.checkToEnableOrDisableQuickAccessSlotsParentOutOfInventoryFromMeleeWeaponsMode (meleeWeaponsGrabbedManagerActive);
|
|
}
|
|
|
|
drawMeleeWeaponsPaused = false;
|
|
|
|
if (!meleeWeaponsGrabbedManagerActive) {
|
|
currentMeleeWeaponSheathedOrCarried = false;
|
|
}
|
|
}
|
|
|
|
public void setDrawMeleeWeaponsPausedState (bool state)
|
|
{
|
|
drawMeleeWeaponsPaused = state;
|
|
}
|
|
|
|
void keepWeapon (int weaponIndex)
|
|
{
|
|
if (!mainGrabbedObjectMeleeAttackSystem.isCarryingObject ()) {
|
|
return;
|
|
}
|
|
|
|
if (meleeWeaponGrabbedInfoList.Count > weaponIndex) {
|
|
|
|
meleeWeaponGrabbedInfo currentMeleeWeaponGrabbedInfo = meleeWeaponGrabbedInfoList [weaponIndex];
|
|
|
|
if (currentMeleeWeaponGrabbedInfo.weaponStored != null) {
|
|
if (showDebugPrint) {
|
|
print ("Keep current weapon " + currentMeleeWeaponGrabbedInfo.Name);
|
|
}
|
|
|
|
mainGrabbedObjectMeleeAttackSystem.setRemoveWeaponsFromManagerState (false);
|
|
|
|
mainGrabbedObjectMeleeAttackSystem.checkEventWhenKeepingOrDrawingMeleeWeapon (true);
|
|
|
|
mainGrabObjects.grabbed = true;
|
|
|
|
mainGrabObjects.checkIfDropObject (currentMeleeWeaponGrabbedInfo.weaponStored);
|
|
|
|
mainGrabObjects.removeCurrentPhysicalObjectToGrabFound (currentMeleeWeaponGrabbedInfo.weaponStored);
|
|
|
|
if (currentMeleeWeaponGrabbedInfo.weaponStored.activeSelf) {
|
|
currentMeleeWeaponGrabbedInfo.weaponStored.SetActive (false);
|
|
}
|
|
|
|
mainGrabbedObjectMeleeAttackSystem.setRemoveWeaponsFromManagerState (true);
|
|
|
|
bool hideWeaponMeshResult = checkIfHideWeaponMeshWhenNotUsed (currentMeleeWeaponGrabbedInfo.hideWeaponMeshWhenNotUsed);
|
|
|
|
if (!hideWeaponMeshResult) {
|
|
checkObjectMeshToEnableOrDisable (true, currentMeleeWeaponGrabbedInfo);
|
|
}
|
|
|
|
mainGrabbedObjectMeleeAttackSystem.drawOrSheatheShield (false);
|
|
|
|
bool canUseWeaponKeepAnimation = true;
|
|
|
|
if (mainGrabbedObjectMeleeAttackSystem.mainPlayerController.isCustomCharacterControllerActive () ||
|
|
mainGrabbedObjectMeleeAttackSystem.mainPlayerController.isPlayerDriving () ||
|
|
mainGrabbedObjectMeleeAttackSystem.mainPlayerController.isUsingDevice ()) {
|
|
canUseWeaponKeepAnimation = false;
|
|
}
|
|
|
|
if (canUseWeaponKeepAnimation) {
|
|
mainGrabbedObjectMeleeAttackSystem.activateStartKeepAnimation ();
|
|
} else {
|
|
mainGrabbedObjectMeleeAttackSystem.removeDrawKeepWeaponAnimationInfo ();
|
|
}
|
|
}
|
|
|
|
currentMeleeWeaponGrabbedInfo.isCurrentWeapon = false;
|
|
}
|
|
}
|
|
|
|
public void disableCurrentMeleeWeapon (string weaponName)
|
|
{
|
|
if (!mainGrabbedObjectMeleeAttackSystem.isCarryingObject ()) {
|
|
return;
|
|
}
|
|
|
|
int weaponIndex = meleeWeaponGrabbedInfoList.FindIndex (s => s.Name == weaponName);
|
|
|
|
if (meleeWeaponGrabbedInfoList.Count > weaponIndex && weaponIndex > -1) {
|
|
|
|
meleeWeaponGrabbedInfo currentMeleeWeaponGrabbedInfo = meleeWeaponGrabbedInfoList [weaponIndex];
|
|
|
|
if (currentMeleeWeaponGrabbedInfo.isCurrentWeapon) {
|
|
if (currentMeleeWeaponGrabbedInfo.weaponStored != null) {
|
|
mainGrabbedObjectMeleeAttackSystem.setRemoveWeaponsFromManagerState (false);
|
|
|
|
mainGrabObjects.grabbed = true;
|
|
|
|
mainGrabObjects.checkIfDropObject (currentMeleeWeaponGrabbedInfo.weaponStored);
|
|
|
|
mainGrabObjects.removeCurrentPhysicalObjectToGrabFound (currentMeleeWeaponGrabbedInfo.weaponStored);
|
|
|
|
if (currentMeleeWeaponGrabbedInfo.weaponStored.activeSelf) {
|
|
currentMeleeWeaponGrabbedInfo.weaponStored.SetActive (false);
|
|
}
|
|
|
|
mainGrabbedObjectMeleeAttackSystem.setRemoveWeaponsFromManagerState (true);
|
|
|
|
bool hideWeaponMeshResult = checkIfHideWeaponMeshWhenNotUsed (currentMeleeWeaponGrabbedInfo.hideWeaponMeshWhenNotUsed);
|
|
|
|
if (!hideWeaponMeshResult) {
|
|
checkObjectMeshToEnableOrDisable (true, currentMeleeWeaponGrabbedInfo);
|
|
}
|
|
}
|
|
|
|
currentMeleeWeaponGrabbedInfo.isCurrentWeapon = false;
|
|
|
|
currentMeleeWeaponGrabbedInfo.carryingWeapon = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void checkObjectMeshToEnableOrDisable (bool enableWeaponMesh, meleeWeaponGrabbedInfo currentMeleeWeaponGrabbedInfo)
|
|
{
|
|
grabPhysicalObjectMeleeAttackSystem currentGrabPhysicalObjectMeleeAttackSystem = currentMeleeWeaponGrabbedInfo.weaponStored.GetComponent<grabPhysicalObjectMeleeAttackSystem> ();
|
|
|
|
bool weaponMeshCreated = false;
|
|
|
|
if (currentMeleeWeaponGrabbedInfo.weaponMesh == null) {
|
|
GameObject weaponMeshToInstantiate = currentGrabPhysicalObjectMeleeAttackSystem.weaponMesh;
|
|
|
|
if (currentGrabPhysicalObjectMeleeAttackSystem.useCustomWeaponMeshToInstantiate) {
|
|
weaponMeshToInstantiate = currentGrabPhysicalObjectMeleeAttackSystem.customWeaponMeshToInstantiate;
|
|
}
|
|
|
|
currentMeleeWeaponGrabbedInfo.weaponMesh = (GameObject)Instantiate (weaponMeshToInstantiate, Vector3.zero, Quaternion.identity);
|
|
|
|
currentMeleeWeaponGrabbedInfo.weaponMesh.transform.localScale = currentGrabPhysicalObjectMeleeAttackSystem.weaponMesh.transform.localScale;
|
|
|
|
weaponMeshCreated = true;
|
|
}
|
|
|
|
if (currentMeleeWeaponGrabbedInfo.weaponMesh != null) {
|
|
if (currentMeleeWeaponGrabbedInfo.weaponMesh.activeSelf != enableWeaponMesh) {
|
|
currentMeleeWeaponGrabbedInfo.weaponMesh.SetActive (enableWeaponMesh);
|
|
|
|
if (showDebugPrint) {
|
|
print (enableWeaponMesh + " " + Time.time);
|
|
}
|
|
}
|
|
|
|
if (enableWeaponMesh || weaponMeshCreated) {
|
|
grabPhysicalObjectSystem currentGrabPhysicalObjectSystem = currentMeleeWeaponGrabbedInfo.weaponStored.GetComponent<grabPhysicalObjectSystem> ();
|
|
|
|
bool setWeaponMeshOnPhysicalWeaponPlace = false;
|
|
|
|
if (enableWeaponMesh) {
|
|
currentMeleeWeaponGrabbedInfo.objectThrown = currentGrabPhysicalObjectMeleeAttackSystem.isObjectThrown ();
|
|
|
|
if (currentMeleeWeaponGrabbedInfo.objectThrown) {
|
|
setWeaponMeshOnPhysicalWeaponPlace = true;
|
|
}
|
|
}
|
|
|
|
Transform newParent = null;
|
|
|
|
bool useMountPointToKeepObject = currentGrabPhysicalObjectSystem.useMountPointToKeepObject;
|
|
|
|
if (useMountPointToKeepObject) {
|
|
newParent = GKC_Utils.getMountPointTransformByName (currentGrabPhysicalObjectSystem.mountPointTokeepObjectName, playerGameObject.transform);
|
|
}
|
|
|
|
if (!useMountPointToKeepObject || newParent == null) {
|
|
newParent = mainGrabbedObjectMeleeAttackSystem.getCharacterHumanBone (currentGrabPhysicalObjectSystem.boneToKeepObject);
|
|
}
|
|
|
|
Vector3 targetPosition = currentGrabPhysicalObjectMeleeAttackSystem.referencePositionToKeepObjectMesh.localPosition;
|
|
Quaternion targetRotation = currentGrabPhysicalObjectMeleeAttackSystem.referencePositionToKeepObjectMesh.localRotation;
|
|
|
|
if (enableWeaponMesh) {
|
|
mainGrabbedObjectMeleeAttackSystem.checkUpdateCustomReferencePositionsToKeepMeshValues (currentGrabPhysicalObjectMeleeAttackSystem);
|
|
}
|
|
|
|
if (currentGrabPhysicalObjectMeleeAttackSystem.useCustomReferencePositionToKeepObjectMesh) {
|
|
targetPosition = currentGrabPhysicalObjectMeleeAttackSystem.getCustomReferenceToKeepObjectMeshPosition ();
|
|
targetRotation = Quaternion.Euler (currentGrabPhysicalObjectMeleeAttackSystem.getCustomReferenceToKeepObjectMeshEuler ());
|
|
}
|
|
|
|
if (setWeaponMeshOnPhysicalWeaponPlace) {
|
|
Transform lastParentAssigned = currentGrabPhysicalObjectSystem.getLastParentAssigned ();
|
|
|
|
if (lastParentAssigned != null) {
|
|
currentMeleeWeaponGrabbedInfo.weaponStored.transform.SetParent (lastParentAssigned);
|
|
}
|
|
|
|
currentMeleeWeaponGrabbedInfo.weaponMesh.transform.SetParent (currentGrabPhysicalObjectMeleeAttackSystem.weaponMesh.transform);
|
|
|
|
currentMeleeWeaponGrabbedInfo.weaponMesh.transform.localPosition = Vector3.zero;
|
|
currentMeleeWeaponGrabbedInfo.weaponMesh.transform.localRotation = Quaternion.identity;
|
|
|
|
newParent = currentGrabPhysicalObjectSystem.transform.parent;
|
|
|
|
currentMeleeWeaponGrabbedInfo.weaponMesh.transform.SetParent (newParent);
|
|
} else {
|
|
|
|
currentMeleeWeaponGrabbedInfo.weaponMesh.transform.SetParent (newParent);
|
|
|
|
currentMeleeWeaponGrabbedInfo.weaponMesh.transform.localPosition = targetPosition;
|
|
currentMeleeWeaponGrabbedInfo.weaponMesh.transform.localRotation = targetRotation;
|
|
}
|
|
|
|
currentMeleeWeaponGrabbedInfo.weaponMesh.transform.localScale = Vector3.one;
|
|
|
|
if (!weaponMeshCreated) {
|
|
if (mainGrabbedObjectMeleeAttackSystem.mainPlayerController.isPlayerOnFirstPerson ()) {
|
|
enableOrDisableMeleeWeaponMeshOnCharacterBodyByName (false, currentMeleeWeaponGrabbedInfo.Name);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public meleeWeaponPrefabInfo getWeaponPrefabByName (string weaponName)
|
|
{
|
|
for (int k = 0; k < meleeWeaponPrefabInfoList.Count; k++) {
|
|
if (meleeWeaponPrefabInfoList [k].Name.Equals (weaponName)) {
|
|
return meleeWeaponPrefabInfoList [k];
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public bool checkIfCanUseMeleeWeaponPrefabByName (string weaponName)
|
|
{
|
|
for (int k = 0; k < meleeWeaponPrefabInfoList.Count; k++) {
|
|
if (meleeWeaponPrefabInfoList [k].Name.Equals (weaponName)) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public grabPhysicalObjectMeleeAttackSystem getWeaponGrabbedByName (string weaponName)
|
|
{
|
|
for (int k = 0; k < meleeWeaponGrabbedInfoList.Count; k++) {
|
|
if (meleeWeaponGrabbedInfoList [k].Name.Equals (weaponName)) {
|
|
if (meleeWeaponGrabbedInfoList [k].weaponStored != null) {
|
|
|
|
return meleeWeaponGrabbedInfoList [k].weaponStored.GetComponent<grabPhysicalObjectMeleeAttackSystem> ();
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public void checkWeaponToStore (string weaponName, GameObject weaponGameObject)
|
|
{
|
|
if (!storeEachGrabbedWeapon) {
|
|
return;
|
|
}
|
|
|
|
int weaponIndex = meleeWeaponGrabbedInfoList.FindIndex (s => s.Name == weaponName);
|
|
|
|
if (weaponIndex == -1) {
|
|
meleeWeaponPrefabInfo currentMeleeWeaponPrefabInfo = getWeaponPrefabByName (weaponName);
|
|
|
|
if (currentMeleeWeaponPrefabInfo != null) {
|
|
meleeWeaponGrabbedInfo newMeleeWeaponGrabbedInfo = new meleeWeaponGrabbedInfo ();
|
|
|
|
newMeleeWeaponGrabbedInfo.Name = weaponName;
|
|
newMeleeWeaponGrabbedInfo.isCurrentWeapon = true;
|
|
newMeleeWeaponGrabbedInfo.carryingWeapon = true;
|
|
|
|
currentMeleeWeaponSheathedOrCarried = true;
|
|
|
|
newMeleeWeaponGrabbedInfo.weaponPrefabIndex = currentMeleeWeaponPrefabInfo.weaponPrefabIndex;
|
|
|
|
newMeleeWeaponGrabbedInfo.weaponStored = weaponGameObject;
|
|
|
|
grabPhysicalObjectMeleeAttackSystem currentGrabPhysicalObjectMeleeAttackSystem = newMeleeWeaponGrabbedInfo.weaponStored.GetComponent<grabPhysicalObjectMeleeAttackSystem> ();
|
|
|
|
bool hideWeaponMeshResult = checkIfHideWeaponMeshWhenNotUsed (currentGrabPhysicalObjectMeleeAttackSystem.hideWeaponMeshWhenNotUsed);
|
|
|
|
newMeleeWeaponGrabbedInfo.hideWeaponMeshWhenNotUsed = hideWeaponMeshResult;
|
|
|
|
newMeleeWeaponGrabbedInfo.weaponInstantiated = true;
|
|
|
|
meleeWeaponGrabbedInfoList.Add (newMeleeWeaponGrabbedInfo);
|
|
|
|
currentNumberOfWeaponsAvailable = getCurrentNumberOfWeaponsAvailable ();
|
|
|
|
currentWeaponIndex = meleeWeaponGrabbedInfoList.Count - 1;
|
|
|
|
if (storeOnlyOneWeapon) {
|
|
for (int i = meleeWeaponGrabbedInfoList.Count - 1; i >= 0; i--) {
|
|
if (currentWeaponIndex != i) {
|
|
meleeWeaponGrabbedInfo currentMeleeWeaponGrabbedInfo = meleeWeaponGrabbedInfoList [i];
|
|
|
|
if (currentMeleeWeaponGrabbedInfo.weaponStored != null) {
|
|
|
|
hideWeaponMeshResult = checkIfHideWeaponMeshWhenNotUsed (currentMeleeWeaponGrabbedInfo.hideWeaponMeshWhenNotUsed);
|
|
|
|
if (!hideWeaponMeshResult) {
|
|
checkObjectMeshToEnableOrDisable (false, currentMeleeWeaponGrabbedInfo);
|
|
}
|
|
|
|
currentMeleeWeaponGrabbedInfo.weaponStored.transform.position = mainGrabObjects.transform.position + mainGrabObjects.transform.up + mainGrabObjects.transform.forward;
|
|
|
|
if (!currentMeleeWeaponGrabbedInfo.weaponStored.activeSelf) {
|
|
currentMeleeWeaponGrabbedInfo.weaponStored.SetActive (true);
|
|
}
|
|
}
|
|
|
|
meleeWeaponGrabbedInfoList.RemoveAt (i);
|
|
}
|
|
}
|
|
|
|
currentNumberOfWeaponsAvailable = getCurrentNumberOfWeaponsAvailable ();
|
|
|
|
currentWeaponIndex = meleeWeaponGrabbedInfoList.Count - 1;
|
|
}
|
|
|
|
if (storePickedWeaponsOnInventory && !equipMeleeWeaponPaused) {
|
|
if (showDebugPrint) {
|
|
print ("ADD MELEE WEAPON TO INVENTORY " + weaponName);
|
|
}
|
|
|
|
mainInventoryManager.addObjectAmountToInventoryByName (weaponName, 1);
|
|
|
|
if (!meleeWeaponsGrabbedManagerActive) {
|
|
mainInventoryManager.checkQuickAccessSlotToSelectByName (weaponName);
|
|
|
|
// if (useEventsOnMeleeWeaponEquipped) {
|
|
// eventOnMeleeWeaponEquipped.Invoke ();
|
|
// }
|
|
}
|
|
|
|
if (!mainGrabbedObjectMeleeAttackSystem.ignoreUseDrawKeepWeaponAnimation) {
|
|
meleeWeaponGrabbedInfo currentMeleeWeaponGrabbedInfo = meleeWeaponGrabbedInfoList [currentWeaponIndex];
|
|
|
|
activateDrawkeepMeleeWeaponAnimation (currentMeleeWeaponGrabbedInfo, false);
|
|
}
|
|
}
|
|
|
|
equipMeleeWeaponPaused = false;
|
|
} else {
|
|
print ("WARNING: melee weapon prefab with the name " + weaponName + " not found, make sure to configure a weapon" +
|
|
" with that info.");
|
|
}
|
|
} else {
|
|
for (int k = 0; k < meleeWeaponGrabbedInfoList.Count; k++) {
|
|
if (weaponIndex == k) {
|
|
meleeWeaponGrabbedInfoList [k].isCurrentWeapon = true;
|
|
meleeWeaponGrabbedInfoList [k].carryingWeapon = true;
|
|
|
|
currentMeleeWeaponSheathedOrCarried = true;
|
|
} else {
|
|
meleeWeaponGrabbedInfoList [k].isCurrentWeapon = false;
|
|
}
|
|
}
|
|
|
|
currentWeaponIndex = weaponIndex;
|
|
|
|
meleeWeaponGrabbedInfo currentMeleeWeaponGrabbedInfo = meleeWeaponGrabbedInfoList [currentWeaponIndex];
|
|
|
|
if (currentMeleeWeaponGrabbedInfo.weaponStored != weaponGameObject) {
|
|
|
|
bool hideWeaponMeshResult = checkIfHideWeaponMeshWhenNotUsed (currentMeleeWeaponGrabbedInfo.hideWeaponMeshWhenNotUsed);
|
|
|
|
if (!hideWeaponMeshResult) {
|
|
checkObjectMeshToEnableOrDisable (false, currentMeleeWeaponGrabbedInfo);
|
|
}
|
|
|
|
currentMeleeWeaponGrabbedInfo.weaponStored.transform.position = mainGrabObjects.transform.position + mainGrabObjects.transform.up + mainGrabObjects.transform.forward;
|
|
|
|
if (!currentMeleeWeaponGrabbedInfo.weaponStored.activeSelf) {
|
|
currentMeleeWeaponGrabbedInfo.weaponStored.SetActive (true);
|
|
}
|
|
|
|
currentMeleeWeaponGrabbedInfo.weaponStored = weaponGameObject;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void checkToDropWeaponFromList (string weaponName)
|
|
{
|
|
for (int k = 0; k < meleeWeaponGrabbedInfoList.Count; k++) {
|
|
meleeWeaponGrabbedInfo currentMeleeWeaponGrabbedInfo = meleeWeaponGrabbedInfoList [k];
|
|
|
|
if (currentMeleeWeaponGrabbedInfo.Name.Equals (weaponName)) {
|
|
|
|
bool objectIsThrown = false;
|
|
|
|
bool ignoreRemoveWeaponFromList = false;
|
|
|
|
if (storePickedWeaponsOnInventory && mainInventoryManager != null) {
|
|
if (currentMeleeWeaponGrabbedInfo.weaponStored != null) {
|
|
grabPhysicalObjectMeleeAttackSystem currentGrabPhysicalObjectMeleeAttackSystem =
|
|
currentMeleeWeaponGrabbedInfo.weaponStored.GetComponent<grabPhysicalObjectMeleeAttackSystem> ();
|
|
|
|
if (currentGrabPhysicalObjectMeleeAttackSystem.isObjectThrown ()) {
|
|
objectIsThrown = true;
|
|
} else {
|
|
if (currentMeleeWeaponGrabbedInfo.weaponStored.activeSelf) {
|
|
currentMeleeWeaponGrabbedInfo.weaponStored.SetActive (false);
|
|
}
|
|
|
|
ignoreRemoveWeaponFromList = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (currentMeleeWeaponGrabbedInfo.isCurrentWeapon) {
|
|
currentMeleeWeaponSheathedOrCarried = false;
|
|
}
|
|
|
|
if (ignoreRemoveWeaponFromList) {
|
|
currentMeleeWeaponGrabbedInfo.isCurrentWeapon = false;
|
|
currentMeleeWeaponGrabbedInfo.carryingWeapon = false;
|
|
} else {
|
|
meleeWeaponGrabbedInfoList.RemoveAt (k);
|
|
}
|
|
|
|
if (meleeWeaponGrabbedInfoList.Count == 0) {
|
|
currentMeleeWeaponSheathedOrCarried = false;
|
|
} else {
|
|
if (getCurrentNumberOfWeaponsAvailable () == 0) {
|
|
currentMeleeWeaponSheathedOrCarried = false;
|
|
}
|
|
}
|
|
|
|
if (storePickedWeaponsOnInventory && mainInventoryManager != null) {
|
|
|
|
if (mainGrabbedObjectMeleeAttackSystem.checkDurabilityOnAttackEnabled || mainGrabbedObjectMeleeAttackSystem.checkDurabilityOnBlockEnabled) {
|
|
if (currentMeleeWeaponGrabbedInfo.weaponStored != null) {
|
|
grabPhysicalObjectMeleeAttackSystem currentGrabPhysicalObjectMeleeAttackSystem = currentMeleeWeaponGrabbedInfo.weaponStored.GetComponent<grabPhysicalObjectMeleeAttackSystem> ();
|
|
|
|
if (currentGrabPhysicalObjectMeleeAttackSystem != null) {
|
|
lastDroppeWeaponDurabilityStored = true;
|
|
|
|
lastDroppedWeaponName = currentMeleeWeaponGrabbedInfo.Name;
|
|
|
|
lastDroppedWeaponDurabilityValue = currentGrabPhysicalObjectMeleeAttackSystem.getDurabilityAmount ();
|
|
}
|
|
}
|
|
}
|
|
|
|
if (objectIsThrown) {
|
|
if (showDebugPrint) {
|
|
print ("object is thrown, remove the weapon from inventory without instantiate a pickup");
|
|
}
|
|
|
|
mainInventoryManager.dropEquipByName (weaponName, 1, false, false);
|
|
} else {
|
|
if (showDebugPrint) {
|
|
print ("object is not thrown, remove the weapon from inventory and instantiate a pickup");
|
|
}
|
|
|
|
bool objectLocatedOnInventory = false;
|
|
|
|
if (showDebugPrint) {
|
|
print (mainInventoryManager.getInventoryObjectAmountByName (weaponName));
|
|
}
|
|
|
|
int amountOfWeaponOnInventory = mainInventoryManager.getInventoryObjectAmountByName (weaponName);
|
|
|
|
if (amountOfWeaponOnInventory >= 1) {
|
|
objectLocatedOnInventory = true;
|
|
}
|
|
|
|
mainInventoryManager.dropEquipByName (weaponName, 1, true, false);
|
|
|
|
if (!objectLocatedOnInventory) {
|
|
if (!currentMeleeWeaponGrabbedInfo.weaponStored.activeSelf) {
|
|
currentMeleeWeaponGrabbedInfo.weaponStored.SetActive (true);
|
|
}
|
|
}
|
|
|
|
//Check here about unequipping melee weapons when carrying more of the same type
|
|
if (amountOfWeaponOnInventory > 1) {
|
|
mainInventoryManager.unEquipObjectByName (weaponName);
|
|
}
|
|
|
|
GameObject pickupDropped = mainInventoryManager.getLastObjectDropped ();
|
|
|
|
if (pickupDropped != null) {
|
|
Rigidbody currentPickupRigidbody = pickupDropped.GetComponentInChildren<Rigidbody> ();
|
|
|
|
if (currentPickupRigidbody != null) {
|
|
Vector3 lastDropForceDirection = mainGrabbedObjectMeleeAttackSystem.mainGrabObjects.getThrowDirection ();
|
|
|
|
lastDropForceDirection *= mainGrabbedObjectMeleeAttackSystem.mainGrabObjects.getLastHoldTimer ();
|
|
|
|
currentPickupRigidbody.AddForce (lastDropForceDirection,
|
|
mainGrabbedObjectMeleeAttackSystem.mainGrabObjects.powerForceMode);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void disableIsCurrentWeaponStateOnAllWeapons ()
|
|
{
|
|
for (int k = 0; k < meleeWeaponGrabbedInfoList.Count; k++) {
|
|
meleeWeaponGrabbedInfoList [k].isCurrentWeapon = false;
|
|
}
|
|
}
|
|
|
|
public bool isCurrentMeleeWeaponSheathedOrCarried ()
|
|
{
|
|
return currentMeleeWeaponSheathedOrCarried;
|
|
}
|
|
|
|
public bool isGrabObjectsEnabled ()
|
|
{
|
|
return mainGrabObjects.isGrabObjectsEnabled ();
|
|
}
|
|
|
|
public bool isCarryingRegularPhysicalObject ()
|
|
{
|
|
return mainGrabObjects.isCarryingRegularPhysicalObject ();
|
|
}
|
|
|
|
public void enableOrDisableMeleeWeaponMeshesOnCharacterBody (bool state)
|
|
{
|
|
if (mainGrabbedObjectMeleeAttackSystem.mainPlayerController.isUsingGenericModelActive ()) {
|
|
if (state) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
int meleeWeaponGrabbedInfoListCount = meleeWeaponGrabbedInfoList.Count;
|
|
|
|
for (int k = 0; k < meleeWeaponGrabbedInfoListCount; k++) {
|
|
if (meleeWeaponGrabbedInfoList [k].carryingWeapon && !meleeWeaponGrabbedInfoList [k].objectThrown) {
|
|
if (meleeWeaponGrabbedInfoList [k].weaponMesh != null) {
|
|
|
|
bool setStateResult = state;
|
|
|
|
if (setStateResult) {
|
|
if (meleeWeaponGrabbedInfoList [k].isCurrentWeapon) {
|
|
setStateResult = false;
|
|
}
|
|
}
|
|
|
|
bool hideWeaponMeshResult = checkIfHideWeaponMeshWhenNotUsed (meleeWeaponGrabbedInfoList [k].hideWeaponMeshWhenNotUsed);
|
|
|
|
if (hideWeaponMeshResult) {
|
|
setStateResult = false;
|
|
}
|
|
|
|
if (meleeWeaponGrabbedInfoList [k].weaponMesh.activeSelf != setStateResult) {
|
|
meleeWeaponGrabbedInfoList [k].weaponMesh.SetActive (setStateResult);
|
|
|
|
if (showDebugPrint) {
|
|
print ("enableOrDisableMeleeWeaponMeshesOnCharacterBody " + state + " " + meleeWeaponGrabbedInfoList [k].Name);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void enableOrDisableMeleeWeaponMeshOnCharacterBodyByNameAndInstantiateMesh (bool state, string weaponName)
|
|
{
|
|
int weaponIndex = meleeWeaponGrabbedInfoList.FindIndex (s => s.Name == weaponName);
|
|
|
|
if (meleeWeaponGrabbedInfoList.Count > weaponIndex && weaponIndex > -1) {
|
|
|
|
meleeWeaponGrabbedInfo currentMeleeWeaponGrabbedInfo = meleeWeaponGrabbedInfoList [weaponIndex];
|
|
|
|
bool hideWeaponMeshResult = checkIfHideWeaponMeshWhenNotUsed (currentMeleeWeaponGrabbedInfo.hideWeaponMeshWhenNotUsed);
|
|
|
|
bool setEnableStateResult = state;
|
|
|
|
if (setEnableStateResult) {
|
|
if (hideWeaponMeshResult) {
|
|
setEnableStateResult = false;
|
|
}
|
|
}
|
|
|
|
checkObjectMeshToEnableOrDisable (setEnableStateResult, currentMeleeWeaponGrabbedInfo);
|
|
}
|
|
}
|
|
|
|
public bool checkIfHideWeaponMeshWhenNotUsedByName (string weaponNameToSearch)
|
|
{
|
|
int weaponIndex = meleeWeaponGrabbedInfoList.FindIndex (s => s.Name == weaponNameToSearch);
|
|
|
|
if (weaponIndex > -1) {
|
|
if (meleeWeaponGrabbedInfoList [weaponIndex].carryingWeapon && meleeWeaponGrabbedInfoList [weaponIndex].weaponMesh != null) {
|
|
return checkIfHideWeaponMeshWhenNotUsed (meleeWeaponGrabbedInfoList [weaponIndex].hideWeaponMeshWhenNotUsed);
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public bool checkIfHideShieldMeshWhenNotUsedByName (string shieldNameToSearch)
|
|
{
|
|
int weaponIndex = shieldGrabbedInfoList.FindIndex (s => s.Name == shieldNameToSearch);
|
|
|
|
if (weaponIndex > -1) {
|
|
if (shieldGrabbedInfoList [weaponIndex].carryingShield && shieldGrabbedInfoList [weaponIndex].shieldStored != null) {
|
|
return checkIfHideWeaponMeshWhenNotUsed (shieldGrabbedInfoList [weaponIndex].hideWeaponMeshWhenNotUsed);
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public void enableOrDisableMeleeWeaponMeshOnCharacterBodyByName (bool state, string weaponNameToSearch)
|
|
{
|
|
int weaponIndex = meleeWeaponGrabbedInfoList.FindIndex (s => s.Name == weaponNameToSearch);
|
|
|
|
if (weaponIndex > -1) {
|
|
if (meleeWeaponGrabbedInfoList [weaponIndex].carryingWeapon && meleeWeaponGrabbedInfoList [weaponIndex].weaponMesh != null) {
|
|
if (meleeWeaponGrabbedInfoList [weaponIndex].weaponMesh.activeSelf != state) {
|
|
meleeWeaponGrabbedInfoList [weaponIndex].weaponMesh.SetActive (state);
|
|
|
|
if (showDebugPrint) {
|
|
print ("enableOrDisableMeleeWeaponMeshOnCharacterBodyByName " + state + " " + meleeWeaponGrabbedInfoList [weaponIndex].Name);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void enableOrDisableAllMeleeWeaponMeshesOnCharacterBody (bool state)
|
|
{
|
|
for (int k = 0; k < meleeWeaponGrabbedInfoList.Count; k++) {
|
|
if (meleeWeaponGrabbedInfoList [k].carryingWeapon && !meleeWeaponGrabbedInfoList [k].objectThrown) {
|
|
if (meleeWeaponGrabbedInfoList [k].weaponMesh != null) {
|
|
if (state) {
|
|
if (!meleeWeaponGrabbedInfoList [k].isCurrentWeapon) {
|
|
if (meleeWeaponGrabbedInfoList [k].weaponMesh.activeSelf != state) {
|
|
meleeWeaponGrabbedInfoList [k].weaponMesh.SetActive (state);
|
|
|
|
if (showDebugPrint) {
|
|
print ("enableOrDisableAllMeleeWeaponMeshesOnCharacterBody " + state + " " + meleeWeaponGrabbedInfoList [k].Name);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
if (meleeWeaponGrabbedInfoList [k].weaponMesh.activeSelf != state) {
|
|
meleeWeaponGrabbedInfoList [k].weaponMesh.SetActive (state);
|
|
|
|
if (showDebugPrint) {
|
|
print ("enableOrDisableAllMeleeWeaponMeshesOnCharacterBody " + state + " " + meleeWeaponGrabbedInfoList [k].Name);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void enableOrDisableAllMeleeWeaponMeshesOnCharacterBodyCheckingIfHiddingMeshes (bool state)
|
|
{
|
|
for (int k = 0; k < meleeWeaponGrabbedInfoList.Count; k++) {
|
|
if (meleeWeaponGrabbedInfoList [k].carryingWeapon && !meleeWeaponGrabbedInfoList [k].objectThrown) {
|
|
if (meleeWeaponGrabbedInfoList [k].weaponMesh != null) {
|
|
if (state) {
|
|
if (!meleeWeaponGrabbedInfoList [k].isCurrentWeapon) {
|
|
bool weaponMeshActiveResult = state;
|
|
|
|
bool hideWeaponMeshResult = checkIfHideWeaponMeshWhenNotUsed (meleeWeaponGrabbedInfoList [k].hideWeaponMeshWhenNotUsed);
|
|
|
|
if (hideWeaponMeshResult) {
|
|
weaponMeshActiveResult = false;
|
|
}
|
|
|
|
if (meleeWeaponGrabbedInfoList [k].weaponMesh.activeSelf != weaponMeshActiveResult) {
|
|
meleeWeaponGrabbedInfoList [k].weaponMesh.SetActive (weaponMeshActiveResult);
|
|
|
|
if (showDebugPrint) {
|
|
print ("enableOrDisableAllMeleeWeaponMeshesOnCharacterBody " + weaponMeshActiveResult + " " + meleeWeaponGrabbedInfoList [k].Name);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
if (meleeWeaponGrabbedInfoList [k].weaponMesh.activeSelf != state) {
|
|
meleeWeaponGrabbedInfoList [k].weaponMesh.SetActive (state);
|
|
|
|
if (showDebugPrint) {
|
|
print ("enableOrDisableAllMeleeWeaponMeshesOnCharacterBody " + state + " " + meleeWeaponGrabbedInfoList [k].Name);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void enableOrDisableAllMeleeWeaponShieldMeshesOnCharacterBody (bool state)
|
|
{
|
|
int shieldGrabbedInfoListCount = shieldGrabbedInfoList.Count;
|
|
|
|
for (int k = 0; k < shieldGrabbedInfoListCount; k++) {
|
|
shieldGrabbedInfo currentShieldInfo = shieldGrabbedInfoList [k];
|
|
|
|
if (currentShieldInfo.carryingShield && currentShieldInfo.shieldStored != null) {
|
|
if (state) {
|
|
if (!currentShieldInfo.isCurrentShield) {
|
|
if (currentShieldInfo.shieldStored.activeSelf != state) {
|
|
currentShieldInfo.shieldStored.SetActive (state);
|
|
|
|
if (showDebugPrint) {
|
|
print (state);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
if (currentShieldInfo.shieldStored.activeSelf != state) {
|
|
currentShieldInfo.shieldStored.SetActive (state);
|
|
|
|
if (showDebugPrint) {
|
|
print (state);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void enableOrDisableAllMeleeWeaponShieldMeshesOnCharacterBodyCheckingIfHiddingMeshes (bool state)
|
|
{
|
|
int shieldGrabbedInfoListCount = shieldGrabbedInfoList.Count;
|
|
|
|
for (int k = 0; k < shieldGrabbedInfoListCount; k++) {
|
|
shieldGrabbedInfo currentShieldInfo = shieldGrabbedInfoList [k];
|
|
|
|
if (currentShieldInfo.carryingShield && currentShieldInfo.shieldStored != null) {
|
|
if (state) {
|
|
if (!currentShieldInfo.isCurrentShield) {
|
|
bool weaponMeshActiveResult = state;
|
|
|
|
bool hideWeaponMeshResult = checkIfHideWeaponMeshWhenNotUsed (currentShieldInfo.hideWeaponMeshWhenNotUsed);
|
|
|
|
if (hideWeaponMeshResult) {
|
|
weaponMeshActiveResult = false;
|
|
}
|
|
|
|
if (currentShieldInfo.shieldStored.activeSelf != weaponMeshActiveResult) {
|
|
currentShieldInfo.shieldStored.SetActive (weaponMeshActiveResult);
|
|
|
|
if (showDebugPrint) {
|
|
print (weaponMeshActiveResult);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
if (currentShieldInfo.shieldStored.activeSelf != state) {
|
|
currentShieldInfo.shieldStored.SetActive (state);
|
|
|
|
if (showDebugPrint) {
|
|
print (state);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool characterIsCarryingWeapon ()
|
|
{
|
|
return meleeWeaponsGrabbedManagerActive && mainGrabbedObjectMeleeAttackSystem.isCarryingObject ();
|
|
}
|
|
|
|
public float getLastTimeDrawMeleeWeapon ()
|
|
{
|
|
return mainGrabbedObjectMeleeAttackSystem.getLastTimeDrawMeleeWeapon ();
|
|
}
|
|
|
|
//INVENTORY FUNCTIONS
|
|
public bool equipMeleeWeapon (string weaponNameToSearch, bool checkIfWeaponNotFound, bool ignoreDrawMeleeWeapon)
|
|
{
|
|
if (!mainGrabbedObjectMeleeAttackSystem.isGrabbedObjectMeleeAttackEnabled () || !mainGrabbedObjectMeleeAttackSystem.isCanGrabMeleeObjectsEnabled ()) {
|
|
return false;
|
|
}
|
|
|
|
int weaponIndex = meleeWeaponGrabbedInfoList.FindIndex (s => s.Name == weaponNameToSearch);
|
|
|
|
equipMeleeWeaponPaused = true;
|
|
|
|
if (weaponIndex > -1) {
|
|
meleeWeaponGrabbedInfo currentMeleeWeaponGrabbedInfo = meleeWeaponGrabbedInfoList [weaponIndex];
|
|
|
|
if (currentMeleeWeaponGrabbedInfo.isCurrentWeapon) {
|
|
return true;
|
|
} else {
|
|
if (mainGrabbedObjectMeleeAttackSystem.isCarryingObject ()) {
|
|
|
|
} else {
|
|
if (!ignoreDrawMeleeWeapon) {
|
|
|
|
checkWeaponByNumber (weaponIndex);
|
|
|
|
if (!meleeWeaponsGrabbedManagerActive) {
|
|
// mainInventoryManager.checkQuickAccessSlotToSelectByName (weaponNameToSearch);
|
|
|
|
// if (useEventsOnMeleeWeaponEquipped) {
|
|
// eventOnMeleeWeaponEquipped.Invoke ();
|
|
// }
|
|
}
|
|
}
|
|
|
|
updateQuickAccesSlotOnInventory (weaponNameToSearch);
|
|
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool weaponEquippedCorrectly = false;
|
|
|
|
bool canSearchWeapon = true;
|
|
|
|
if (showDebugPrint) {
|
|
print (weaponNameToSearch);
|
|
}
|
|
|
|
weaponIndex = meleeWeaponGrabbedInfoList.FindIndex (s => s.Name == weaponNameToSearch);
|
|
|
|
if (checkIfWeaponNotFound) {
|
|
if (weaponIndex == -1) {
|
|
canSearchWeapon = false;
|
|
}
|
|
}
|
|
|
|
if (canSearchWeapon) {
|
|
if (weaponIndex > -1 && meleeWeaponGrabbedInfoList [weaponIndex].weaponInstantiated) {
|
|
if (showDebugPrint) {
|
|
print ("check weapon by number");
|
|
}
|
|
|
|
weaponEquippedCorrectly = true;
|
|
} else {
|
|
if (showDebugPrint) {
|
|
print ("instantiate new weapon");
|
|
}
|
|
|
|
int weaponPrefabIndex = meleeWeaponPrefabInfoList.FindIndex (s => s.Name == weaponNameToSearch);
|
|
|
|
if (weaponPrefabIndex > -1) {
|
|
meleeWeaponPrefabInfo currentMeleeWeaponPrefabInfo = meleeWeaponPrefabInfoList [weaponPrefabIndex];
|
|
|
|
GameObject newWeaponToCarry = (GameObject)Instantiate (currentMeleeWeaponPrefabInfo.weaponPrefab, Vector3.up * 1000, Quaternion.identity);
|
|
|
|
meleeWeaponGrabbedInfo newMeleeWeaponGrabbedInfo = new meleeWeaponGrabbedInfo ();
|
|
newMeleeWeaponGrabbedInfo.Name = weaponNameToSearch;
|
|
|
|
newMeleeWeaponGrabbedInfo.weaponPrefabIndex = currentMeleeWeaponPrefabInfo.weaponPrefabIndex;
|
|
|
|
newMeleeWeaponGrabbedInfo.weaponStored = newWeaponToCarry;
|
|
|
|
newMeleeWeaponGrabbedInfo.carryingWeapon = true;
|
|
|
|
if (newMeleeWeaponGrabbedInfo.weaponStored.activeSelf) {
|
|
newMeleeWeaponGrabbedInfo.weaponStored.SetActive (false);
|
|
}
|
|
|
|
newMeleeWeaponGrabbedInfo.weaponInstantiated = true;
|
|
|
|
grabPhysicalObjectMeleeAttackSystem currentGrabPhysicalObjectMeleeAttackSystem = newMeleeWeaponGrabbedInfo.weaponStored.GetComponent<grabPhysicalObjectMeleeAttackSystem> ();
|
|
|
|
bool hideWeaponMeshResult = checkIfHideWeaponMeshWhenNotUsed (currentGrabPhysicalObjectMeleeAttackSystem.hideWeaponMeshWhenNotUsed);
|
|
|
|
newMeleeWeaponGrabbedInfo.hideWeaponMeshWhenNotUsed = hideWeaponMeshResult;
|
|
|
|
meleeWeaponGrabbedInfoList.Add (newMeleeWeaponGrabbedInfo);
|
|
|
|
weaponEquippedCorrectly = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
equipMeleeWeaponPaused = false;
|
|
|
|
if (weaponEquippedCorrectly) {
|
|
|
|
updateQuickAccesSlotOnInventory (weaponNameToSearch);
|
|
}
|
|
|
|
return weaponEquippedCorrectly;
|
|
}
|
|
|
|
void updateQuickAccesSlotOnInventory (string weaponNameToSearch)
|
|
{
|
|
if (storePickedWeaponsOnInventory) {
|
|
mainInventoryManager.showWeaponSlotsParentWhenWeaponSelectedByName (weaponNameToSearch);
|
|
}
|
|
}
|
|
|
|
public bool unEquipMeleeWeapon (string weaponNameToSearch, bool dropWeaponObject)
|
|
{
|
|
int weaponIndex = meleeWeaponGrabbedInfoList.FindIndex (s => s.Name == weaponNameToSearch);
|
|
|
|
if (weaponIndex > -1) {
|
|
meleeWeaponGrabbedInfo currentMeleeWeaponGrabbedInfo = meleeWeaponGrabbedInfoList [weaponIndex];
|
|
|
|
if (currentMeleeWeaponGrabbedInfo.weaponStored != null) {
|
|
if (currentMeleeWeaponGrabbedInfo.isCurrentWeapon) {
|
|
mainGrabbedObjectMeleeAttackSystem.setRemoveWeaponsFromManagerState (false);
|
|
|
|
mainGrabObjects.grabbed = true;
|
|
|
|
mainGrabObjects.checkIfDropObject (currentMeleeWeaponGrabbedInfo.weaponStored);
|
|
} else {
|
|
currentMeleeWeaponGrabbedInfo.weaponStored.transform.position = mainGrabObjects.transform.position + mainGrabObjects.transform.up + mainGrabObjects.transform.forward;
|
|
}
|
|
|
|
bool hideWeaponMeshResult = checkIfHideWeaponMeshWhenNotUsed (currentMeleeWeaponGrabbedInfo.hideWeaponMeshWhenNotUsed);
|
|
|
|
if (!hideWeaponMeshResult) {
|
|
checkObjectMeshToEnableOrDisable (false, currentMeleeWeaponGrabbedInfo);
|
|
}
|
|
|
|
mainGrabObjects.removeCurrentPhysicalObjectToGrabFound (currentMeleeWeaponGrabbedInfo.weaponStored);
|
|
|
|
if (currentMeleeWeaponGrabbedInfo.weaponStored.activeSelf != dropWeaponObject) {
|
|
currentMeleeWeaponGrabbedInfo.weaponStored.SetActive (dropWeaponObject);
|
|
}
|
|
|
|
mainGrabbedObjectMeleeAttackSystem.setRemoveWeaponsFromManagerState (true);
|
|
}
|
|
|
|
currentMeleeWeaponGrabbedInfo.isCurrentWeapon = false;
|
|
|
|
currentMeleeWeaponGrabbedInfo.carryingWeapon = false;
|
|
|
|
currentMeleeWeaponSheathedOrCarried = false;
|
|
|
|
currentNumberOfWeaponsAvailable = getCurrentNumberOfWeaponsAvailable ();
|
|
|
|
currentWeaponIndex = meleeWeaponGrabbedInfoList.Count - 1;
|
|
|
|
bool currentWeaponIndexFound = false;
|
|
|
|
for (int i = meleeWeaponGrabbedInfoList.Count - 1; i >= 0; i--) {
|
|
if (!currentWeaponIndexFound) {
|
|
if (meleeWeaponGrabbedInfoList [i].carryingWeapon) {
|
|
currentWeaponIndex = i;
|
|
|
|
currentWeaponIndexFound = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (currentWeaponIndex < 0) {
|
|
currentWeaponIndex = 0;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public bool checkWeaponToSelectOnQuickAccessSlots (string weaponName)
|
|
{
|
|
int weaponIndex = meleeWeaponGrabbedInfoList.FindIndex (s => s.Name == weaponName);
|
|
|
|
if (weaponIndex > -1) {
|
|
meleeWeaponGrabbedInfo currentMeleeWeaponGrabbedInfo = meleeWeaponGrabbedInfoList [weaponIndex];
|
|
|
|
checkWeaponByNumber (weaponIndex);
|
|
|
|
mainGrabbedObjectMeleeAttackSystem.checkEventWhenKeepingOrDrawingMeleeWeapon (false);
|
|
|
|
if (currentMeleeWeaponGrabbedInfo.isCurrentWeapon) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public Transform getCurrentGrabbedObjectTransform ()
|
|
{
|
|
if (characterIsCarryingWeapon ()) {
|
|
return mainGrabbedObjectMeleeAttackSystem.getCurrentGrabbedObjectTransform ();
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public bool isMeleeWeaponsGrabbedManagerActive ()
|
|
{
|
|
return meleeWeaponsGrabbedManagerActive;
|
|
}
|
|
|
|
public string getCurrentWeaponName ()
|
|
{
|
|
for (int k = 0; k < meleeWeaponGrabbedInfoList.Count; k++) {
|
|
if (meleeWeaponGrabbedInfoList [k].isCurrentWeapon) {
|
|
return meleeWeaponGrabbedInfoList [k].Name;
|
|
}
|
|
}
|
|
|
|
return "";
|
|
}
|
|
|
|
public string getCurrentShieldName ()
|
|
{
|
|
for (int k = 0; k < shieldGrabbedInfoList.Count; k++) {
|
|
if (shieldGrabbedInfoList [k].isCurrentShield) {
|
|
return shieldGrabbedInfoList [k].Name;
|
|
}
|
|
}
|
|
|
|
return "";
|
|
}
|
|
|
|
public string getEmptyWeaponToUseOnlyShield ()
|
|
{
|
|
return mainGrabbedObjectMeleeAttackSystem.getEmptyWeaponToUseOnlyShield ();
|
|
}
|
|
|
|
public GameObject getCurrentWeaponMeshByName (string weaponName)
|
|
{
|
|
for (int k = 0; k < meleeWeaponGrabbedInfoList.Count; k++) {
|
|
if (meleeWeaponGrabbedInfoList [k].Name.Equals (weaponName)) {
|
|
return meleeWeaponGrabbedInfoList [k].weaponMesh;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public bool isWeaponInGrabbedInfoList (string weaponName)
|
|
{
|
|
int weaponIndex = meleeWeaponGrabbedInfoList.FindIndex (s => s.Name == weaponName);
|
|
|
|
if (weaponIndex > -1) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public string getCurrentWeaponActiveName ()
|
|
{
|
|
if (meleeWeaponGrabbedInfoList.Count > 0 && currentWeaponIndex < meleeWeaponGrabbedInfoList.Count) {
|
|
return meleeWeaponGrabbedInfoList [currentWeaponIndex].Name;
|
|
}
|
|
|
|
return "";
|
|
}
|
|
|
|
public bool equipShield (string shieldName)
|
|
{
|
|
return setShieldActiveState (true, shieldName);
|
|
}
|
|
|
|
public bool unequipeShield (string shieldName)
|
|
{
|
|
bool unequipResult = setShieldActiveState (false, shieldName);
|
|
|
|
int shieldInfoIndex = shieldGrabbedInfoList.FindIndex (s => s.Name == shieldName);
|
|
|
|
if (shieldInfoIndex > -1) {
|
|
if (shieldGrabbedInfoList [shieldInfoIndex].shieldStored != null) {
|
|
if (shieldGrabbedInfoList [shieldInfoIndex].shieldStored.activeSelf) {
|
|
shieldGrabbedInfoList [shieldInfoIndex].shieldStored.SetActive (false);
|
|
}
|
|
|
|
shieldGrabbedInfoList [shieldInfoIndex].isCurrentShield = false;
|
|
|
|
shieldGrabbedInfoList [shieldInfoIndex].carryingShield = false;
|
|
}
|
|
|
|
string emptyShieldWeaponName = getEmptyWeaponToUseOnlyShield ();
|
|
|
|
int weaponIndex = meleeWeaponGrabbedInfoList.FindIndex (s => s.Name == emptyShieldWeaponName);
|
|
|
|
if (weaponIndex > -1) {
|
|
if (meleeWeaponGrabbedInfoList [weaponIndex].weaponStored != null) {
|
|
if (meleeWeaponGrabbedInfoList [weaponIndex].weaponStored.activeSelf) {
|
|
meleeWeaponGrabbedInfoList [weaponIndex].weaponStored.SetActive (false);
|
|
}
|
|
|
|
meleeWeaponGrabbedInfoList [weaponIndex].isCurrentWeapon = false;
|
|
|
|
meleeWeaponGrabbedInfoList [weaponIndex].carryingWeapon = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
return unequipResult;
|
|
}
|
|
//END INVENTORY FUNCTIONS
|
|
|
|
|
|
//START SHIELD FUNCTIONS
|
|
public bool setShieldActiveState (bool state, string shieldName)
|
|
{
|
|
// print (shieldName + " " + state);
|
|
|
|
int shieldInfoIndex = shieldGrabbedInfoList.FindIndex (s => s.Name == shieldName);
|
|
|
|
int shieldPrefabIndex = shieldPrefabInfoList.FindIndex (s => s.Name == shieldName);
|
|
|
|
if (shieldInfoIndex == -1) {
|
|
if (shieldPrefabIndex > -1) {
|
|
|
|
shieldPrefabInfo currentShieldPrefabInfo = shieldPrefabInfoList [shieldPrefabIndex];
|
|
|
|
GameObject newWeaponToCarry = (GameObject)Instantiate (currentShieldPrefabInfo.shieldPrefab, Vector3.up * 1000, Quaternion.identity);
|
|
|
|
shieldGrabbedInfo newShieldGrabbedInfo = new shieldGrabbedInfo ();
|
|
newShieldGrabbedInfo.Name = shieldName;
|
|
|
|
newShieldGrabbedInfo.shieldInstantiated = true;
|
|
|
|
newShieldGrabbedInfo.shieldPrefabIndex = currentShieldPrefabInfo.shieldPrefabIndex;
|
|
|
|
newShieldGrabbedInfo.shieldStored = newWeaponToCarry;
|
|
|
|
newShieldGrabbedInfo.carryingShield = true;
|
|
|
|
newShieldGrabbedInfo.mainMeleeShieldObjectSystem = newWeaponToCarry.GetComponent<meleeShieldObjectSystem> ();
|
|
|
|
if (newShieldGrabbedInfo.mainMeleeShieldObjectSystem != null) {
|
|
newShieldGrabbedInfo.mainMeleeShieldObjectSystem.setCurrentCharacter (playerGameObject);
|
|
|
|
newShieldGrabbedInfo.mainMeleeShieldObjectSystemLocated = true;
|
|
|
|
newShieldGrabbedInfo.shieldCarriedOnRightArm = newShieldGrabbedInfo.mainMeleeShieldObjectSystem.shieldCarriedOnRightArm;
|
|
}
|
|
|
|
newShieldGrabbedInfo.equipShieldWhenPickedIfNotShieldEquippedPrevioulsy = currentShieldPrefabInfo.equipShieldWhenPickedIfNotShieldEquippedPrevioulsy;
|
|
|
|
bool hideWeaponMeshResult = false;
|
|
|
|
if (newShieldGrabbedInfo.mainMeleeShieldObjectSystemLocated) {
|
|
hideWeaponMeshResult = checkIfHideWeaponMeshWhenNotUsed (newShieldGrabbedInfo.mainMeleeShieldObjectSystem.hideWeaponMeshWhenNotUsed);
|
|
}
|
|
|
|
newShieldGrabbedInfo.hideWeaponMeshWhenNotUsed = hideWeaponMeshResult;
|
|
|
|
shieldGrabbedInfoList.Add (newShieldGrabbedInfo);
|
|
|
|
shieldInfoIndex = shieldGrabbedInfoList.Count - 1;
|
|
}
|
|
}
|
|
|
|
if (shieldInfoIndex > -1) {
|
|
int shieldGrabbedInfoListCount = shieldGrabbedInfoList.Count;
|
|
|
|
for (int k = 0; k < shieldGrabbedInfoListCount; k++) {
|
|
shieldGrabbedInfo currentShieldInfo = shieldGrabbedInfoList [k];
|
|
|
|
if (k == shieldInfoIndex) {
|
|
currentShieldGrabbedInfo = currentShieldInfo;
|
|
|
|
if (!currentShieldGrabbedInfo.isCurrentShield) {
|
|
if (currentShieldGrabbedInfo.useEventsOnEquipShieldChangeState) {
|
|
if (state) {
|
|
currentShieldGrabbedInfo.eventOnUnequippShield.Invoke ();
|
|
} else {
|
|
currentShieldGrabbedInfo.eventOnEquipShield.Invoke ();
|
|
}
|
|
}
|
|
}
|
|
|
|
currentShieldGrabbedInfo.isCurrentShield = true;
|
|
|
|
currentShieldGrabbedInfo.carryingShield = true;
|
|
|
|
if (currentShieldGrabbedInfo.shieldStored.activeSelf != state) {
|
|
currentShieldGrabbedInfo.shieldStored.SetActive (state);
|
|
}
|
|
} else {
|
|
if (currentShieldInfo.isCurrentShield) {
|
|
if (currentShieldInfo.useEventsOnEquipShieldChangeState) {
|
|
currentShieldInfo.eventOnUnequippShield.Invoke ();
|
|
}
|
|
}
|
|
|
|
currentShieldInfo.isCurrentShield = false;
|
|
|
|
if (currentShieldInfo.shieldStored.activeSelf) {
|
|
currentShieldInfo.shieldStored.SetActive (false);
|
|
}
|
|
}
|
|
}
|
|
|
|
mainGrabbedObjectMeleeAttackSystem.setShieldInfo (currentShieldGrabbedInfo.Name,
|
|
currentShieldGrabbedInfo.shieldStored,
|
|
shieldPrefabInfoList [shieldPrefabIndex].shieldHandMountPointTransformReference,
|
|
shieldPrefabInfoList [shieldPrefabIndex].shieldBackMountPointTransformReference,
|
|
currentShieldGrabbedInfo.shieldCarriedOnRightArm,
|
|
state);
|
|
|
|
mainGrabbedObjectMeleeAttackSystem.setShieldActiveState (state);
|
|
|
|
if (state) {
|
|
// string currentShieldName = getCurrentShieldName ();
|
|
//
|
|
// int weaponIndex = meleeWeaponPrefabInfoList.FindIndex (s => s.Name.Equals (currentShieldName));
|
|
//
|
|
// if (weaponIndex > -1) {
|
|
//
|
|
// grabPhysicalObjectMeleeAttackSystem currentShieldAttackSystem = meleeWeaponPrefabInfoList [weaponIndex].weaponPrefab.GetComponent<grabPhysicalObjectMeleeAttackSystem> ();
|
|
//
|
|
// if (currentShieldAttackSystem != null) {
|
|
// mainGrabbedObjectMeleeAttackSystem.setShieldProtectionValues (currentShieldAttackSystem.blockDamageProtectionAmount, currentShieldAttackSystem.reducedBlockDamageProtectionAmount);
|
|
// }
|
|
// }
|
|
|
|
if (currentShieldGrabbedInfo.mainMeleeShieldObjectSystem != null) {
|
|
mainGrabbedObjectMeleeAttackSystem.setShieldProtectionValues (
|
|
currentShieldGrabbedInfo.mainMeleeShieldObjectSystem.blockDamageProtectionAmount,
|
|
currentShieldGrabbedInfo.mainMeleeShieldObjectSystem.reducedBlockDamageProtectionAmount,
|
|
currentShieldGrabbedInfo.mainMeleeShieldObjectSystem.useMaxBlockRangeAngle,
|
|
currentShieldGrabbedInfo.mainMeleeShieldObjectSystem.maxBlockRangeAngle);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public void checkEquipShieldIfNotCarryingPreviously ()
|
|
{
|
|
if (!mainGrabbedObjectMeleeAttackSystem.carryingShield &&
|
|
(meleeWeaponsGrabbedManagerActive || mainGrabbedObjectMeleeAttackSystem.shieldCanBeUsedWithoutMeleeWeapon)) {
|
|
|
|
string lastInventoryObjectPickedName = mainInventoryManager.getLastInventoryObjectPickedName ();
|
|
|
|
if (lastInventoryObjectPickedName != "") {
|
|
for (int k = 0; k < shieldPrefabInfoList.Count; k++) {
|
|
if (shieldPrefabInfoList [k].equipShieldWhenPickedIfNotShieldEquippedPrevioulsy &&
|
|
shieldPrefabInfoList [k].Name.Equals (lastInventoryObjectPickedName)) {
|
|
|
|
mainInventoryManager.equipObjectByName (lastInventoryObjectPickedName);
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void toggleDrawOrSheatheShield (string shieldName)
|
|
{
|
|
int shieldInfoIndex = shieldGrabbedInfoList.FindIndex (s => s.Name == shieldName);
|
|
|
|
bool shieldState = false;
|
|
|
|
if (shieldInfoIndex > -1) {
|
|
// if (meleeWeaponsGrabbedManagerActive) {
|
|
if (shieldGrabbedInfoList [shieldInfoIndex].isCurrentShield) {
|
|
shieldState = !mainGrabbedObjectMeleeAttackSystem.shieldActive;
|
|
} else {
|
|
shieldState = true;
|
|
}
|
|
// } else {
|
|
// print ("trying to draw the shield when not melee mode active, sending signal to quick access slots");
|
|
//
|
|
// mainInventoryManager.changeToMeleeWeapons (mainGrabbedObjectMeleeAttackSystem.getEmptyWeaponToUseOnlyShield ());
|
|
// }
|
|
} else {
|
|
shieldState = true;
|
|
}
|
|
|
|
if (shieldState) {
|
|
currentMeleeWeaponSheathedOrCarried = false;
|
|
}
|
|
|
|
drawOrSheatheShield (shieldState, shieldName);
|
|
|
|
// print (shieldState + " " + shieldName);
|
|
}
|
|
|
|
public void drawOrSheatheShield (bool state, string shieldName)
|
|
{
|
|
setShieldActiveState (true, shieldName);
|
|
|
|
mainGrabbedObjectMeleeAttackSystem.drawOrSheatheShield (state);
|
|
|
|
if (state) {
|
|
if (!mainGrabbedObjectMeleeAttackSystem.shieldActive && mainGrabbedObjectMeleeAttackSystem.carryingShield) {
|
|
mainGrabbedObjectMeleeAttackSystem.setShieldParentState (false);
|
|
}
|
|
} else {
|
|
mainGrabbedObjectMeleeAttackSystem.setShieldActiveFieldValueDirectly (false);
|
|
}
|
|
}
|
|
//END SHIELD FUNCTIONS
|
|
|
|
public void checkToKeepWeapon ()
|
|
{
|
|
keepWeaponExternally (true);
|
|
}
|
|
|
|
public void checkToKeepWeaponWithoutCheckingInputActive ()
|
|
{
|
|
keepWeaponExternally (false);
|
|
}
|
|
|
|
void keepWeaponExternally (bool checkIfInputActive)
|
|
{
|
|
if (!meleeWeaponsGrabbedManagerActive) {
|
|
return;
|
|
}
|
|
|
|
if (!isGrabObjectsEnabled ()) {
|
|
return;
|
|
}
|
|
|
|
if ((mainGrabbedObjectMeleeAttackSystem.canUseWeaponsInput () || !checkIfInputActive) &&
|
|
!mainGrabbedObjectMeleeAttackSystem.isObjectThrownTravellingToTarget ()) {
|
|
|
|
if (mainGrabbedObjectMeleeAttackSystem.isCarryingObject ()) {
|
|
keepWeapon (currentWeaponIndex);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setStartGameWithWeaponState (bool state)
|
|
{
|
|
startGameWithWeapon = state;
|
|
}
|
|
|
|
public void setStartGameWithWeaponStateFromEditor (bool state)
|
|
{
|
|
setStartGameWithWeaponState (state);
|
|
|
|
updateComponent ();
|
|
}
|
|
|
|
public void setWeaponNameToStartGame (string newName)
|
|
{
|
|
weaponNameToStartGame = newName;
|
|
}
|
|
|
|
public void updateDurabilityAmountStateOnAllObjects ()
|
|
{
|
|
if (mainGrabbedObjectMeleeAttackSystem.checkDurabilityOnAttackEnabled || mainGrabbedObjectMeleeAttackSystem.checkDurabilityOnBlockEnabled) {
|
|
int meleeWeaponGrabbedInfoListCount = meleeWeaponGrabbedInfoList.Count;
|
|
|
|
for (int i = 0; i < meleeWeaponGrabbedInfoListCount; i++) {
|
|
if (meleeWeaponGrabbedInfoList [i].weaponStored != null && meleeWeaponGrabbedInfoList [i].carryingWeapon) {
|
|
grabPhysicalObjectMeleeAttackSystem currentGrabPhysicalObjectMeleeAttackSystem = meleeWeaponGrabbedInfoList [i].weaponStored.GetComponent<grabPhysicalObjectMeleeAttackSystem> ();
|
|
|
|
if (currentGrabPhysicalObjectMeleeAttackSystem != null) {
|
|
currentGrabPhysicalObjectMeleeAttackSystem.updateDurabilityAmountState ();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (mainGrabbedObjectMeleeAttackSystem.checkDurabilityOnBlockEnabled) {
|
|
int shieldGrabbedInfoListCount = shieldGrabbedInfoList.Count;
|
|
|
|
for (int i = 0; i < shieldGrabbedInfoListCount; i++) {
|
|
shieldGrabbedInfo currentShieldInfo = shieldGrabbedInfoList [i];
|
|
|
|
if (currentShieldInfo.shieldStored != null && currentShieldInfo.carryingShield) {
|
|
|
|
if (currentShieldInfo.mainMeleeShieldObjectSystem != null) {
|
|
currentShieldInfo.mainMeleeShieldObjectSystem.updateDurabilityAmountState ();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void updateDurabilityAmountStateOnObjectByName (string weaponName)
|
|
{
|
|
if (mainGrabbedObjectMeleeAttackSystem.checkDurabilityOnAttackEnabled || mainGrabbedObjectMeleeAttackSystem.checkDurabilityOnBlockEnabled) {
|
|
int meleeWeaponGrabbedInfoListCount = meleeWeaponGrabbedInfoList.Count;
|
|
|
|
for (int i = 0; i < meleeWeaponGrabbedInfoListCount; i++) {
|
|
if (meleeWeaponGrabbedInfoList [i].Name.Equals (weaponName) && meleeWeaponGrabbedInfoList [i].weaponStored != null) {
|
|
grabPhysicalObjectMeleeAttackSystem currentGrabPhysicalObjectMeleeAttackSystem = meleeWeaponGrabbedInfoList [i].weaponStored.GetComponent<grabPhysicalObjectMeleeAttackSystem> ();
|
|
|
|
if (currentGrabPhysicalObjectMeleeAttackSystem != null) {
|
|
currentGrabPhysicalObjectMeleeAttackSystem.updateDurabilityAmountState ();
|
|
}
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public float getDurabilityAmountStateOnObjectByName (string weaponName)
|
|
{
|
|
if (mainGrabbedObjectMeleeAttackSystem.checkDurabilityOnAttackEnabled || mainGrabbedObjectMeleeAttackSystem.checkDurabilityOnBlockEnabled) {
|
|
if (lastDroppeWeaponDurabilityStored) {
|
|
lastDroppeWeaponDurabilityStored = false;
|
|
|
|
if (lastDroppedWeaponName.Equals (weaponName)) {
|
|
return lastDroppedWeaponDurabilityValue;
|
|
}
|
|
}
|
|
|
|
int meleeWeaponGrabbedInfoListCount = meleeWeaponGrabbedInfoList.Count;
|
|
|
|
for (int i = 0; i < meleeWeaponGrabbedInfoListCount; i++) {
|
|
if (meleeWeaponGrabbedInfoList [i].Name.Equals (weaponName) && meleeWeaponGrabbedInfoList [i].weaponStored != null) {
|
|
grabPhysicalObjectMeleeAttackSystem currentGrabPhysicalObjectMeleeAttackSystem = meleeWeaponGrabbedInfoList [i].weaponStored.GetComponent<grabPhysicalObjectMeleeAttackSystem> ();
|
|
|
|
if (currentGrabPhysicalObjectMeleeAttackSystem != null) {
|
|
return currentGrabPhysicalObjectMeleeAttackSystem.getDurabilityAmount ();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
public float getDurabilityAmountStateOnObjectShieldByName (string weaponName)
|
|
{
|
|
if (mainGrabbedObjectMeleeAttackSystem.checkDurabilityOnBlockEnabled) {
|
|
// if (lastDroppeWeaponDurabilityStored) {
|
|
// lastDroppeWeaponDurabilityStored = false;
|
|
//
|
|
// if (lastDroppedWeaponName.Equals (weaponName)) {
|
|
// return lastDroppedWeaponDurabilityValue;
|
|
// }
|
|
// }
|
|
|
|
int shieldGrabbedInfoListCount = shieldGrabbedInfoList.Count;
|
|
|
|
for (int i = 0; i < shieldGrabbedInfoListCount; i++) {
|
|
shieldGrabbedInfo currentShieldInfo = shieldGrabbedInfoList [i];
|
|
|
|
if (currentShieldInfo.Name.Equals (weaponName) && currentShieldInfo.shieldStored != null) {
|
|
|
|
if (currentShieldInfo.mainMeleeShieldObjectSystem != null) {
|
|
return currentShieldInfo.mainMeleeShieldObjectSystem.getDurabilityAmount ();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
public void initializeDurabilityValue (float newAmount, string weaponName, int currentObjectIndex)
|
|
{
|
|
if (mainGrabbedObjectMeleeAttackSystem.checkDurabilityOnAttackEnabled || mainGrabbedObjectMeleeAttackSystem.checkDurabilityOnBlockEnabled) {
|
|
int meleeWeaponGrabbedInfoListCount = meleeWeaponGrabbedInfoList.Count;
|
|
|
|
for (int i = 0; i < meleeWeaponGrabbedInfoListCount; i++) {
|
|
if (meleeWeaponGrabbedInfoList [i].Name.Equals (weaponName) && meleeWeaponGrabbedInfoList [i].weaponStored != null) {
|
|
grabPhysicalObjectMeleeAttackSystem currentGrabPhysicalObjectMeleeAttackSystem = meleeWeaponGrabbedInfoList [i].weaponStored.GetComponent<grabPhysicalObjectMeleeAttackSystem> ();
|
|
|
|
if (currentGrabPhysicalObjectMeleeAttackSystem != null) {
|
|
currentGrabPhysicalObjectMeleeAttackSystem.initializeDurabilityValue (newAmount, currentObjectIndex);
|
|
}
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setInventoryObjectIndex (string weaponName, int currentObjectIndex)
|
|
{
|
|
if (mainGrabbedObjectMeleeAttackSystem.checkDurabilityOnAttackEnabled || mainGrabbedObjectMeleeAttackSystem.checkDurabilityOnBlockEnabled) {
|
|
int meleeWeaponGrabbedInfoListCount = meleeWeaponGrabbedInfoList.Count;
|
|
|
|
for (int i = 0; i < meleeWeaponGrabbedInfoListCount; i++) {
|
|
if (meleeWeaponGrabbedInfoList [i].Name.Equals (weaponName) && meleeWeaponGrabbedInfoList [i].weaponStored != null) {
|
|
grabPhysicalObjectMeleeAttackSystem currentGrabPhysicalObjectMeleeAttackSystem = meleeWeaponGrabbedInfoList [i].weaponStored.GetComponent<grabPhysicalObjectMeleeAttackSystem> ();
|
|
|
|
if (currentGrabPhysicalObjectMeleeAttackSystem != null) {
|
|
currentGrabPhysicalObjectMeleeAttackSystem.setInventoryObjectIndex (currentObjectIndex);
|
|
}
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void initializeDurabilityValueOnShield (float newAmount, string shieldName, int currentObjectIndex)
|
|
{
|
|
if (mainGrabbedObjectMeleeAttackSystem.checkDurabilityOnBlockEnabled) {
|
|
int shieldGrabbedInfoListCount = shieldGrabbedInfoList.Count;
|
|
|
|
for (int i = 0; i < shieldGrabbedInfoListCount; i++) {
|
|
shieldGrabbedInfo currentShieldInfo = shieldGrabbedInfoList [i];
|
|
|
|
if (currentShieldInfo.Name.Equals (shieldName) && currentShieldInfo.shieldStored != null) {
|
|
|
|
if (currentShieldInfo.mainMeleeShieldObjectSystem != null) {
|
|
currentShieldInfo.mainMeleeShieldObjectSystem.initializeDurabilityValue (newAmount, currentObjectIndex);
|
|
}
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setInventoryObjectIndexOnShield (string shieldName, int currentObjectIndex)
|
|
{
|
|
if (mainGrabbedObjectMeleeAttackSystem.checkDurabilityOnBlockEnabled) {
|
|
int shieldGrabbedInfoListCount = shieldGrabbedInfoList.Count;
|
|
|
|
for (int i = 0; i < shieldGrabbedInfoListCount; i++) {
|
|
shieldGrabbedInfo currentShieldInfo = shieldGrabbedInfoList [i];
|
|
|
|
if (currentShieldInfo.Name.Equals (shieldName) && currentShieldInfo.shieldStored != null) {
|
|
|
|
if (currentShieldInfo.mainMeleeShieldObjectSystem != null) {
|
|
currentShieldInfo.mainMeleeShieldObjectSystem.setInventoryObjectIndex (currentObjectIndex);
|
|
}
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void repairObjectFully (string weaponName)
|
|
{
|
|
if (mainGrabbedObjectMeleeAttackSystem.checkDurabilityOnAttackEnabled || mainGrabbedObjectMeleeAttackSystem.checkDurabilityOnBlockEnabled) {
|
|
int meleeWeaponGrabbedInfoListCount = meleeWeaponGrabbedInfoList.Count;
|
|
|
|
for (int i = 0; i < meleeWeaponGrabbedInfoListCount; i++) {
|
|
if (meleeWeaponGrabbedInfoList [i].Name.Equals (weaponName) && meleeWeaponGrabbedInfoList [i].weaponStored != null) {
|
|
grabPhysicalObjectMeleeAttackSystem currentGrabPhysicalObjectMeleeAttackSystem = meleeWeaponGrabbedInfoList [i].weaponStored.GetComponent<grabPhysicalObjectMeleeAttackSystem> ();
|
|
|
|
if (currentGrabPhysicalObjectMeleeAttackSystem != null) {
|
|
currentGrabPhysicalObjectMeleeAttackSystem.repairObjectFully ();
|
|
}
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void repairObjectShieldFully (string weaponName)
|
|
{
|
|
if (mainGrabbedObjectMeleeAttackSystem.checkDurabilityOnBlockEnabled) {
|
|
int shieldGrabbedInfoListCount = shieldGrabbedInfoList.Count;
|
|
|
|
for (int i = 0; i < shieldGrabbedInfoListCount; i++) {
|
|
shieldGrabbedInfo currentShieldInfo = shieldGrabbedInfoList [i];
|
|
|
|
if (currentShieldInfo.Name.Equals (weaponName) && currentShieldInfo.shieldStored != null) {
|
|
|
|
if (currentShieldInfo.mainMeleeShieldObjectSystem != null) {
|
|
currentShieldInfo.mainMeleeShieldObjectSystem.repairObjectFully ();
|
|
}
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void breakFullDurabilityOnCurrentWeapon ()
|
|
{
|
|
if (!characterIsCarryingWeapon ()) {
|
|
return;
|
|
}
|
|
|
|
if (mainGrabbedObjectMeleeAttackSystem.checkDurabilityOnAttackEnabled || mainGrabbedObjectMeleeAttackSystem.checkDurabilityOnBlockEnabled) {
|
|
grabPhysicalObjectMeleeAttackSystem currentGrabPhysicalObjectMeleeAttackSystem = mainGrabbedObjectMeleeAttackSystem.getCurrentGrabPhysicalObjectMeleeAttackSystem ();
|
|
|
|
if (currentGrabPhysicalObjectMeleeAttackSystem != null) {
|
|
currentGrabPhysicalObjectMeleeAttackSystem.breakFullDurabilityOnCurrentWeapon ();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void breakFullDurabilityOnCurrentShield ()
|
|
{
|
|
if (!characterIsCarryingWeapon ()) {
|
|
return;
|
|
}
|
|
|
|
if (mainGrabbedObjectMeleeAttackSystem.checkDurabilityOnBlockEnabled) {
|
|
if (currentShieldGrabbedInfo != null) {
|
|
currentShieldGrabbedInfo.mainMeleeShieldObjectSystem.breakFullDurabilityOnCurrentWeapon ();
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool checkDurabilityOnBlockWithShield (float extraMultiplier)
|
|
{
|
|
if (currentShieldGrabbedInfo != null) {
|
|
return currentShieldGrabbedInfo.mainMeleeShieldObjectSystem.checkDurabilityOnBlockWithShield (extraMultiplier);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public bool checkIfReturnThrowWeaponOrDropItExternally ()
|
|
{
|
|
if (isCurrentWeaponThrown ()) {
|
|
if (dropThrownWeaponIfChangingToAnotherWeaponEnabled) {
|
|
mainGrabbedObjectMeleeAttackSystem.dropMeleeWeaponsExternallyWithoutResult ();
|
|
|
|
return false;
|
|
} else {
|
|
mainGrabbedObjectMeleeAttackSystem.inputThrowOrReturnObject ();
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public void checkIfDropThrownWeaponWhenUsingDevice ()
|
|
{
|
|
if (isCurrentWeaponThrown ()) {
|
|
if (dropThrownWeaponWhenUsingDeviceEnabled) {
|
|
mainGrabbedObjectMeleeAttackSystem.dropMeleeWeaponsExternallyWithoutResult ();
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool isCurrentWeaponThrown ()
|
|
{
|
|
return mainGrabbedObjectMeleeAttackSystem.isCurrentWeaponThrown ();
|
|
}
|
|
|
|
public bool isAimingBowActive ()
|
|
{
|
|
return mainGrabbedObjectMeleeAttackSystem.isAimingBowActive ();
|
|
}
|
|
|
|
public bool isCuttingModeActive ()
|
|
{
|
|
return mainGrabbedObjectMeleeAttackSystem.isCuttingModeActive ();
|
|
}
|
|
|
|
public bool isBlockActive ()
|
|
{
|
|
return mainGrabbedObjectMeleeAttackSystem.isBlockActive ();
|
|
}
|
|
|
|
public bool isDrawWeaponAtStartIfFoundOnInitializingInventoryActive ()
|
|
{
|
|
return drawWeaponAtStartIfFoundOnInitializingInventory;
|
|
}
|
|
|
|
//EDITOR FUNCTIONS
|
|
public void setWeaponNameToStartGameFromEditor (string newName)
|
|
{
|
|
setWeaponNameToStartGame (newName);
|
|
|
|
updateComponent ();
|
|
}
|
|
|
|
public void addNewMeleeWeaponPrefab (GameObject newWeaponPrefab, string newWeaponName, bool useBowWeaponType)
|
|
{
|
|
if (newWeaponPrefab != null) {
|
|
int weaponPrefabIndex = meleeWeaponPrefabInfoList.FindIndex (s => s.Name == newWeaponName);
|
|
|
|
if (weaponPrefabIndex < 0) {
|
|
|
|
meleeWeaponPrefabInfo newMeleeWeaponPrefabInfo = new meleeWeaponPrefabInfo ();
|
|
|
|
newMeleeWeaponPrefabInfo.Name = newWeaponName;
|
|
|
|
newMeleeWeaponPrefabInfo.weaponPrefab = newWeaponPrefab;
|
|
|
|
newMeleeWeaponPrefabInfo.useBowWeaponType = useBowWeaponType;
|
|
|
|
newMeleeWeaponPrefabInfo.weaponPrefabIndex = meleeWeaponPrefabInfoList.Count;
|
|
|
|
meleeWeaponPrefabInfoList.Add (newMeleeWeaponPrefabInfo);
|
|
|
|
updateComponent ();
|
|
} else {
|
|
meleeWeaponPrefabInfo newMeleeWeaponPrefabInfo = meleeWeaponPrefabInfoList [weaponPrefabIndex];
|
|
|
|
if (newMeleeWeaponPrefabInfo.weaponPrefab == null) {
|
|
newMeleeWeaponPrefabInfo.weaponPrefab = newWeaponPrefab;
|
|
|
|
updateComponent ();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void removeMeleeWeaponPrefab (string newWeaponName)
|
|
{
|
|
int weaponPrefabIndex = meleeWeaponPrefabInfoList.FindIndex (s => s.Name == newWeaponName);
|
|
|
|
if (weaponPrefabIndex > -1) {
|
|
meleeWeaponPrefabInfoList.RemoveAt (weaponPrefabIndex);
|
|
|
|
int weaponPrefabIndexCounter = 0;
|
|
|
|
for (int k = 0; k < meleeWeaponPrefabInfoList.Count; k++) {
|
|
meleeWeaponPrefabInfoList [k].weaponPrefabIndex = weaponPrefabIndexCounter;
|
|
|
|
weaponPrefabIndexCounter++;
|
|
}
|
|
|
|
updateComponent ();
|
|
}
|
|
}
|
|
|
|
public bool checkIfMeleeShieldExists (string shieldName)
|
|
{
|
|
int shieldPrefabIndex = shieldPrefabInfoList.FindIndex (s => s.Name == shieldName);
|
|
|
|
if (shieldPrefabIndex < 0) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public void removeMeleeShieldPrefab (string shieldName)
|
|
{
|
|
int shieldPrefabIndex = shieldPrefabInfoList.FindIndex (s => s.Name == shieldName);
|
|
|
|
if (shieldPrefabIndex > -1) {
|
|
shieldPrefabInfoList.RemoveAt (shieldPrefabIndex);
|
|
|
|
int shieldPrefabIndexCounter = 0;
|
|
|
|
for (int k = 0; k < shieldPrefabInfoList.Count; k++) {
|
|
shieldPrefabInfoList [k].shieldPrefabIndex = shieldPrefabIndexCounter;
|
|
|
|
shieldPrefabIndexCounter++;
|
|
}
|
|
|
|
updateComponent ();
|
|
}
|
|
}
|
|
|
|
public void addNewMeleeShieldPrefab (GameObject newShieldPrefab, string newShieldName)
|
|
{
|
|
if (newShieldPrefab != null) {
|
|
int shieldPrefabIndex = shieldPrefabInfoList.FindIndex (s => s.Name == newShieldName);
|
|
|
|
if (shieldPrefabIndex < 0) {
|
|
shieldPrefabInfo newShieldPrefabInfo = new shieldPrefabInfo ();
|
|
|
|
newShieldPrefabInfo.Name = newShieldName;
|
|
|
|
newShieldPrefabInfo.shieldPrefab = newShieldPrefab;
|
|
|
|
newShieldPrefabInfo.shieldPrefabIndex = shieldPrefabInfoList.Count;
|
|
|
|
if (shieldPrefabInfoList.Count > 0) {
|
|
newShieldPrefabInfo.shieldBackMountPointTransformReference = shieldPrefabInfoList [0].shieldBackMountPointTransformReference;
|
|
newShieldPrefabInfo.shieldHandMountPointTransformReference = shieldPrefabInfoList [0].shieldHandMountPointTransformReference;
|
|
}
|
|
|
|
shieldPrefabInfoList.Add (newShieldPrefabInfo);
|
|
|
|
updateComponent ();
|
|
} else {
|
|
shieldPrefabInfo newShieldPrefabInfo = shieldPrefabInfoList [shieldPrefabIndex];
|
|
|
|
if (newShieldPrefabInfo.shieldPrefab == null) {
|
|
newShieldPrefabInfo.shieldPrefab = newShieldPrefab;
|
|
|
|
updateComponent ();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//INPUT FUNCTIONS
|
|
bool canUseInput ()
|
|
{
|
|
if (mainGrabbedObjectMeleeAttackSystem.mainPlayerController.iscloseCombatAttackInProcess ()) {
|
|
return false;
|
|
}
|
|
|
|
if (!mainGrabbedObjectMeleeAttackSystem.mainPlayerController.isActionActive ()) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public void inputDrawOrKeepMeleeWeapon ()
|
|
{
|
|
if (isCurrentWeaponThrown ()) {
|
|
mainGrabbedObjectMeleeAttackSystem.inputThrowOrReturnObject ();
|
|
|
|
return;
|
|
}
|
|
|
|
if (getCurrentNumberOfWeaponsAvailable () == 0) {
|
|
return;
|
|
}
|
|
|
|
drawOrKeepMeleeWeapon (true);
|
|
}
|
|
|
|
public void drawOrKeepMeleeWeaponWithoutCheckingInputActive ()
|
|
{
|
|
drawOrKeepMeleeWeapon (false);
|
|
}
|
|
|
|
public void drawMeleeWeaponGrabbedCheckingAnimationDelay ()
|
|
{
|
|
bool activateDrawCoroutineResult = false;
|
|
|
|
if (currentWeaponIndex < meleeWeaponGrabbedInfoList.Count && currentWeaponIndex >= 0) {
|
|
meleeWeaponGrabbedInfo currentMeleeWeaponGrabbedInfo = meleeWeaponGrabbedInfoList [currentWeaponIndex];
|
|
|
|
if (currentMeleeWeaponGrabbedInfo.weaponStored != null) {
|
|
grabPhysicalObjectMeleeAttackSystem currentGrabPhysicalObjectMeleeAttackSystem = currentMeleeWeaponGrabbedInfo.weaponStored.GetComponent<grabPhysicalObjectMeleeAttackSystem> ();
|
|
|
|
if (currentGrabPhysicalObjectMeleeAttackSystem.useDrawKeepWeaponAnimation) {
|
|
StartCoroutine (drawMeleeWeaponGrabbedCheckingAnimationDelayCoroutine ());
|
|
|
|
activateDrawCoroutineResult = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!activateDrawCoroutineResult) {
|
|
drawOrKeepMeleeWeapon (false);
|
|
}
|
|
}
|
|
|
|
IEnumerator drawMeleeWeaponGrabbedCheckingAnimationDelayCoroutine ()
|
|
{
|
|
yield return new WaitForSeconds (0.2f);
|
|
|
|
drawOrKeepMeleeWeapon (false);
|
|
}
|
|
|
|
void drawOrKeepMeleeWeapon (bool checkIfInputActive)
|
|
{
|
|
if (!meleeWeaponsGrabbedManagerActive) {
|
|
return;
|
|
}
|
|
|
|
if (!isGrabObjectsEnabled ()) {
|
|
return;
|
|
}
|
|
|
|
if (mainGrabbedObjectMeleeAttackSystem.isAttackInProcess ()) {
|
|
return;
|
|
}
|
|
|
|
if ((mainGrabbedObjectMeleeAttackSystem.canUseWeaponsInput () || !checkIfInputActive) &&
|
|
!mainGrabbedObjectMeleeAttackSystem.isObjectThrownTravellingToTarget ()) {
|
|
if (mainGrabbedObjectMeleeAttackSystem.isCarryingObject ()) {
|
|
keepWeapon (currentWeaponIndex);
|
|
} else {
|
|
checkIfDrawWeapon ();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void resetCurrentAttackByIndex ()
|
|
{
|
|
mainGrabbedObjectMeleeAttackSystem.resetCurrentAttackByIndex ();
|
|
}
|
|
|
|
public void activateGrabbedObjectMeleeAttackByIndex ()
|
|
{
|
|
mainGrabbedObjectMeleeAttackSystem.activateGrabbedObjectMeleeAttackByIndex ();
|
|
}
|
|
|
|
public void activateOrDeactivateBlockGrabbedObjectMeleee (bool state)
|
|
{
|
|
if (state) {
|
|
mainGrabbedObjectMeleeAttackSystem.inputActivateBlock ();
|
|
} else {
|
|
mainGrabbedObjectMeleeAttackSystem.inputDeactivateBlock ();
|
|
}
|
|
}
|
|
|
|
public void activateOrDeactivateBlockGrabbedObjectMeleeeCheckingCurrentState (bool state)
|
|
{
|
|
if (state) {
|
|
if (!mainGrabbedObjectMeleeAttackSystem.isBlockActive ()) {
|
|
mainGrabbedObjectMeleeAttackSystem.inputActivateBlock ();
|
|
}
|
|
} else {
|
|
if (mainGrabbedObjectMeleeAttackSystem.isBlockActive ()) {
|
|
mainGrabbedObjectMeleeAttackSystem.inputDeactivateBlock ();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setIgnoreUseDrawKeepWeaponAnimationState (bool state)
|
|
{
|
|
mainGrabbedObjectMeleeAttackSystem.setIgnoreUseDrawKeepWeaponAnimationState (state);
|
|
}
|
|
|
|
public void setOriginalIgnoreUseDrawKeepWeaponAnimationState ()
|
|
{
|
|
mainGrabbedObjectMeleeAttackSystem.setOriginalIgnoreUseDrawKeepWeaponAnimationState ();
|
|
}
|
|
|
|
public void setIsCarryingObjectState (bool state)
|
|
{
|
|
carryingObject = state;
|
|
|
|
if (carryingObject) {
|
|
fullBodyAwarenessActive = mainGrabbedObjectMeleeAttackSystem.mainPlayerController.isFullBodyAwarenessActive ();
|
|
} else {
|
|
|
|
}
|
|
|
|
checkIKHandsOnGrabWeaponStateChange (state);
|
|
|
|
if (useEventOnGrabDropWeapon) {
|
|
if (state) {
|
|
eventOnGrabWeapon.Invoke ();
|
|
} else {
|
|
eventOnDropWeapon.Invoke ();
|
|
}
|
|
}
|
|
|
|
if (storePickedWeaponsOnInventory) {
|
|
if (state) {
|
|
mainInventoryManager.setLastWeaponCarriedOnHandsName (getCurrentWeaponName ());
|
|
}
|
|
}
|
|
}
|
|
|
|
void checkIKHandsOnGrabWeaponStateChange (bool state)
|
|
{
|
|
if (useIKOnHands) {
|
|
bool setHandsResult = state;
|
|
|
|
if (useIKOnHandsOnlyOnFba) {
|
|
if (!fullBodyAwarenessActive) {
|
|
setHandsResult = false;
|
|
}
|
|
}
|
|
|
|
if (setHandsResult) {
|
|
if (mainGrabbedObjectMeleeAttackSystem.checkIfCurrentWeaponignoreUseIKOnHands ()) {
|
|
setHandsResult = false;
|
|
}
|
|
}
|
|
|
|
if (setHandsResult) {
|
|
bool isCurrentWeaponIsCarriedOnRightHand = mainGrabbedObjectMeleeAttackSystem.isCurrentWeaponIsCarriedOnRightHand ();
|
|
|
|
if (isCurrentWeaponIsCarriedOnRightHand) {
|
|
handsOnMeleeWeaponIKSystem.enableOnlyRightHand ();
|
|
} else {
|
|
handsOnMeleeWeaponIKSystem.enableOnlyLeftHand ();
|
|
}
|
|
|
|
mainIKSystem.setTemporalOnAnimatorIKComponentActiveIfNotInUse (handsOnMeleeWeaponIKSystem);
|
|
} else {
|
|
mainIKSystem.removeThisTemporalOnAnimatorIKComponentIfIsCurrent (handsOnMeleeWeaponIKSystem);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setFullBodyAwarenessActiveState (bool state)
|
|
{
|
|
fullBodyAwarenessActive = state;
|
|
|
|
if (fullBodyAwarenessActive) {
|
|
if (carryingObject) {
|
|
checkIKHandsOnGrabWeaponStateChange (true);
|
|
} else {
|
|
|
|
}
|
|
} else {
|
|
if (carryingObject) {
|
|
checkIKHandsOnGrabWeaponStateChange (true);
|
|
} else {
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
public int getCurrentNumberOfWeaponsAvailable ()
|
|
{
|
|
currentNumberOfWeaponsAvailable = meleeWeaponGrabbedInfoList.Count;
|
|
|
|
if (currentNumberOfWeaponsAvailable != 0) {
|
|
int meleeWeaponGrabbedInfoListCount = meleeWeaponGrabbedInfoList.Count;
|
|
|
|
currentNumberOfWeaponsAvailable = 0;
|
|
|
|
for (int k = 0; k < meleeWeaponGrabbedInfoListCount; k++) {
|
|
if (meleeWeaponGrabbedInfoList [k].carryingWeapon) {
|
|
currentNumberOfWeaponsAvailable++;
|
|
}
|
|
}
|
|
}
|
|
|
|
return currentNumberOfWeaponsAvailable;
|
|
}
|
|
|
|
public bool checkIfCarryingWeaponByName (string weaponName)
|
|
{
|
|
int meleeWeaponGrabbedInfoListCount = meleeWeaponGrabbedInfoList.Count;
|
|
|
|
for (int k = 0; k < meleeWeaponGrabbedInfoListCount; k++) {
|
|
if (meleeWeaponGrabbedInfoList [k].carryingWeapon && meleeWeaponGrabbedInfoList [k].Name.Equals (weaponName)) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public string getFirstRegularMeleeWeaponTypeAvailableName ()
|
|
{
|
|
for (int k = 0; k < meleeWeaponPrefabInfoList.Count; k++) {
|
|
if (!meleeWeaponPrefabInfoList [k].useBowWeaponType) {
|
|
int weaponIndex = meleeWeaponGrabbedInfoList.FindIndex (s => s.Name == meleeWeaponPrefabInfoList [k].Name);
|
|
|
|
if (weaponIndex != -1) {
|
|
if (meleeWeaponGrabbedInfoList [weaponIndex].carryingWeapon) {
|
|
return meleeWeaponPrefabInfoList [k].Name;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return "";
|
|
}
|
|
|
|
public string getFirstBowMeleeWeaponTypeAvailableName ()
|
|
{
|
|
for (int k = 0; k < meleeWeaponPrefabInfoList.Count; k++) {
|
|
if (meleeWeaponPrefabInfoList [k].useBowWeaponType) {
|
|
int weaponIndex = meleeWeaponGrabbedInfoList.FindIndex (s => s.Name == meleeWeaponPrefabInfoList [k].Name);
|
|
|
|
if (weaponIndex != -1) {
|
|
if (meleeWeaponGrabbedInfoList [weaponIndex].carryingWeapon) {
|
|
return meleeWeaponPrefabInfoList [k].Name;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return "";
|
|
}
|
|
|
|
public bool isThereAnyBowMeleeWeaponTypeAvailable ()
|
|
{
|
|
for (int k = 0; k < meleeWeaponPrefabInfoList.Count; k++) {
|
|
if (meleeWeaponPrefabInfoList [k].useBowWeaponType) {
|
|
int weaponIndex = meleeWeaponGrabbedInfoList.FindIndex (s => s.Name == meleeWeaponPrefabInfoList [k].Name);
|
|
|
|
if (weaponIndex != -1) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public void renameWeapon (string currentWeaponName, string newWeaponName)
|
|
{
|
|
int weaponIndex = meleeWeaponPrefabInfoList.FindIndex (s => s.Name == currentWeaponName);
|
|
|
|
if (weaponIndex != -1) {
|
|
meleeWeaponPrefabInfo currentMeleeWeaponPrefabInfo = meleeWeaponPrefabInfoList [weaponIndex];
|
|
|
|
currentMeleeWeaponPrefabInfo.Name = newWeaponName;
|
|
|
|
if (currentMeleeWeaponPrefabInfo.weaponPrefab != null) {
|
|
grabPhysicalObjectMeleeAttackSystem currentGrabPhysicalObjectMeleeAttackSystem =
|
|
currentMeleeWeaponPrefabInfo.weaponPrefab.GetComponent<grabPhysicalObjectMeleeAttackSystem> ();
|
|
|
|
if (currentGrabPhysicalObjectMeleeAttackSystem != null) {
|
|
currentGrabPhysicalObjectMeleeAttackSystem.renameWeaponFromEditor (newWeaponName);
|
|
}
|
|
}
|
|
|
|
updateComponent ();
|
|
}
|
|
}
|
|
|
|
|
|
public void selectAndDrawFirstBowMeleeWeaponTypeAvailable ()
|
|
{
|
|
if (!meleeWeaponsGrabbedManagerActive) {
|
|
return;
|
|
}
|
|
|
|
if (!isGrabObjectsEnabled ()) {
|
|
return;
|
|
}
|
|
|
|
string weaponNameToUse = getFirstBowMeleeWeaponTypeAvailableName ();
|
|
|
|
if (weaponNameToUse != "") {
|
|
checkWeaponToSelectOnQuickAccessSlots (weaponNameToUse);
|
|
}
|
|
}
|
|
|
|
public void checkEventOnWeaponStolen ()
|
|
{
|
|
if (useEventOnWeaponStolen) {
|
|
eventOnWeaponStolen.Invoke ();
|
|
}
|
|
}
|
|
|
|
//EDITOR FUNCTIONS
|
|
void updateComponent ()
|
|
{
|
|
GKC_Utils.updateComponent (this);
|
|
|
|
GKC_Utils.updateDirtyScene ("Add Shield", gameObject);
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class meleeWeaponGrabbedInfo
|
|
{
|
|
public string Name;
|
|
public bool weaponInstantiated;
|
|
public GameObject weaponStored;
|
|
public bool canBeSpawnedInfiniteTimes;
|
|
public bool isCurrentWeapon;
|
|
public bool carryingWeapon;
|
|
public int weaponPrefabIndex;
|
|
public bool hideWeaponMeshWhenNotUsed;
|
|
|
|
public bool objectThrown;
|
|
|
|
public GameObject weaponMesh;
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class meleeWeaponPrefabInfo
|
|
{
|
|
public string Name;
|
|
public GameObject weaponPrefab;
|
|
public int weaponPrefabIndex;
|
|
|
|
public bool useBowWeaponType;
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class shieldPrefabInfo
|
|
{
|
|
public string Name;
|
|
public GameObject shieldPrefab;
|
|
public Transform shieldHandMountPointTransformReference;
|
|
public Transform shieldBackMountPointTransformReference;
|
|
public int shieldPrefabIndex;
|
|
|
|
public bool equipShieldWhenPickedIfNotShieldEquippedPrevioulsy;
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class shieldGrabbedInfo
|
|
{
|
|
public string Name;
|
|
public bool shieldInstantiated;
|
|
public GameObject shieldStored;
|
|
|
|
[Space]
|
|
|
|
public bool isCurrentShield;
|
|
public bool carryingShield;
|
|
|
|
public int shieldPrefabIndex;
|
|
|
|
[Space]
|
|
|
|
public bool hideWeaponMeshWhenNotUsed;
|
|
public bool shieldCarriedOnRightArm;
|
|
|
|
[Space]
|
|
|
|
public meleeShieldObjectSystem mainMeleeShieldObjectSystem;
|
|
|
|
public bool mainMeleeShieldObjectSystemLocated;
|
|
|
|
public bool equipShieldWhenPickedIfNotShieldEquippedPrevioulsy;
|
|
|
|
[Space]
|
|
|
|
public bool useEventsOnEquipShieldChangeState;
|
|
public UnityEvent eventOnEquipShield;
|
|
public UnityEvent eventOnUnequippShield;
|
|
}
|
|
}
|