/// <Summary>
/// Execute method of event process.
/// </Summary>
/// <param name="controller">Game controller object.</param>
/// <param name="eventPos">The position of the event.</param>
/// <param name="eventParts">The event parts data.</param>
public void ExecuteEvent(GameObject controller, Vector2Int eventPos, AriadneEventParts parts)
{
gameController = controller;
this.sendShowingMsgList = parts.msgList;
this.sendParts = parts;
SendShowingMessage(gameController);
}
/// <Summary>
/// Copy constructor of base parts.
/// </Summary>
/// <param name="baseParts">Base parts data for copying.</param>
public AriadneEventParts(AriadneEventParts baseParts)
{
eventCategory = baseParts.eventCategory;
eventTrigger = baseParts.eventTrigger;
eventPos = baseParts.eventPos;
startCondition = baseParts.startCondition;
startFlagName = baseParts.startFlagName;
startItemId = baseParts.startItemId;
startNum = baseParts.startNum;
comparisonOperator = baseParts.comparisonOperator;
hasExecutedFlag = baseParts.hasExecutedFlag;
executedFlagName = baseParts.executedFlagName;
doorKeyType = baseParts.doorKeyType;
destDungeon = baseParts.destDungeon;
destMap = baseParts.destMap;
destPos = baseParts.destPos;
direction = baseParts.direction;
treasureType = baseParts.treasureType;
itemId = baseParts.itemId;
itemNum = baseParts.itemNum;
msgList = new List <string>();
foreach (string msg in baseParts.msgList)
{
msgList.Add(msg);
}
}
/// <Summary>
/// Returns the flag that the event is executed.
/// This method is called when the key is pressed.
/// </Summary>
/// <param name="eventData">Event data of the position.</param>
/// <param name="targetPos">Target position.</param>
/// <param name="eventStartPos">Starting position of the event defined in the event parts.</param>
bool ExecuteEventOnKeyPressed(EventMasterData eventData, Vector2Int targetPos, AriadneEventPosition eventStartPos)
{
bool isEventExecute = false;
fadeManager.FadeOutKeyWait();
if (eventData == null)
{
return(isEventExecute);
}
AriadneEventParts parts = eventProcessor.GetExecutionEventParts(eventData);
if (parts == null)
{
return(isEventExecute);
}
if (parts.eventPos != eventStartPos)
{
return(isEventExecute);
}
if (parts.eventTrigger == AriadneEventTrigger.KeyPress)
{
// Execute event.
isEventExecute = true;
SetEventTraverse(targetPos);
this.isExecutingEvent = true;
SetArrowButtonState(false);
eventProcessor.EventExecuter(parts, targetPos);
}
return(isEventExecute);
}
/// <Summary>
/// Execute events according to event type.
/// </Summary>
/// <param name="eventParts">The event parts to execute.</param>
/// <param name="eventPos">The position of event.</param>
public void EventExecuter(AriadneEventParts eventParts, Vector2Int eventPos)
{
AriadneEventStrategyFactory factory = gameController.GetComponent <AriadneEventStrategyFactory>();
IAriadneEventStrategy iEventExecuter = factory.GetEventExecuter(eventParts.eventCategory);
iEventExecuter.ExecuteEvent(gameController, eventPos, eventParts);
}
/// <Summary>
/// Showing message process.
/// </Summary>
/// <param name="msg">Message list to show.</param>
/// <param name="eventParts">The event parts to execute.</param>
IEnumerator ShowMessages(List <string> msg, AriadneEventParts eventParts)
{
// Fade in message window.
fadeManager.ClearText();
fadeManager.FadeInMsgWindow();
var wait = new WaitForSeconds(0.2f);
for (int page = 0; page < msg.Count; page++)
{
fadeManager.SetText(msg[page]);
yield return(new WaitForSeconds(fadeManager.keyWaitFadeTime));
isWaitingMsg = true;
while (isWaitingMsg)
{
yield return(wait);
}
}
fadeManager.FadeOutMsgWindow();
yield return(new WaitForSeconds(fadeManager.keyWaitFadeTime));
PostEvent(eventParts);
}
/// <Summary>
/// Door opening process.
/// </Summary>
/// <param name="doorObj">The door object to animate.</param>
/// <param name="eventParts">The event parts data.</param>
protected IEnumerator OpenDoor(GameObject doorObj, AriadneEventParts eventParts)
{
// Get door animatior component.
DoorAnimator doorAnim = doorObj.GetComponent <DoorAnimator>();
if (doorAnim != null)
{
// Send door open message
doorAnim.OpenDoor();
// Wait until door opend
yield return(new WaitForSeconds(doorOpenTime));
// Move 2 step
SendOpenDoorAndMoveMessage(gameController);
float wait = 0.1f;
isWaitingMove = true;
while (isWaitingMove)
{
yield return(new WaitForSeconds(wait));
}
// Close door
doorAnim.CloseDoor();
}
else
{
AnimatorWarning(doorObj);
}
PostEvent(eventParts);
// Check if that event exists on the new position after moving.
SendPostOpenDoorMessage(gameController);
}
/// <Summary>
/// Key type checking of the locked door.
/// </Summary>
/// <param name="doorObj">The door object to animate.</param>
/// <param name="eventParts">The event parts data.</param>
void OpenLockedDoor(GameObject doorObj, AriadneEventParts eventParts)
{
// Check the key type of door
DoorKeyType keyType = eventParts.doorKeyType;
bool isKeyMatched = ItemManager.CheckCorrespondingKey(keyType);
// If the key type was None, treat the door as unlocked.
if (keyType == DoorKeyType.None)
{
isKeyMatched = true;
}
if (isKeyMatched)
{
StartCoroutine(OpenDoor(doorObj, eventParts));
}
else
{
string msg = "You don't have any corresponding key.";
List <string> msgList = new List <string>();
msgList.Add(msg);
this.sendShowingMsgList = msgList;
this.sendParts = eventParts;
SendShowingMessage(gameController);
}
}
/// <Summary>
/// Show edit button and remove button.
/// When remove button is pressed, confirming dialog will be shown.
/// </Summary>
/// <param name="i">Index of the event parts.</param>
void ShowEditAndRemoveButtonParts(int i)
{
EditorGUILayout.BeginHorizontal();
{
if (eventPartsList.Count > 1)
{
if (GUILayout.Button("Remove", removeStyle))
{
string confirmMsg = "Remove this event parts?" + "\n"
+ "Index : " + i.ToString() + " \n"
+ "Event Category : " + eventPartsList[i].eventCategory.ToString();
bool dialogChoice = EditorUtility.DisplayDialog("Confirm",
confirmMsg,
"Remove",
"Cancel");
if (dialogChoice)
{
selectedParts = -1;
Undo.RecordObject(this, undoName);
eventPartsList.RemoveAt(i);
}
}
}
if (GUILayout.Button("Edit", editStyle))
{
// Set event data of this index.
selectedParts = i;
editingEventParts = new AriadneEventParts(eventPartsList[selectedParts]);
GetExecutedFlagList();
ClearUndoStack();
}
}
EditorGUILayout.EndHorizontal();
}
/// <Summary>
/// Increasing (or decreasing) item process.
/// This method is called when increase (or decrease) item without animation too.
/// </Summary>
/// <param name="treasureObj">The treasure box object to animate.</param>
/// <param name="eventParts">The event parts data.</param>
void SetTreasureItem(AriadneEventParts eventParts)
{
string msg = "";
int num = eventParts.itemNum;
int numOnShowing = Mathf.Abs(num);
string gotOrLost = num >= 0 ? "got" : "lost";
if (eventParts.treasureType == TreasureType.Item)
{
string itemName = ItemManager.GetItemNameById(eventParts.itemId);
if (itemName == ItemManager.ITEM_NAME_NONE)
{
Debug.LogWarning("It seems that specified item ID is not defined. Check the setting of the event parts.");
}
msg = "You " + gotOrLost + " follow item." + "\n"
+ itemName + " : " + numOnShowing.ToString();
ItemManager.SetHoldItemList(eventParts.itemId, eventParts.itemNum);
}
else if (eventParts.treasureType == TreasureType.Money)
{
string unit = numOnShowing == 1 ? UNIT_OF_MONEY : UNIT_OF_MONEY + "s";
msg = "You " + gotOrLost + " " + numOnShowing.ToString() + " " + unit + ".";
ItemManager.money += num;
}
List <string> msgList = new List <string>();
msgList.Add(msg);
this.sendShowingMsgList = msgList;
this.sendParts = eventParts;
SendShowingMessage(gameController);
}
/// <Summary>
/// Set the event executed flag if the event parts had.
/// </Summary>
/// <param name="parts">The executed event parts data.</param>
protected void SetEventExecutedFlag(AriadneEventParts parts)
{
if (parts.hasExecutedFlag && parts.executedFlagName != "")
{
FlagManager.SetEventFlagDict(parts.executedFlagName, true);
}
}
/// <Summary>
/// Move position event process.
/// </Summary>
/// <param name="eventParts">Event parts data.</param>
IEnumerator EventMovePosition(AriadneEventParts eventParts)
{
// Fade out
fadeManager.FadeOut();
var waitTime = new WaitForSeconds(fadeManager.fadeTime);
yield return(waitTime);
// Set new position
if (eventParts.destDungeon == null)
{
Debug.LogError("Dest dungeon is not assigned to this EventData!");
yield break;
}
if (eventParts.destMap == null)
{
Debug.LogError("Dest map is not assigned to this EventData!");
yield break;
}
// Send dungeon data to DungeonSetting.
moveDestDungeon = eventParts.destDungeon;
SendDungeonData(gameController);
PlayerPosition.currentDungeonId = eventParts.destDungeon.dungeonId;
PlayerPosition.currentFloorId = eventParts.destMap.floorId;
PlayerPosition.playerPos = eventParts.destPos;
PlayerPosition.direction = eventParts.direction;
// Get new floor data
DungeonSettings ds = gameController.GetComponent <DungeonSettings>();
dungeonData = ds.dungeonData;
floorMapData = ds.GetCurrentFloorData();
// Add traverse data
TraverseManager.AddDungeonTraverseData(PlayerPosition.currentDungeonId, PlayerPosition.currentFloorId, floorMapData);
PlayerPosition.SetTraverseData();
yield return(waitTime);
// Remove dungeon walls and redraw dungeon
SendRedrawMessage(gameController);
// Move camera
SetCameraPos();
float targetAngle = CurrentDirAngle();
player.transform.eulerAngles = new Vector3(0, targetAngle, 0);
SendSetNewMap();
SendSetDirtyMsg();
yield return(waitTime);
// Fade in
fadeManager.FadeIn();
yield return(waitTime);
OnPostEvent();
}
/// <Summary>
/// Initialize properties of EventEditor.
/// </Summary>
void InitializeProperties()
{
this.eventName = MapEditorUtil.eventDefaultName;
this.eventPartsList = new List <AriadneEventParts>();
this.editingEventParts = null;
GetTreasureItemList();
GetExecutedFlagList();
}
/// <Summary>
/// Start point of showing message UI.
/// </Summary>
/// <param name="msg">Message list to show.</param>
/// <param name="eventParts">The event parts to execute.</param>
public void OnShowingMsg(List <string> msg, AriadneEventParts eventParts)
{
if (msg == null)
{
PostEvent(eventParts);
return;
}
StartCoroutine(ShowMessages(msg, eventParts));
}
/// <Summary>
/// Execute method of event process.
/// </Summary>
/// <param name="controller">Game controller object.</param>
/// <param name="eventPos">The position of the event.</param>
/// <param name="eventParts">The event parts data.</param>
public void ExecuteEvent(GameObject controller, Vector2Int eventPos, AriadneEventParts parts)
{
gameController = controller;
GameObject doorObj = GetEventObj(eventPos, MapAttributeDefine.LOCKED_DOOR);
if (doorObj != null)
{
OpenLockedDoor(doorObj, parts);
}
else
{
MissingEventObjectError(eventPos);
}
}
/// <Summary>
/// Execute method of event process.
/// </Summary>
/// <param name="controller">Game controller object.</param>
/// <param name="eventPos">The position of the event.</param>
/// <param name="eventParts">The event parts data.</param>
public void ExecuteEvent(GameObject controller, Vector2Int eventPos, AriadneEventParts parts)
{
gameController = controller;
GameObject treasureObj = GetEventObj(eventPos, MapAttributeDefine.TREASURE);
if (treasureObj != null)
{
StartCoroutine(TreasureAnimation(treasureObj, parts));
}
else
{
// Set item without animation.
SetTreasureItem(parts);
}
}
/// <Summary>
/// Set treasure box open state by checking event flags.
/// When all flags in the event are true, open the treasure box.
/// </Summary>
/// <param name="treasureBoxObj">The treasure box object to instantiate.</param>
/// <param name="index">Index of the position in MapInfo list.</param>
void SetTreasureBoxState(GameObject treasureBoxObj, int index)
{
TreasureAnimator treasureAnim = treasureBoxObj.GetComponent <TreasureAnimator>();
if (treasureAnim == null)
{
return;
}
EventMasterData eventData = null;
int eventId = currentFloorMapData.mapInfo[index].eventId;
if (eventId > 0)
{
string path = "EventData/event_" + eventId.ToString("D5");
eventData = (EventMasterData)Resources.Load(path);
}
if (eventData == null)
{
return;
}
bool isOpend = false;
AriadneEventParts parts = null;
for (int i = eventData.eventParts.Count - 1; i >= 0; i--)
{
parts = eventData.eventParts[i];
if (parts == null)
{
continue;
}
if (parts.hasExecutedFlag && !string.IsNullOrEmpty(parts.executedFlagName))
{
isOpend = FlagManager.CheckEventFlag(parts.executedFlagName);
}
}
if (!isOpend)
{
return;
}
treasureAnim.OpenTreasureBoxImmediately();
}
/// <Summary>
/// Ready event parts for edit to avoid changing ScriptableObject directly.
/// </Summary>
List <AriadneEventParts> GetEventPartsListForEdit(List <AriadneEventParts> partsList)
{
List <AriadneEventParts> partsListForEdit = new List <AriadneEventParts>();
if (partsList == null)
{
return(partsListForEdit);
}
foreach (AriadneEventParts parts in partsList)
{
if (parts == null)
{
continue;
}
AriadneEventParts partsForEdit = new AriadneEventParts(parts);
partsListForEdit.Add(partsForEdit);
}
return(partsListForEdit);
}
/// <Summary>
/// Returns the event parts data that matched the condition.
/// </Summary>
/// <param name="eventData">The event data of target position.</param>
public AriadneEventParts GetExecutionEventParts(EventMasterData eventData)
{
if (eventData.eventParts == null)
{
return(null);
}
AriadneEventParts parts = null;
// Check the condition of event parts from last index.
for (int i = eventData.eventParts.Count - 1; i >= 0; i--)
{
parts = eventData.eventParts[i];
if (CheckEventPartsCondition(parts))
{
break;
}
}
return(parts);
}
/// <Summary>
/// Treasure box opening process.
/// </Summary>
/// <param name="treasureObj">The treasure box object to animate.</param>
/// <param name="eventParts">The event parts data.</param>
IEnumerator TreasureAnimation(GameObject treasureObj, AriadneEventParts eventParts)
{
// Get the TreasureAnimator component.
TreasureAnimator treasureAnim = treasureObj.GetComponent <TreasureAnimator>();
if (treasureAnim != null)
{
// Send treasure open message.
treasureAnim.OpenTreasureBox();
// Wait until the treasure box is opened.
yield return(new WaitForSeconds(treasureAnimTime));
// Show item message.
SetTreasureItem(eventParts);
}
else
{
AnimatorWarning(treasureObj);
}
}
/// <Summary>
/// Show apply button and cancel button.
/// </Summary>
void ShowApplyAndCancelButtonParts()
{
EditorGUILayout.BeginVertical();
{
EditorGUILayout.BeginHorizontal();
{
if (GUILayout.Button("Cancel"))
{
selectedParts = -1;
}
GUIStyle applyStyle = new GUIStyle(GUI.skin.button);
applyStyle.fontStyle = FontStyle.Bold;
if (GUILayout.Button("Apply", applyStyle))
{
eventPartsList[selectedParts] = editingEventParts;
editingEventParts = new AriadneEventParts(eventPartsList[selectedParts]);
}
}
EditorGUILayout.EndHorizontal();
}
EditorGUILayout.EndVertical();
}
/// <Summary>
/// Returns the flag that the event is executed.
/// This method is called after the player has moved.
/// </Summary>
/// <param name="eventData">Event data of the position.</param>
/// <param name="targetPos">Target position.</param>
/// <param name="eventStartPos">Starting position of the event defined in the event parts.</param>
bool ExecuteEventOnPostMove(EventMasterData eventData, Vector2Int targetPos, AriadneEventPosition eventStartPos)
{
bool isEventExecute = false;
if (eventData == null)
{
return(isEventExecute);
}
AriadneEventParts parts = eventProcessor.GetExecutionEventParts(eventData);
if (parts == null)
{
return(isEventExecute);
}
if (parts.eventPos != eventStartPos)
{
return(isEventExecute);
}
if (parts.eventTrigger == AriadneEventTrigger.Auto)
{
// Execute event immediately.
isEventExecute = true;
SetEventTraverse(targetPos);
this.isExecutingEvent = true;
InitializeButtonPressedState();
SetArrowButtonState(false);
eventProcessor.EventExecuter(parts, targetPos);
}
else
{
// Set key wait flag.
this.isEventReady = true;
fadeManager.FadeInKeyWait();
}
return(isEventExecute);
}
/// <Summary>
/// Returns that event parts condition is matched.
/// </Summary>
/// <param name="parts">The event parts to check the condition.</param>
bool CheckEventPartsCondition(AriadneEventParts parts)
{
bool isMatched = false;
switch (parts.startCondition)
{
case AriadneEventCondition.Flag:
isMatched = FlagManager.CheckEventFlag(parts.startFlagName);
break;
case AriadneEventCondition.Item:
isMatched = ItemManager.CheckEventConditionItem(parts.startItemId, parts.comparisonOperator, parts.startNum);
break;
case AriadneEventCondition.Money:
isMatched = ItemManager.CheckEventConditionMoney(parts.comparisonOperator, parts.startNum);
break;
case AriadneEventCondition.NoCondition:
isMatched = true;
break;
}
return(isMatched);
}
/// <Summary>
/// Show information parts about event parts data.
/// </Summary>
void ShowEachEventPartsInformation()
{
EditorGUILayout.BeginVertical();
{
for (int i = 0; i < eventPartsList.Count; i++)
{
EditorGUILayout.BeginVertical("Box");
{
ShowEventPartsCategoryAndConditions(i);
ShowEditAndRemoveButtonParts(i);
}
EditorGUILayout.EndVertical();
EditorGUILayout.Space();
}
if (GUILayout.Button("Add event parts"))
{
var newParts = new AriadneEventParts();
Undo.RecordObject(this, undoName);
eventPartsList.Add(newParts);
}
}
EditorGUILayout.EndVertical();
}
/// <Summary>
/// Execute method of event process.
/// </Summary>
/// <param name="controller">Game controller object.</param>
/// <param name="eventPos">The position of the event.</param>
/// <param name="eventParts">The event parts data.</param>
public void ExecuteEvent(GameObject controller, Vector2Int eventPos, AriadneEventParts parts)
{
gameController = controller;
SendExitDungeonMessage(gameController);
}
/// <Summary>
/// Execute method of event process.
/// </Summary>
/// <param name="controller">Game controller object.</param>
/// <param name="eventPos">The position of the event.</param>
/// <param name="eventParts">The event parts data.</param>
public void ExecuteEvent(GameObject controller, Vector2Int eventPos, AriadneEventParts parts)
{
gameController = controller;
this.sendParts = parts;
SendMovePositionMessage(gameController);
}
/// <Summary>
/// Execute method of event process.
/// </Summary>
/// <param name="controller">Game controller object.</param>
/// <param name="eventPos">The position of the event.</param>
/// <param name="eventParts">The event parts data.</param>
public void ExecuteEvent(GameObject controller, Vector2Int eventPos, AriadneEventParts parts)
{
gameController = controller;
PostEvent(parts);
}
/// <Summary>
/// Receiver of OnMovePosition message from IEventProcessor.
/// </Summary>
/// <param name="eventParts">Event parts data.</param>
public void OnMovePosition(AriadneEventParts eventParts)
{
StartCoroutine(EventMovePosition(eventParts));
}
/// <Summary>
/// The post process of event.
/// Check the event executed flag in this method.
/// </Summary>
/// <param name="parts">The executed event parts data.</param>
protected void PostEvent(AriadneEventParts parts)
{
SetEventExecutedFlag(parts);
SendEventFinishedMessage(gameController);
}
