640 lines
18 KiB
C#
640 lines
18 KiB
C#
using UnityEngine;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using UnityEngine.UI;
|
|
using UnityEngine.Events;
|
|
|
|
public class friendListManager : MonoBehaviour
|
|
{
|
|
[Header ("Main Settings")]
|
|
[Space]
|
|
|
|
public bool openMenuEnabled = true;
|
|
|
|
public bool friendManagerEnabled;
|
|
|
|
public string menuPanelName = "Friend List Manager";
|
|
|
|
public bool useBlurUIPanel = true;
|
|
public bool usedByAI;
|
|
|
|
[Space]
|
|
[Header ("Order Info Settings")]
|
|
[Space]
|
|
|
|
public List<orderInfo> orderInfoList = new List<orderInfo> ();
|
|
|
|
[Space]
|
|
[Header ("Order Button Settings")]
|
|
[Space]
|
|
|
|
public List<Button> orderButtonList = new List<Button> ();
|
|
|
|
[Space]
|
|
[Header ("Other Settings")]
|
|
[Space]
|
|
|
|
public string callToFriendsOrderName = "Follow";
|
|
|
|
[Space]
|
|
[Header ("Events Settings")]
|
|
[Space]
|
|
|
|
public bool useEventIfSystemDisabled;
|
|
public UnityEvent eventIfSystemDisabled;
|
|
|
|
[Space]
|
|
|
|
public bool useEventToSendFriendAdded;
|
|
public eventParameters.eventToCallWithGameObject eventToSendFriendAdded;
|
|
|
|
public bool useEventToSendFriendRemoved;
|
|
public eventParameters.eventToCallWithGameObject eventToSendFriendRemoved;
|
|
|
|
[Space]
|
|
[Header ("Debug")]
|
|
[Space]
|
|
|
|
public bool showDebugPrint;
|
|
public bool menuOpened;
|
|
|
|
public List<friendInfo> friendsList = new List<friendInfo> ();
|
|
|
|
[Space]
|
|
[Header ("Components")]
|
|
[Space]
|
|
|
|
public menuPause pauseManager;
|
|
public playerController playerControllerManager;
|
|
public Collider mainCollider;
|
|
|
|
public Transform playerTransform;
|
|
|
|
public GameObject friendsMenuContent;
|
|
public GameObject friendListContent;
|
|
public GameObject friendListElement;
|
|
|
|
|
|
friendInfo currentFriendInfo;
|
|
|
|
|
|
void Start ()
|
|
{
|
|
if (usedByAI) {
|
|
return;
|
|
}
|
|
|
|
if (!friendManagerEnabled) {
|
|
checkEventOnSystemDisabled ();
|
|
}
|
|
|
|
if (friendListElement.activeSelf) {
|
|
friendListElement.SetActive (false);
|
|
}
|
|
|
|
if (friendsMenuContent.activeSelf) {
|
|
friendsMenuContent.SetActive (false);
|
|
}
|
|
}
|
|
|
|
public void checkEventOnSystemDisabled ()
|
|
{
|
|
if (useEventIfSystemDisabled) {
|
|
eventIfSystemDisabled.Invoke ();
|
|
}
|
|
}
|
|
|
|
public void openOrCloseFriendMenu (bool state)
|
|
{
|
|
if (state) {
|
|
if (!pauseManager.checkIfMenuCanBeUsedByName (menuPanelName)) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
bool checkResult =
|
|
|
|
(!playerControllerManager.isPlayerMenuActive () || menuOpened) &&
|
|
(!playerControllerManager.isUsingDevice () || playerControllerManager.isPlayerDriving ()) &&
|
|
!pauseManager.isGamePaused ();
|
|
|
|
if (checkResult) {
|
|
|
|
menuOpened = state;
|
|
|
|
pauseManager.openOrClosePlayerMenu (menuOpened, friendsMenuContent.transform, useBlurUIPanel);
|
|
|
|
friendsMenuContent.SetActive (menuOpened);
|
|
|
|
pauseManager.setIngameMenuOpenedState (menuPanelName, menuOpened, true);
|
|
|
|
pauseManager.enableOrDisablePlayerMenu (menuOpened, true, false);
|
|
|
|
if (playerControllerManager.isPlayerDriving ()) {
|
|
GameObject currentVehicleObject = playerControllerManager.getCurrentVehicle ();
|
|
|
|
if (currentVehicleObject != null) {
|
|
vehicleHUDManager currentVehicleHUDManager = currentVehicleObject.GetComponent<vehicleHUDManager> ();
|
|
|
|
if (currentVehicleHUDManager != null) {
|
|
currentVehicleHUDManager.IKDrivingManager.setCameraAndWeaponsPauseState (menuOpened);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void openOrCLoseFriendMenuFromTouch ()
|
|
{
|
|
openOrCloseFriendMenu (!menuOpened);
|
|
}
|
|
|
|
public void closeFriendMenuIfOpen ()
|
|
{
|
|
if (menuOpened) {
|
|
openOrCloseFriendMenu (false);
|
|
}
|
|
}
|
|
|
|
public void closeFriendMenu ()
|
|
{
|
|
openOrCloseFriendMenu (false);
|
|
}
|
|
|
|
public void addFriend (GameObject friend)
|
|
{
|
|
if (friend == null) {
|
|
return;
|
|
}
|
|
|
|
if (!checkIfContains (friend.transform)) {
|
|
GameObject newFriendListElement = (GameObject)Instantiate (friendListElement, friendListElement.transform.position,
|
|
Quaternion.identity, friendListElement.transform.parent);
|
|
|
|
newFriendListElement.name = "New Friend List Element " + (friendsList.Count + 1);
|
|
|
|
friendInfo newFriend = newFriendListElement.GetComponent<friendListElement> ().friendListElementInfo;
|
|
|
|
healthManagement currentHealthManagement = friend.GetComponent<healthManagement> ();
|
|
|
|
if (currentHealthManagement != null) {
|
|
health currentHealth = currentHealthManagement.GetComponent<health> ();
|
|
|
|
if (currentHealth != null) {
|
|
newFriend.Name = currentHealth.settings.allyName;
|
|
}
|
|
}
|
|
|
|
newFriend.friendTransform = friend.transform;
|
|
|
|
newFriendListElement.SetActive (true);
|
|
|
|
playerComponentsManager mainPlayerComponentsManager = friend.GetComponent<playerComponentsManager> ();
|
|
|
|
if (mainPlayerComponentsManager != null) {
|
|
newFriend.friendRemoteEventSystem = mainPlayerComponentsManager.getRemoteEventSystem ();
|
|
|
|
newFriend.mainCharacterToReceiveOrders = mainPlayerComponentsManager.getCharacterToReceiveOrders ();
|
|
}
|
|
|
|
newFriendListElement.transform.localScale = Vector3.one;
|
|
|
|
newFriend.friendListElement = newFriendListElement;
|
|
|
|
if (newFriend.mainCharacterToReceiveOrders != null) {
|
|
for (int i = 0; i < newFriend.orderButtonList.Count; i++) {
|
|
Text pressedButtonText = newFriend.orderButtonList [i].GetComponentInChildren<Text> ();
|
|
|
|
if (pressedButtonText != null) {
|
|
string currentOrderButtonName = pressedButtonText.text.ToString ();
|
|
|
|
if (showDebugPrint) {
|
|
print ("checking if order exists " + currentOrderButtonName);
|
|
}
|
|
|
|
if (!newFriend.mainCharacterToReceiveOrders.containsOrderName (currentOrderButtonName)) {
|
|
if (newFriend.orderButtonList [i].gameObject.activeSelf) {
|
|
newFriend.orderButtonList [i].gameObject.SetActive (false);
|
|
}
|
|
|
|
if (showDebugPrint) {
|
|
print (currentOrderButtonName + " not located, disabing button");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
friendsList.Add (newFriend);
|
|
|
|
setCurrentStateText (friendsList.Count - 1, "Following");
|
|
|
|
setFriendListName ();
|
|
|
|
if (useEventToSendFriendAdded) {
|
|
eventToSendFriendAdded.Invoke (friend);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setFriendListName ()
|
|
{
|
|
for (int i = 0; i < friendsList.Count; i++) {
|
|
friendsList [i].nameText.text = (i + 1) + ".- " + friendsList [i].Name;
|
|
}
|
|
}
|
|
|
|
public bool checkIfContains (Transform friend)
|
|
{
|
|
bool itContains = false;
|
|
|
|
for (int i = 0; i < friendsList.Count; i++) {
|
|
if (friendsList [i].friendTransform == friend) {
|
|
itContains = true;
|
|
}
|
|
}
|
|
|
|
return itContains;
|
|
}
|
|
|
|
public void setIndividualOrder (Button pressedButton)
|
|
{
|
|
Text pressedButtonText = pressedButton.GetComponentInChildren<Text> ();
|
|
|
|
if (pressedButtonText != null) {
|
|
string orderName = pressedButtonText.text.ToString ();
|
|
|
|
setOrderByName (orderName, true, pressedButton);
|
|
}
|
|
}
|
|
|
|
void setOrderByName (string orderName, bool isIndividualOrder, Button pressedButton)
|
|
{
|
|
if (playerTransform == null) {
|
|
playerTransform = transform;
|
|
}
|
|
|
|
int orderIndex = orderInfoList.FindIndex (a => a.Name.Equals (orderName));
|
|
|
|
if (orderIndex > -1) {
|
|
orderInfo newOrderInfo = orderInfoList [orderIndex];
|
|
|
|
Transform target = playerTransform;
|
|
|
|
for (int i = 0; i < friendsList.Count; i++) {
|
|
|
|
currentFriendInfo = friendsList [i];
|
|
|
|
bool canCheckFriendResult = false;
|
|
|
|
if (isIndividualOrder) {
|
|
canCheckFriendResult = currentFriendInfo.orderButtonList.Contains (pressedButton);
|
|
} else {
|
|
canCheckFriendResult = true;
|
|
}
|
|
|
|
if (showDebugPrint) {
|
|
print ("order activated result " + orderName + " " + canCheckFriendResult);
|
|
}
|
|
|
|
if (canCheckFriendResult) {
|
|
|
|
if (newOrderInfo.closeMenuOnOrderSelected) {
|
|
if (menuOpened) {
|
|
closeFriendMenu ();
|
|
}
|
|
}
|
|
|
|
string action = newOrderInfo.orderName;
|
|
|
|
if (showDebugPrint) {
|
|
print (action);
|
|
}
|
|
|
|
if (newOrderInfo.checkCharacterToReceiveOrdersComponent) {
|
|
if (currentFriendInfo.mainCharacterToReceiveOrders != null) {
|
|
currentFriendInfo.mainCharacterToReceiveOrders.activateOrder (newOrderInfo.Name);
|
|
}
|
|
}
|
|
|
|
if (newOrderInfo.useCustomOrderBehavior) {
|
|
if (newOrderInfo.sendPlayerOnOrder) {
|
|
newOrderInfo.mainCustomOrderBehavior.activateOrder (currentFriendInfo.friendTransform, playerTransform);
|
|
} else {
|
|
newOrderInfo.mainCustomOrderBehavior.activateOrder (currentFriendInfo.friendTransform);
|
|
}
|
|
|
|
if (newOrderInfo.getCustomTargetFromBehavior) {
|
|
target = newOrderInfo.mainCustomOrderBehavior.getCustomTarget (currentFriendInfo.friendTransform, playerTransform);
|
|
}
|
|
|
|
if (target != null) {
|
|
newOrderInfo.mainCustomOrderBehavior.setCustomTarget (target);
|
|
}
|
|
}
|
|
|
|
if (target != null) {
|
|
if (newOrderInfo.checkCharacterToReceiveOrdersComponent) {
|
|
if (currentFriendInfo.mainCharacterToReceiveOrders != null) {
|
|
currentFriendInfo.mainCharacterToReceiveOrders.setCustomTarget (target);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (newOrderInfo.useRemoteEvent) {
|
|
for (int j = 0; j < newOrderInfo.remoteEventNameList.Count; j++) {
|
|
currentFriendInfo.friendRemoteEventSystem.callRemoteEvent (newOrderInfo.remoteEventNameList [j]);
|
|
}
|
|
}
|
|
|
|
if (target != null && action != "") {
|
|
currentFriendInfo.friendRemoteEventSystem.callRemoteEventWithTransform (action, target);
|
|
}
|
|
|
|
if (newOrderInfo.sendPlayerTransformOnEvent) {
|
|
currentFriendInfo.friendRemoteEventSystem.callRemoteEventWithTransform (action, playerTransform);
|
|
}
|
|
|
|
if (newOrderInfo.useRemoteEventListToSendPlayer) {
|
|
for (int j = 0; j < newOrderInfo.remoteEventNameListToSendPlayer.Count; j++) {
|
|
currentFriendInfo.friendRemoteEventSystem.callRemoteEvent (newOrderInfo.remoteEventNameListToSendPlayer [j]);
|
|
}
|
|
}
|
|
|
|
setCurrentStateText (i, action);
|
|
|
|
if (newOrderInfo.useEventOnOrder) {
|
|
newOrderInfo.eventOnOrder.Invoke ();
|
|
}
|
|
|
|
if (isIndividualOrder) {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setGeneralOrderByName (string orderName)
|
|
{
|
|
setOrderByName (orderName, false, null);
|
|
}
|
|
|
|
public void setGeneralOrder (Button pressedButton)
|
|
{
|
|
Text pressedButtonText = pressedButton.GetComponentInChildren<Text> ();
|
|
|
|
if (pressedButtonText != null) {
|
|
string orderName = pressedButtonText.text.ToString ();
|
|
|
|
setOrderByName (orderName, false, pressedButton);
|
|
}
|
|
}
|
|
|
|
public void callToFriends ()
|
|
{
|
|
setGeneralOrderByName (callToFriendsOrderName);
|
|
}
|
|
|
|
public void findFriendsInRadius (float radius)
|
|
{
|
|
Collider [] colliders = Physics.OverlapSphere (playerTransform.position, radius);
|
|
|
|
if (colliders.Length > 0) {
|
|
|
|
for (int i = 0; i < colliders.Length; i++) {
|
|
findObjectivesSystem currentFindObjectivesSystem = colliders [i].GetComponentInChildren<findObjectivesSystem> ();
|
|
|
|
if (currentFindObjectivesSystem != null) {
|
|
currentFindObjectivesSystem.checkTriggerInfo (mainCollider, true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setCurrentStateText (int index, string state)
|
|
{
|
|
if (friendsList.Count > 0 && index < friendsList.Count) {
|
|
friendsList [index].currentState.text = "State: " + state;
|
|
}
|
|
}
|
|
|
|
public void removeFriend (Transform friend)
|
|
{
|
|
for (int i = 0; i < friendsList.Count; i++) {
|
|
if (friendsList [i].friendTransform == friend) {
|
|
if (showDebugPrint) {
|
|
print ("friend removed " + friendsList [i].Name);
|
|
}
|
|
|
|
Destroy (friendsList [i].friendListElement);
|
|
|
|
friendsList.RemoveAt (i);
|
|
|
|
if (useEventToSendFriendRemoved) {
|
|
eventToSendFriendRemoved.Invoke (friend.gameObject);
|
|
}
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void removeAllFriends ()
|
|
{
|
|
for (int i = 0; i < friendsList.Count; i++) {
|
|
Destroy (friendsList [i].friendListElement);
|
|
}
|
|
|
|
friendsList.Clear ();
|
|
}
|
|
|
|
public List<GameObject> getAllFriendList ()
|
|
{
|
|
if (friendsList.Count == 0) {
|
|
return null;
|
|
}
|
|
|
|
List<GameObject> currentFriendList = new List<GameObject> ();
|
|
|
|
for (int i = 0; i < friendsList.Count; i++) {
|
|
if (friendsList [i].friendTransform != null) {
|
|
currentFriendList.Add (friendsList [i].friendTransform.gameObject);
|
|
}
|
|
}
|
|
|
|
return currentFriendList;
|
|
}
|
|
|
|
public Transform getClosestByDistanceFriend ()
|
|
{
|
|
if (friendsList.Count == 0) {
|
|
return null;
|
|
}
|
|
|
|
float maxDistanceToTarget = Mathf.Infinity;
|
|
|
|
float currentDistance = 0;
|
|
|
|
Vector3 characterPosition = playerTransform.position;
|
|
|
|
int friendIndex = -1;
|
|
|
|
for (int i = 0; i < friendsList.Count; i++) {
|
|
if (friendsList [i].friendTransform != null) {
|
|
currentDistance = GKC_Utils.distance (characterPosition, friendsList [i].friendTransform.position);
|
|
|
|
if (currentDistance < maxDistanceToTarget) {
|
|
maxDistanceToTarget = currentDistance;
|
|
|
|
friendIndex = i;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (friendIndex != -1) {
|
|
return friendsList [friendIndex].friendTransform;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public bool anyFriendOnList ()
|
|
{
|
|
return (friendsList.Count != 0);
|
|
}
|
|
|
|
public void setUsedByAIState (bool state)
|
|
{
|
|
usedByAI = state;
|
|
}
|
|
|
|
public void inputOpenOrCloseFriendListMenu ()
|
|
{
|
|
if (!openMenuEnabled) {
|
|
return;
|
|
}
|
|
|
|
if (friendManagerEnabled) {
|
|
if (pauseManager.isOpenOrClosePlayerOpenMenuByNamePaused ()) {
|
|
return;
|
|
}
|
|
|
|
openOrCloseFriendMenu (!menuOpened);
|
|
}
|
|
}
|
|
|
|
public void setFriendManagerEnabledState (bool state)
|
|
{
|
|
friendManagerEnabled = state;
|
|
}
|
|
|
|
public void resurrectFullTeam ()
|
|
{
|
|
if (friendManagerEnabled) {
|
|
for (int i = 0; i < friendsList.Count; i++) {
|
|
if (friendsList [i].friendTransform != null) {
|
|
applyDamage.resurrectCharacter (friendsList [i].friendTransform.gameObject);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void resurrectFullTeamAndPlayer ()
|
|
{
|
|
if (friendManagerEnabled) {
|
|
resurrectFullTeam ();
|
|
|
|
applyDamage.resurrectCharacter (playerTransform.gameObject);
|
|
}
|
|
}
|
|
|
|
public void setOpenMenuEnabled (bool state)
|
|
{
|
|
openMenuEnabled = state;
|
|
}
|
|
|
|
//EDITOR FUNCTIONS
|
|
public void setFriendManagerEnabledStateFromEditor (bool state)
|
|
{
|
|
setFriendManagerEnabledState (state);
|
|
|
|
updateComponent ();
|
|
}
|
|
|
|
public void setOpenMenuEnabledFromEditor (bool state)
|
|
{
|
|
setOpenMenuEnabled (state);
|
|
|
|
updateComponent ();
|
|
}
|
|
|
|
void updateComponent ()
|
|
{
|
|
GKC_Utils.updateComponent (this);
|
|
|
|
GKC_Utils.updateDirtyScene ("Update Friend List Manager", gameObject);
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class friendInfo
|
|
{
|
|
public string Name;
|
|
public Transform friendTransform;
|
|
|
|
public Text nameText;
|
|
public Text currentState;
|
|
|
|
[Space]
|
|
|
|
public List<Button> orderButtonList = new List<Button> ();
|
|
|
|
[Space]
|
|
|
|
public GameObject friendListElement;
|
|
|
|
public remoteEventSystem friendRemoteEventSystem;
|
|
|
|
public characterToReceiveOrders mainCharacterToReceiveOrders;
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class orderInfo
|
|
{
|
|
public string Name;
|
|
|
|
public string orderName;
|
|
|
|
public bool checkCharacterToReceiveOrdersComponent;
|
|
|
|
public bool closeMenuOnOrderSelected;
|
|
|
|
[Space]
|
|
|
|
public bool useRemoteEvent;
|
|
|
|
public List<string> remoteEventNameList = new List<string> ();
|
|
|
|
public bool sendPlayerTransformOnEvent;
|
|
|
|
|
|
public bool useRemoteEventListToSendPlayer;
|
|
|
|
public List<string> remoteEventNameListToSendPlayer = new List<string> ();
|
|
|
|
[Space]
|
|
|
|
public bool useCustomOrderBehavior;
|
|
|
|
public bool getCustomTargetFromBehavior;
|
|
|
|
public bool sendPlayerOnOrder;
|
|
|
|
public customOrderBehavior mainCustomOrderBehavior;
|
|
|
|
[Space]
|
|
|
|
public bool useEventOnOrder;
|
|
public UnityEvent eventOnOrder;
|
|
}
|
|
} |