618 lines
19 KiB
C#
618 lines
19 KiB
C#
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
using RPGCreationKit;
|
|
using System;
|
|
using UnityEngine.SceneManagement;
|
|
using RPGCreationKit.CellsSystem;
|
|
using RPGCreationKit.AI;
|
|
using RPGCreationKit.PersistentReferences;
|
|
using RPGCreationKit.SaveSystem;
|
|
|
|
namespace RPGCreationKit
|
|
{
|
|
public enum RCKScriptType
|
|
{
|
|
QuestScript = 0,
|
|
QuestStageScript = 1,
|
|
ItemScript = 2,
|
|
ResultScript = 3
|
|
}
|
|
|
|
[AttributeUsage(AttributeTargets.All, Inherited = false)]
|
|
public class IsConditionAttribute : Attribute { }
|
|
|
|
/// <summary>
|
|
/// This class provides quick static access to useful methods and functions
|
|
/// </summary>
|
|
public static class RCKFunctions
|
|
{
|
|
public static void ExecuteScript(string fullScriptPath)
|
|
{
|
|
QuestScriptManager.instance.scriptsHolder.AddComponent(System.Type.GetType(fullScriptPath));
|
|
}
|
|
|
|
public static void ExecuteEvents(Events events, GameObject caller = null)
|
|
{
|
|
QuestManager.instance.QuestDealerActivator(events.questDealers);
|
|
QuestManager.instance.QuestUpdaterActivator(events.questUpdaters);
|
|
ConsequenceManager.instance.ConsequencesActivator(caller, events.consequences);
|
|
}
|
|
|
|
public static void AddQuest(string newQuestID, int atIndex = 0, bool hideAlert = false)
|
|
{
|
|
QuestManager.instance.AddQuest(newQuestID, atIndex, hideAlert);
|
|
}
|
|
|
|
public static void AddQuestParam(Quest newQuest, int atIndex = 0, bool hideAlert = false)
|
|
{
|
|
QuestManager.instance.AddQuest(newQuest, atIndex, hideAlert);
|
|
}
|
|
|
|
[IsCondition]
|
|
public static int GetStage(string _questID)
|
|
{
|
|
return QuestManager.instance.GetStage(_questID);
|
|
}
|
|
|
|
[IsCondition]
|
|
public static int GetStageFailed(string _questID, int _stage)
|
|
{
|
|
return QuestManager.instance.GetStageFailed(_questID, _stage);
|
|
}
|
|
|
|
[IsCondition]
|
|
public static int GetStageCompleted(string _questID, int _stage)
|
|
{
|
|
return QuestManager.instance.GetStageCompleted(_questID, _stage);
|
|
}
|
|
|
|
[IsCondition]
|
|
public static int GetPlayerEquipped(string _itemID)
|
|
{
|
|
return Equipment.PlayerEquipment.IsEquipped(_itemID) ? 1 : 0;
|
|
}
|
|
|
|
public static bool GetPlayerEquippedBool(string _itemID)
|
|
{
|
|
return Equipment.PlayerEquipment.IsEquipped(_itemID);
|
|
}
|
|
|
|
public static void SetQuestStage(string _questID, int _stageIndex)
|
|
{
|
|
QuestManager.instance.SetQuestStage(_questID, _stageIndex);
|
|
}
|
|
|
|
public static void CompleteQuestStage(string _questID, int _stageIndex)
|
|
{
|
|
QuestManager.instance.CompleteQuestStage(_questID, _stageIndex);
|
|
}
|
|
|
|
public static void CompleteQuestStage(string _questID, int _stageIndex, bool hideLog = false, bool _comesFromLoad = false)
|
|
{
|
|
QuestManager.instance.CompleteQuestStage(_questID, _stageIndex, hideLog, _comesFromLoad);
|
|
}
|
|
|
|
|
|
public static void SetQuestStageParam(Quest _quest, QuestStage _questStage)
|
|
{
|
|
QuestManager.instance.SetQuestStage(_quest, _questStage);
|
|
}
|
|
|
|
|
|
public static void CompleteQuest(Quest _quest)
|
|
{
|
|
QuestManager.instance.CompleteQuest(_quest);
|
|
}
|
|
|
|
public static void FailQuestStage(string _questID, int _stageIndex, bool hideLog = false, bool _comesFromLoad = false)
|
|
{
|
|
QuestManager.instance.FailQuestStage(_questID, _stageIndex, hideLog, _comesFromLoad);
|
|
}
|
|
|
|
|
|
[IsCondition]
|
|
public static bool IsQuestCompleted(string _questID)
|
|
{
|
|
Debug.Log(QuestManager.instance.IsQuestCompleted(_questID));
|
|
return QuestManager.instance.IsQuestCompleted(_questID);
|
|
}
|
|
|
|
public static int GetIsID(string _id, int c64)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
public static void DisplayCurrentQuestObjective(bool isCompleted)
|
|
{
|
|
QuestAlertManager.instance.DisplayCurrentQuestObjective(isCompleted);
|
|
}
|
|
|
|
public static void DisplayQuestObjective(string questID, int stageIndex, bool isCompleted)
|
|
{
|
|
QuestAlertManager.instance.DisplayQuestObjective(questID, stageIndex, isCompleted);
|
|
}
|
|
|
|
public static void DisplayQuestObjective(Quest quest, int stageIndex, bool isCompleted)
|
|
{
|
|
QuestAlertManager.instance.DisplayQuestObjective(quest, stageIndex, isCompleted);
|
|
}
|
|
|
|
public static void InitQuestAlert(Quest newQuest, bool isCompleted)
|
|
{
|
|
QuestAlertManager.instance.InitQuestAlert(newQuest.questName, !isCompleted);
|
|
}
|
|
|
|
public static bool VerifyConditions(Condition[] conditions)
|
|
{
|
|
// No conditions
|
|
if (conditions.Length == 0)
|
|
return true;
|
|
|
|
// At least 1 condition
|
|
int orConditionsNumber = 1;
|
|
|
|
for (int i = 0; i < conditions.Length; i++)
|
|
if (conditions[i].OR)
|
|
orConditionsNumber++;
|
|
|
|
bool[] evaluatedBlocks = new bool[orConditionsNumber];
|
|
|
|
int lastIndex = -1;
|
|
for (int i = 0; i < orConditionsNumber; i++)
|
|
{
|
|
List<bool> currentBlockConditions = new List<bool>();
|
|
for (int j = lastIndex + 1; j < conditions.Length; j++)
|
|
{
|
|
// Add this element
|
|
currentBlockConditions.Add(conditions[j].conditionValue);
|
|
|
|
if (conditions[j].OR)
|
|
{
|
|
// Add this element
|
|
lastIndex = j;
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
/* Debug of Blocks
|
|
Debug.LogWarning("-----BLOCK N: " + i);
|
|
for(int z = 0; z < currentBlockConditions.Count; z++)
|
|
{
|
|
Debug.Log(currentBlockConditions[z]);
|
|
}
|
|
Debug.LogWarning("-----END N: " + i);
|
|
*/
|
|
|
|
bool absEvaluatedBlock = false;
|
|
|
|
// Fill the evaluetedBlocks.
|
|
for (int p = 0; p < currentBlockConditions.Count; p++)
|
|
{
|
|
if (currentBlockConditions[p] == false)
|
|
{
|
|
absEvaluatedBlock = false;
|
|
break;
|
|
}
|
|
|
|
absEvaluatedBlock = true;
|
|
}
|
|
|
|
evaluatedBlocks[i] = absEvaluatedBlock;
|
|
}
|
|
|
|
// Check if there is at least a single true in blocks
|
|
for (int i = 0; i < evaluatedBlocks.Length; i++)
|
|
{
|
|
if (evaluatedBlocks[i]) return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
[IsCondition]
|
|
public static int GetItemCount(Inventory inventory, string itemID)
|
|
{
|
|
return inventory.GetItemCount(itemID);
|
|
}
|
|
|
|
[IsCondition]
|
|
public static int GetItemCountPlayer(string itemID)
|
|
{
|
|
return Inventory.PlayerInventory.GetItemCount(itemID);
|
|
}
|
|
|
|
[IsCondition]
|
|
public static float GetPlayerMaxHealth()
|
|
{
|
|
return GlobalVariables.PlayerMaxHealth;
|
|
}
|
|
|
|
public static bool IsNumber(object value)
|
|
{
|
|
if (value is sbyte) return true;
|
|
if (value is byte) return true;
|
|
if (value is short) return true;
|
|
if (value is ushort) return true;
|
|
if (value is int) return true;
|
|
if (value is uint) return true;
|
|
if (value is long) return true;
|
|
if (value is ulong) return true;
|
|
if (value is float) return true;
|
|
if (value is double) return true;
|
|
if (value is decimal) return true;
|
|
return false;
|
|
}
|
|
|
|
public static Quest GetQuest(string _questID)
|
|
{
|
|
return QuestsDatabase.GetQuest(_questID);
|
|
}
|
|
|
|
public static void StartTrading(Merchant merchant)
|
|
{
|
|
if (merchant != null)
|
|
TradeSystemUI.instance.OpenTradePanel(merchant);
|
|
else
|
|
Debug.LogWarning("Tried to StartTrading but there was no Merchant given");
|
|
}
|
|
|
|
/*
|
|
public static void StartTrading(NPC_Behaviour npc)
|
|
{
|
|
TradeSystemUI.instance.OpenTradePanel(npc, true);
|
|
}
|
|
*/
|
|
|
|
/// <summary>
|
|
/// Gets the distance of the Persistent AI and the player and returns it as a float. Returns the special value 99999.12f if the the Player is in a different cell.
|
|
/// </summary>
|
|
/// <param name="_npcRef"></param>
|
|
/// <returns></returns>
|
|
[IsCondition]
|
|
public static float AI_GetDistanceFromPC(string _npcRef)
|
|
{
|
|
if (IsAILoadedForPlayer(_npcRef))
|
|
{
|
|
// Get the NPC behaviour
|
|
PersistentReference npcRef = PersistentReferenceManager.instance.GetPersistentReference(_npcRef);
|
|
|
|
if (npcRef != null)
|
|
return (Vector3.Distance(Player.RckPlayer.instance.transform.position, npcRef.transform.position));
|
|
else
|
|
return 99999.12f;
|
|
}
|
|
else
|
|
return 99999.12f;
|
|
}
|
|
|
|
public static int GetPCInFaction(string _factionID)
|
|
{
|
|
//return Interactor.instance.
|
|
return 001;
|
|
}
|
|
|
|
public static GameObject GetChildWithName(GameObject obj, string name)
|
|
{
|
|
Transform t = obj.transform;
|
|
Transform childT = t.Find(name);
|
|
if (childT != null)
|
|
{
|
|
return childT.gameObject;
|
|
}
|
|
else
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns true if the provided AI is loaded and present in the same cell of the Player or in a neighbour cell.
|
|
/// </summary>
|
|
public static bool IsAILoadedForPlayer(string _npcRef)
|
|
{
|
|
var npc = PersistentReferences.PersistentReferenceManager.instance.GetPersistentReference(_npcRef);
|
|
if (npc != null)
|
|
{
|
|
if (npc.isActiveAndEnabled && !npc.GetComponent<RPGCreationKit.AI.RckAI>().isInOfflineMode)
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Usage: GameObject.scene.GetCellInformation - Gets the CellInformation of a GameObject, ergo the cell in which the gameobject is at any given point
|
|
/// </summary>
|
|
/// <param name="_scene"></param>
|
|
/// <returns></returns>
|
|
public static CellInformation GetCellInformation(this Scene _scene)
|
|
{
|
|
try
|
|
{
|
|
GameObject[] gos = SceneManager.GetSceneByPath(_scene.path).GetRootGameObjects();
|
|
|
|
for (int z = 0; z < gos.Length; z++)
|
|
{
|
|
if (gos[z].CompareTag("RPG Creation Kit/CellInfo"))
|
|
return gos[z].GetComponent<CellInformation>();
|
|
}
|
|
return null;
|
|
}
|
|
catch
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static bool ContainsBiped(BipedObject[] arr, BipedObject target)
|
|
{
|
|
for(int i = 0; i < arr.Length; i++)
|
|
{
|
|
if (arr[i] == target)
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
[IsCondition]
|
|
public static int IsAIAlive(string _entityID)
|
|
{
|
|
RckAI ai = null;
|
|
CellInformation.TryToGetAI(_entityID, out ai);
|
|
|
|
if (ai != null)
|
|
return ai.isAlive ? 1 : 0;
|
|
else if (SaveSystemManager.instance.saveFile.AIData.aiDictionary.ContainsKey(_entityID))
|
|
{
|
|
// Look in the save files
|
|
AISaveData aiData = SaveSystemManager.instance.saveFile.AIData.aiDictionary[_entityID];
|
|
|
|
return aiData.isAlive ? 1 : 0;
|
|
}
|
|
else
|
|
return 1;
|
|
}
|
|
|
|
[IsCondition]
|
|
public static int IsAILoaded(string _entityID)
|
|
{
|
|
RckAI ai = null;
|
|
CellInformation.TryToGetAI(_entityID, out ai);
|
|
|
|
return (ai != null) ? 1 : 0;
|
|
|
|
}
|
|
|
|
|
|
public static void MutateMutable(string _mutableID, bool _restoreMutable)
|
|
{
|
|
Mutable mutable = null;
|
|
if (CellInformation.TryToGetMutable(_mutableID, out mutable))
|
|
{
|
|
if (!_restoreMutable)
|
|
mutable.Mutate();
|
|
else
|
|
mutable.RestoreToNormal();
|
|
}
|
|
else // Update the save file directly
|
|
{
|
|
var allMutables = SaveSystemManager.instance.saveFile.MutablesData.allMutables;
|
|
|
|
if (!_restoreMutable)
|
|
{
|
|
if (allMutables.ContainsKey(_mutableID))
|
|
allMutables[_mutableID].isMutated = true;
|
|
else
|
|
allMutables.Add(_mutableID, new MutableData(true));
|
|
}
|
|
else
|
|
{
|
|
if (allMutables.ContainsKey(_mutableID))
|
|
allMutables[_mutableID].isMutated = false;
|
|
else
|
|
allMutables.Add(_mutableID, new MutableData(false));
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Unlocks a door, loaded or not.
|
|
/// </summary>
|
|
/// <param name="_doorID">The ID of the door</param>
|
|
public static void UnlockDoor(string _doorID)
|
|
{
|
|
Door door = null;
|
|
|
|
// If Door is loaded
|
|
if (CellInformation.TryToGetDoor(_doorID, out door))
|
|
{
|
|
door.UnlockDoor();
|
|
}
|
|
else // Update the save file directly
|
|
{
|
|
var allDoors = SaveSystemManager.instance.saveFile.DoorData.allDoors;
|
|
|
|
if (allDoors.ContainsKey(_doorID))
|
|
allDoors[_doorID].isLocked = false;
|
|
else
|
|
allDoors.Add(_doorID, new DoorSaveData(_doorID, false));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Locks a door, loaded or not.
|
|
/// </summary>
|
|
/// <param name="_doorID">The ID of the door</param>
|
|
public static void LockDoor(string _doorID, DoorLockLevel _doorLockLevel)
|
|
{
|
|
Door door = null;
|
|
if (CellInformation.TryToGetDoor(_doorID, out door))
|
|
{
|
|
door.LockDoor(_doorLockLevel);
|
|
}
|
|
else // Update the save file directly
|
|
{
|
|
var allDoors = SaveSystemManager.instance.saveFile.DoorData.allDoors;
|
|
|
|
if (allDoors.ContainsKey(_doorID))
|
|
{
|
|
allDoors[_doorID].isLocked = true;
|
|
allDoors[_doorID].doorLockLevel = (int)_doorLockLevel;
|
|
}
|
|
else
|
|
allDoors.Add(_doorID, new DoorSaveData(_doorID, true, (int)_doorLockLevel));
|
|
}
|
|
}
|
|
|
|
public static void DisplayHeardLine(string _line, float _time)
|
|
{
|
|
Player.RckPlayer.instance.DisplayHeardLine(_line, _time);
|
|
}
|
|
|
|
|
|
public static RckAI SpawnAIInCurrentCell(string _ID, Vector3 _pos, Quaternion _rot)
|
|
{
|
|
return CellInformation.activeCells[WorldManager.instance.currentCenterCell.ID].SpawnNewAI(_ID, _pos, _rot);
|
|
}
|
|
|
|
public static void SpawnAIInDistantCell(string _ID, string _cellID, Vector3 _pos, Quaternion _rot)
|
|
{
|
|
CellInformation.activeCells[WorldManager.instance.currentCenterCell.ID].SpawnAIInDistantCell(_ID, _cellID, _pos, _rot);
|
|
}
|
|
|
|
|
|
public static RckAI SpawnAIInCell(string _ID, string _cellID, Vector3 _pos, Quaternion _rot)
|
|
{
|
|
if (CellInformation.activeCells.ContainsKey(_cellID))
|
|
{
|
|
var cell = CellInformation.activeCells[_cellID];
|
|
|
|
if (cell.isActiveInScene)
|
|
return CellInformation.activeCells[_cellID].SpawnNewAI(_ID, _pos, _rot);
|
|
else
|
|
return CellInformation.activeCells[_cellID].SpawnNewAIWhileCellIsCached(_ID, _pos, _rot);
|
|
}
|
|
else
|
|
{
|
|
SpawnAIInDistantCell(_ID, _cellID, _pos, _rot);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
|
|
public static bool SendIntoOblivion(string _rckID)
|
|
{
|
|
// If AI is loaded save and destroy it
|
|
RckAI ai = null;
|
|
CellInformation.TryToGetAI(_rckID, out ai);
|
|
|
|
if(ai != null)
|
|
ai.DestroyThis();
|
|
|
|
|
|
// Pick the AI in the save file
|
|
var aiData = SaveSystem.SaveSystemManager.instance.saveFile.AIData;
|
|
|
|
var rckAIData = aiData.aiDictionary[_rckID];
|
|
|
|
// Remove from CellDictionary
|
|
aiData.aiCellDictionary[rckAIData.saveCellID].allIDs.Remove(_rckID);
|
|
|
|
rckAIData.runtimeSaveCellID = "OBLIVION";
|
|
rckAIData.saveCellID = "OBLIVION";
|
|
|
|
return true;
|
|
}
|
|
|
|
public static bool SummonFromOblivion(string _rckID)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
public static bool RckAI_AddInFaction(string _rckID, string _factionID)
|
|
{
|
|
RckAI ai = null;
|
|
CellInformation.TryToGetAI(_rckID, out ai);
|
|
|
|
if (ai != null)
|
|
{
|
|
ai.AddToFaction(_factionID);
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
|
|
public static bool RckAI_RemoveFromFaction(string _rckID, string _factionID)
|
|
{
|
|
RckAI ai = null;
|
|
CellInformation.TryToGetAI(_rckID, out ai);
|
|
|
|
if (ai != null)
|
|
{
|
|
ai.RemoveFromFaction(_factionID);
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
|
|
public static bool KillRckAI(string _rckID)
|
|
{
|
|
RckAI ai = null;
|
|
CellInformation.TryToGetAI(_rckID, out ai);
|
|
|
|
if (ai != null)
|
|
{
|
|
ai.PlayDeathSound();
|
|
ai.Die();
|
|
return true;
|
|
}
|
|
|
|
// Pick the AI in the save file
|
|
var aiData = SaveSystem.SaveSystemManager.instance.saveFile.AIData;
|
|
if (aiData.aiDictionary.ContainsKey(_rckID))
|
|
{
|
|
var rckAIData = aiData.aiDictionary[_rckID];
|
|
|
|
rckAIData.isAlive = false;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public static bool ChangeDialogueToRckAI(string _rckID, string _dialogueID)
|
|
{
|
|
RckAI ai = null;
|
|
CellInformation.TryToGetAI(_rckID, out ai);
|
|
|
|
if (ai != null)
|
|
{
|
|
ai.ChangeDialogueGraph(_dialogueID);
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
// Pick the AI in the save file
|
|
var aiData = SaveSystem.SaveSystemManager.instance.saveFile.AIData;
|
|
|
|
if (aiData.aiDictionary.ContainsKey(_rckID))
|
|
{
|
|
var rckAIData = aiData.aiDictionary[_rckID];
|
|
|
|
rckAIData.currentDialogueID = _dialogueID;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
}
|
|
} |