516 lines
14 KiB
C#
516 lines
14 KiB
C#
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
using UnityEngine.Events;
|
|
|
|
public class objectExperienceSystem : MonoBehaviour
|
|
{
|
|
[Header ("Main Settings")]
|
|
[Space]
|
|
|
|
public bool giveRewardOnlyOnceEnabled;
|
|
|
|
[Space]
|
|
[Header ("Experience Settings")]
|
|
[Space]
|
|
|
|
public bool useExperienceRandomRange;
|
|
public Vector2 experienceRandomRange;
|
|
public int experienceAmount;
|
|
|
|
public bool useTransformAsExpTextPosition = true;
|
|
public Transform objectTransform;
|
|
|
|
public string extraExperienceText;
|
|
|
|
[Space]
|
|
[Header ("Money Settings")]
|
|
[Space]
|
|
|
|
public bool useMoneyRandomRange;
|
|
public Vector2 moneyRandomRange;
|
|
public int moneyAmount;
|
|
|
|
[Space]
|
|
[Header ("Inventory Object Settings")]
|
|
[Space]
|
|
|
|
public bool giveInventoryObject;
|
|
public string inventoryObjectName;
|
|
public int inventoryObjectAmount;
|
|
|
|
public bool onlyRefillCertainAmountOfInventoryObjectAmount;
|
|
|
|
[Space]
|
|
|
|
public Transform positionToInstantiateInventoryObjectPickup;
|
|
public float maxRadiusToInstantiate;
|
|
public float forceAmount;
|
|
public float forceRadius;
|
|
public ForceMode inventoryObjectForceMode;
|
|
|
|
public bool spawnAllInventoryObjects;
|
|
|
|
public bool spawnObjectIfNotEnoughSpaceOnInventory = true;
|
|
|
|
[Space]
|
|
|
|
public bool giveRandomSingleObjectFromList;
|
|
public bool giveInventoryObjectList;
|
|
|
|
[Space]
|
|
|
|
public List<inventoryElementInfo> inventoryElementInfoList = new List<inventoryElementInfo> ();
|
|
|
|
[Space]
|
|
|
|
public bool getInventoryObjectsFromInventoryBank;
|
|
public inventoryBankSystem mainInventoryBankSystem;
|
|
|
|
[Space]
|
|
[Header ("Stamina Settings")]
|
|
[Space]
|
|
|
|
public bool refillStamina;
|
|
public bool refillFullStamina;
|
|
public float staminaAmountToRefill;
|
|
|
|
[Space]
|
|
[Header ("Inventory Extra Slots Settings")]
|
|
[Space]
|
|
|
|
public bool increaseInventorySlotsAmount;
|
|
public int extraInventorySlotsAmount;
|
|
|
|
[Space]
|
|
[Header ("Inventory Extra Weight Settings")]
|
|
[Space]
|
|
|
|
public bool increaseInventoryWeightLimit;
|
|
public float extraWeightLimit;
|
|
|
|
[Space]
|
|
[Header ("Stats To Increase Settings")]
|
|
[Space]
|
|
|
|
public bool increaseStatsValues;
|
|
|
|
[Space]
|
|
|
|
public List<statInfo> statInfoList = new List<statInfo> ();
|
|
|
|
[Space]
|
|
[Header ("Skill Points Settings")]
|
|
[Space]
|
|
|
|
public bool getSkillPoints;
|
|
public bool useSkillPointsRandomRange;
|
|
public Vector2 skillPointsRandomRange;
|
|
public int skillPointsAmount;
|
|
|
|
[Space]
|
|
[Header ("Skill Settings")]
|
|
[Space]
|
|
|
|
public bool getSkill;
|
|
public string skillToGetName;
|
|
|
|
[Space]
|
|
|
|
public bool getSkillList;
|
|
|
|
public List<string> skillToGetNameList = new List<string> ();
|
|
|
|
[Space]
|
|
|
|
public bool showMessageOnGetSkill;
|
|
[Tooltip ("Write -SKILLNAME- in the string to replace that part of the message with the name of the skill.")]
|
|
public string messageOnGetSkill;
|
|
|
|
[Space]
|
|
[Header ("Abilities Settings")]
|
|
[Space]
|
|
|
|
public bool getAbility;
|
|
public string abilityToGetName;
|
|
|
|
[Space]
|
|
|
|
public bool getAbilityList;
|
|
|
|
public List<string> abilityToGetNameList = new List<string> ();
|
|
|
|
[Space]
|
|
|
|
public bool showMessageOnGetAbility;
|
|
[Tooltip ("Write -ABILITYNAME- in the string to replace that part of the message with the name of the skill.")]
|
|
public string messageOnGetAbility;
|
|
|
|
[Space]
|
|
[Header ("Crafting Settings")]
|
|
[Space]
|
|
|
|
public bool getCraftingRecipes;
|
|
|
|
[Space]
|
|
|
|
public List<string> craftingRecipesList = new List<string> ();
|
|
|
|
[Space]
|
|
[Header ("Player Manual Settings")]
|
|
[Space]
|
|
|
|
public bool setPlayerManually;
|
|
public bool sendAlwaysToMainPlayer;
|
|
public bool searchPlayerByTagIfNotAssigned = true;
|
|
public GameObject playerToConfigure;
|
|
|
|
[Space]
|
|
[Header ("Remote Events Settings")]
|
|
[Space]
|
|
|
|
public bool useRemoteEvents;
|
|
public List<string> removeEventNameList = new List<string> ();
|
|
|
|
[Space]
|
|
[Header ("Event Settings")]
|
|
[Space]
|
|
|
|
public bool useEventOnReward;
|
|
public UnityEvent eventtOnReward;
|
|
|
|
[Space]
|
|
[Header ("Debug")]
|
|
[Space]
|
|
|
|
public bool showDebugPrint;
|
|
public bool rewardObtained;
|
|
|
|
|
|
public void sendExperienceToPlayerManually ()
|
|
{
|
|
if (setPlayerManually) {
|
|
sendExperienceToAttacker (playerToConfigure);
|
|
}
|
|
}
|
|
|
|
public void sendExperienceToPlayer (GameObject playerToUse)
|
|
{
|
|
if (setPlayerManually) {
|
|
playerToUse = playerToConfigure;
|
|
}
|
|
|
|
sendExperienceToAttacker (playerToUse);
|
|
}
|
|
|
|
public void sendExperienceToAttacker (GameObject attackerGameObject)
|
|
{
|
|
if (giveRewardOnlyOnceEnabled) {
|
|
if (rewardObtained) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (sendAlwaysToMainPlayer) {
|
|
attackerGameObject = GKC_Utils.findMainPlayerOnScene ();
|
|
}
|
|
|
|
if (attackerGameObject == null) {
|
|
if (setPlayerManually && searchPlayerByTagIfNotAssigned) {
|
|
|
|
attackerGameObject = GKC_Utils.findMainPlayerOnScene ();
|
|
|
|
if (attackerGameObject == null) {
|
|
return;
|
|
}
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (objectTransform == null) {
|
|
objectTransform = transform;
|
|
}
|
|
|
|
if (applyDamage.isVehicle (attackerGameObject)) {
|
|
GameObject vehicleDriver = applyDamage.getVehicleDriver (attackerGameObject);
|
|
|
|
if (vehicleDriver != null) {
|
|
attackerGameObject = vehicleDriver;
|
|
}
|
|
}
|
|
|
|
playerComponentsManager currentPlayerComponentsManager = attackerGameObject.GetComponent<playerComponentsManager> ();
|
|
|
|
if (currentPlayerComponentsManager != null) {
|
|
if (experienceAmount != 0 || (useExperienceRandomRange && (experienceRandomRange.x != 0 || experienceRandomRange.y != 0))) {
|
|
playerExperienceSystem currentPlayerExperienceSystem = currentPlayerComponentsManager.getPlayerExperienceSystem ();
|
|
|
|
if (currentPlayerExperienceSystem != null) {
|
|
|
|
float newAmount = experienceAmount;
|
|
|
|
if (useExperienceRandomRange) {
|
|
newAmount = Random.Range (experienceRandomRange.x, experienceRandomRange.y);
|
|
|
|
newAmount = Mathf.RoundToInt (newAmount);
|
|
}
|
|
|
|
currentPlayerExperienceSystem.getExperienceAmount ((int)newAmount, objectTransform, useTransformAsExpTextPosition, extraExperienceText);
|
|
}
|
|
}
|
|
|
|
if (moneyAmount != 0) {
|
|
currencySystem currentCurrencySystem = currentPlayerComponentsManager.getCurrencySystem ();
|
|
|
|
if (currentCurrencySystem != null) {
|
|
|
|
float newAmount = moneyAmount;
|
|
|
|
if (useMoneyRandomRange && moneyRandomRange != Vector2.zero) {
|
|
newAmount = Random.Range (moneyRandomRange.x, moneyRandomRange.y);
|
|
|
|
newAmount = Mathf.RoundToInt (newAmount);
|
|
}
|
|
|
|
currentCurrencySystem.increaseTotalMoneyAmount (newAmount);
|
|
}
|
|
}
|
|
|
|
if (giveInventoryObject) {
|
|
if (positionToInstantiateInventoryObjectPickup == null) {
|
|
positionToInstantiateInventoryObjectPickup = transform;
|
|
}
|
|
|
|
if (giveInventoryObjectList) {
|
|
if (giveRandomSingleObjectFromList) {
|
|
if (getInventoryObjectsFromInventoryBank) {
|
|
List<inventoryInfo> inventoryBankElementInfoList = mainInventoryBankSystem.getBankInventoryListFromFullBank ();
|
|
|
|
if (inventoryBankElementInfoList != null && inventoryBankElementInfoList.Count > 0) {
|
|
int randomObjectIndex = Random.Range (0, inventoryBankElementInfoList.Count - 1);
|
|
|
|
applyDamage.giveInventoryObjectToCharacter (attackerGameObject,
|
|
inventoryBankElementInfoList [randomObjectIndex].Name,
|
|
inventoryBankElementInfoList [randomObjectIndex].amount,
|
|
positionToInstantiateInventoryObjectPickup, forceAmount,
|
|
maxRadiusToInstantiate, inventoryObjectForceMode, forceRadius, spawnAllInventoryObjects,
|
|
false, spawnObjectIfNotEnoughSpaceOnInventory);
|
|
}
|
|
} else {
|
|
int randomObjectIndex = Random.Range (0, inventoryElementInfoList.Count - 1);
|
|
|
|
if (inventoryElementInfoList [randomObjectIndex].inventoryObjectAmount == 0) {
|
|
inventoryElementInfoList [randomObjectIndex].inventoryObjectAmount = 1;
|
|
}
|
|
|
|
applyDamage.giveInventoryObjectToCharacter (attackerGameObject,
|
|
inventoryElementInfoList [randomObjectIndex].Name,
|
|
inventoryElementInfoList [randomObjectIndex].inventoryObjectAmount,
|
|
positionToInstantiateInventoryObjectPickup, forceAmount,
|
|
maxRadiusToInstantiate, inventoryObjectForceMode, forceRadius, spawnAllInventoryObjects,
|
|
inventoryElementInfoList [randomObjectIndex].onlyRefillCertainAmountOfInventoryObjectAmount,
|
|
spawnObjectIfNotEnoughSpaceOnInventory);
|
|
|
|
}
|
|
} else {
|
|
if (getInventoryObjectsFromInventoryBank) {
|
|
List<inventoryInfo> inventoryBankElementInfoList = mainInventoryBankSystem.getBankInventoryListFromFullBank ();
|
|
|
|
if (inventoryBankElementInfoList != null && inventoryBankElementInfoList.Count > 0) {
|
|
for (int i = 0; i < inventoryBankElementInfoList.Count; i++) {
|
|
|
|
applyDamage.giveInventoryObjectToCharacter (attackerGameObject,
|
|
inventoryBankElementInfoList [i].Name,
|
|
inventoryBankElementInfoList [i].amount,
|
|
positionToInstantiateInventoryObjectPickup, forceAmount,
|
|
maxRadiusToInstantiate, inventoryObjectForceMode, forceRadius, spawnAllInventoryObjects,
|
|
false, spawnObjectIfNotEnoughSpaceOnInventory);
|
|
}
|
|
}
|
|
} else {
|
|
for (int i = 0; i < inventoryElementInfoList.Count; i++) {
|
|
if (inventoryElementInfoList [i].inventoryObjectAmount == 0) {
|
|
inventoryElementInfoList [i].inventoryObjectAmount = 1;
|
|
}
|
|
|
|
applyDamage.giveInventoryObjectToCharacter (attackerGameObject,
|
|
inventoryElementInfoList [i].Name,
|
|
inventoryElementInfoList [i].inventoryObjectAmount,
|
|
positionToInstantiateInventoryObjectPickup, forceAmount,
|
|
maxRadiusToInstantiate, inventoryObjectForceMode, forceRadius, spawnAllInventoryObjects,
|
|
inventoryElementInfoList [i].onlyRefillCertainAmountOfInventoryObjectAmount,
|
|
spawnObjectIfNotEnoughSpaceOnInventory);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
if (inventoryObjectAmount == 0) {
|
|
inventoryObjectAmount = 1;
|
|
}
|
|
|
|
applyDamage.giveInventoryObjectToCharacter (attackerGameObject, inventoryObjectName,
|
|
inventoryObjectAmount, positionToInstantiateInventoryObjectPickup,
|
|
forceAmount, maxRadiusToInstantiate,
|
|
inventoryObjectForceMode, forceRadius, spawnAllInventoryObjects,
|
|
onlyRefillCertainAmountOfInventoryObjectAmount, spawnObjectIfNotEnoughSpaceOnInventory);
|
|
}
|
|
}
|
|
|
|
if (refillStamina) {
|
|
applyDamage.setStamina (staminaAmountToRefill, attackerGameObject, refillFullStamina);
|
|
}
|
|
|
|
if (increaseInventorySlotsAmount) {
|
|
applyDamage.addInventoryExtraSpace (attackerGameObject, extraInventorySlotsAmount);
|
|
}
|
|
|
|
if (increaseInventoryWeightLimit) {
|
|
applyDamage.increaseInventoryBagWeight (extraWeightLimit, attackerGameObject);
|
|
}
|
|
|
|
if (increaseStatsValues) {
|
|
playerStatsSystem currentPlayerStatsSystem = currentPlayerComponentsManager.getPlayerStatsSystem ();
|
|
|
|
if (currentPlayerStatsSystem != null) {
|
|
|
|
for (int k = 0; k < statInfoList.Count; k++) {
|
|
|
|
if (statInfoList [k].statIsAmount) {
|
|
float extraValue = statInfoList [k].statExtraValue;
|
|
if (statInfoList [k].useRandomRange) {
|
|
extraValue = Random.Range (statInfoList [k].randomRange.x, statInfoList [k].randomRange.y);
|
|
|
|
extraValue = Mathf.RoundToInt (extraValue);
|
|
}
|
|
|
|
currentPlayerStatsSystem.increasePlayerStat (statInfoList [k].Name, extraValue);
|
|
} else {
|
|
currentPlayerStatsSystem.enableOrDisableBoolPlayerStat (statInfoList [k].Name, statInfoList [k].newBoolState);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (getSkillPoints) {
|
|
playerExperienceSystem currentPlayerExperienceSystem = currentPlayerComponentsManager.getPlayerExperienceSystem ();
|
|
|
|
if (currentPlayerExperienceSystem != null) {
|
|
|
|
float newAmount = skillPointsAmount;
|
|
|
|
if (useSkillPointsRandomRange) {
|
|
newAmount = Random.Range (skillPointsRandomRange.x, skillPointsRandomRange.y);
|
|
|
|
newAmount = Mathf.RoundToInt (newAmount);
|
|
}
|
|
|
|
currentPlayerExperienceSystem.getSkillPoints ((int)newAmount);
|
|
}
|
|
}
|
|
|
|
if (getSkill) {
|
|
playerSkillsSystem currentPlayerSkillsSystem = currentPlayerComponentsManager.getPlayerSkillsSystem ();
|
|
|
|
if (currentPlayerSkillsSystem != null) {
|
|
if (getSkillList) {
|
|
GKC_Utils.setUnlockStateOnSkillList (attackerGameObject.transform, skillToGetNameList, true);
|
|
} else {
|
|
currentPlayerSkillsSystem.getSkillByName (skillToGetName);
|
|
}
|
|
|
|
if (showMessageOnGetSkill) {
|
|
pickUpsScreenInfo currentPickUpsScreenInfo = currentPlayerComponentsManager.getPickUpsScreenInfo ();
|
|
|
|
if (currentPickUpsScreenInfo != null) {
|
|
messageOnGetSkill = messageOnGetSkill.Replace ("-SKILLNAME-", skillToGetName);
|
|
|
|
currentPickUpsScreenInfo.recieveInfo (messageOnGetSkill);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (getAbility) {
|
|
playerAbilitiesSystem currentPlayerAbilitiesSystem = currentPlayerComponentsManager.getPlayerAbilitiesSystem ();
|
|
|
|
if (currentPlayerAbilitiesSystem != null) {
|
|
if (getAbilityList) {
|
|
currentPlayerAbilitiesSystem.enableAbilityGroupByName (abilityToGetNameList);
|
|
|
|
GKC_Utils.setUnlockStateOnSkillList (attackerGameObject.transform, abilityToGetNameList, true);
|
|
} else {
|
|
currentPlayerAbilitiesSystem.enableAbilityByName (abilityToGetName);
|
|
|
|
GKC_Utils.setUnlockStateOnSkill (attackerGameObject.transform, abilityToGetName, true);
|
|
}
|
|
|
|
if (showMessageOnGetAbility) {
|
|
pickUpsScreenInfo currentPickUpsScreenInfo = currentPlayerComponentsManager.getPickUpsScreenInfo ();
|
|
|
|
if (currentPickUpsScreenInfo != null) {
|
|
messageOnGetSkill = messageOnGetSkill.Replace ("-ABILITYNAME-", abilityToGetName);
|
|
|
|
currentPickUpsScreenInfo.recieveInfo (messageOnGetAbility);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (getCraftingRecipes) {
|
|
GKC_Utils.addNewBlueprintsUnlockedList (attackerGameObject, craftingRecipesList);
|
|
}
|
|
|
|
|
|
if (useRemoteEvents) {
|
|
remoteEventSystem currentRemoteEventSystem = attackerGameObject.GetComponent<remoteEventSystem> ();
|
|
|
|
if (currentRemoteEventSystem == null && currentPlayerComponentsManager != null) {
|
|
currentRemoteEventSystem = currentPlayerComponentsManager.getRemoteEventSystem ();
|
|
}
|
|
|
|
if (currentRemoteEventSystem != null) {
|
|
for (int i = 0; i < removeEventNameList.Count; i++) {
|
|
|
|
currentRemoteEventSystem.callRemoteEvent (removeEventNameList [i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (useEventOnReward) {
|
|
eventtOnReward.Invoke ();
|
|
}
|
|
}
|
|
|
|
if (showDebugPrint) {
|
|
print ("giving reward to character");
|
|
}
|
|
|
|
rewardObtained = true;
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class inventoryElementInfo
|
|
{
|
|
public string Name;
|
|
public int inventoryObjectAmount;
|
|
|
|
public bool onlyRefillCertainAmountOfInventoryObjectAmount;
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class statInfo
|
|
{
|
|
public string Name;
|
|
|
|
public bool statIsAmount = true;
|
|
|
|
public float statExtraValue;
|
|
|
|
public bool useRandomRange;
|
|
public Vector2 randomRange;
|
|
|
|
public bool newBoolState;
|
|
}
|
|
|
|
} |