/**
* \fn OnEvent
* \brief Plays a sound effect.
* \param data - Event data to parse for validation.
*
**/
override protected void OnEvent(LPK_EventManager.LPK_EventData data)
{
//Incorrect object.
if (!ShouldRespondToEvent(data) || m_bOnCooldown)
{
return;
}
if (m_bPrintDebug)
{
LPK_PrintDebug(this, "Event received.");
}
for (int i = 0; i < m_TargetObjects.Length; i++)
{
if (m_TargetObjects[i].GetComponent <AudioSource>() != null)
{
m_TargetObjects[i].GetComponent <AudioSource>().Play();
}
}
for (int i = 0; i < m_TargetTags.Length; i++)
{
GameObject[] taggedObjects = GameObject.FindGameObjectsWithTag(m_TargetTags[i]);
for (int j = 0; j < taggedObjects.Length; j++)
{
if (taggedObjects[j].GetComponent <AudioSource>() != null)
{
taggedObjects[j].GetComponent <AudioSource>().Play();
}
}
}
m_bOnCooldown = true;
StartCoroutine(CoolDownDelay());
}
/**
* \fn CountDown
* \brief Detects when timer has finished counting down.
*
*
**/
void CountDown()
{
//Send out event.
LPK_EventManager.LPK_EventData data = new LPK_EventManager.LPK_EventData(gameObject, m_TimerCompletedReceiver);
LPK_EventList sendEvent = new LPK_EventList();
sendEvent.m_GameplayEventTrigger = new LPK_EventList.LPK_GAMEPLAY_EVENTS[] { LPK_EventList.LPK_GAMEPLAY_EVENTS.LPK_TimerCompleted };
LPK_EventManager.InvokeEvent(sendEvent, data);
if (m_bPrintDebug)
{
LPK_PrintDebug(this, "Timer Completed");
}
if (m_eTimerPolicy == LPK_TimerPolicy.RESET)
{
SetTime();
}
else
{
m_bPaused = true;
}
}
/**
* FUNCTION NAME: OnAudioLevelsChange
* DESCRIPTION : Call the Audio Source's volume.
* INPUTS : data - Event registration data (unused).
* OUTPUTS : None
**/
void OnAudioLevelsChange(LPK_EventManager.LPK_EventData data)
{
SetAudioLevel();
}
/**
* \fn SpawnObject
* \brief Spawn the desired object. Public so the Unity UI system can interact with this function.
*
*
**/
public void SpawnObject()
{
//Spawn the objects
for (int i = 0; i < m_iSpawnPerEventCount; ++i)
{
if (m_iMaxTotalSpawnCount == 0 || m_iSpawnCount < m_iMaxTotalSpawnCount)
{
//Too many alive objects, but still count the spawn.
//NOTENOTE: If you want failed spawns not to count, remove the increment line below.
if (m_pActiveList.Count >= m_iMaxAliveAtOnce && m_iMaxAliveAtOnce != 0)
{
m_iSpawnCount++;
return;
}
float randX = Random.Range(m_vecOffset.x - m_vecRandomOffsetVariance.x, m_vecOffset.x + m_vecRandomOffsetVariance.x);
float randY = Random.Range(m_vecOffset.y - m_vecRandomOffsetVariance.y, m_vecOffset.y + m_vecRandomOffsetVariance.y);
float randZ = Random.Range(m_vecOffset.z - m_vecRandomOffsetVariance.z, m_vecOffset.z + m_vecRandomOffsetVariance.z);
GameObject obj = (GameObject)Instantiate(m_pPrefabToSpawn, m_pTargetSpawnTransformObj.transform.position + new Vector3(randX, randY, randZ), Quaternion.identity);
if (m_bCopyTargetRotation)
{
obj.transform.rotation = m_pTargetSpawnTransformObj.transform.rotation;
}
if (m_bAttachToSpawnTarget)
{
obj.transform.SetParent(m_pTargetSpawnTransformObj.transform);
}
if (m_bAttachToSpawner)
{
obj.transform.SetParent(gameObject.transform);
}
if (!string.IsNullOrEmpty(m_sNewObjectName))
{
obj.name = m_sNewObjectName;
}
//Dispatch spawn event
GameObject[] temp = new GameObject[m_SpawnObjectReceivers.Length + 1];
for (int j = 0; j < m_SpawnObjectReceivers.Length; j++)
{
temp[j] = m_SpawnObjectReceivers[j];
}
temp[temp.Length - 1] = obj;
//Dispatch spawn event
LPK_EventManager.LPK_EventData sendData = new LPK_EventManager.LPK_EventData(gameObject, null);
LPK_EventList sendEvent = new LPK_EventList();
sendEvent.m_GameplayEventTrigger = new LPK_EventList.LPK_GAMEPLAY_EVENTS[] { LPK_EventList.LPK_GAMEPLAY_EVENTS.LPK_ObjectSpawned };
LPK_EventManager.InvokeEvent(sendEvent, sendData);
if (m_bPrintDebug)
{
LPK_PrintDebug(this, "Object Spawned");
}
m_iSpawnCount++;
m_pActiveList.Add(obj);
}
}
}
/**
* \fn OnEvent
* \brief Sets detecing health modification events.
* \param data - Event data to parse for validation.
*
**/
override protected void OnEvent(LPK_EventManager.LPK_EventData data)
{
//Incorrect object.
if (!ShouldRespondToEvent(data))
{
return;
}
if (data.m_idata.Count < 1 || data.m_bData.Count < 1)
{
return;
}
//Infinite health.
if (m_iHealth == -1)
{
return;
}
int valToSet = 0;
//First bool false = set.
if (data.m_bData[0])
{
valToSet = data.m_idata[0];
}
//First bool true = add.
else if (!data.m_bData[0])
{
valToSet = m_iHealth + data.m_idata[0];
}
//Clamp the incoming health to max health
int finalVal = Mathf.Clamp(valToSet, 0, m_iMaxHealth);
//If the health is being set to a lower value, send a LPK_Damaged event
if (m_iHealth > finalVal)
{
if (gameObject != null) //necessary check in case health is set at initialization
{
LPK_EventManager.LPK_EventData newData = new LPK_EventManager.LPK_EventData(gameObject, m_DamageReceivers);
LPK_EventList sendEvent = new LPK_EventList();
sendEvent.m_CharacterEventTrigger = new LPK_EventList.LPK_CHARACTER_EVENTS[] { LPK_EventList.LPK_CHARACTER_EVENTS.LPK_Damaged };
LPK_EventManager.InvokeEvent(sendEvent, newData);
}
if (m_bPrintDebug)
{
LPK_PrintDebug(this, "Character Damaged");
}
}
//If the health is being set to a higher value, send a LPK_Healed event
else if (m_iHealth < finalVal)
{
if (gameObject != null)//necessary check in case health is set at initialization
{
LPK_EventManager.LPK_EventData newData = new LPK_EventManager.LPK_EventData(gameObject, m_HealingReceivers);
LPK_EventList sendEvent = new LPK_EventList();
sendEvent.m_CharacterEventTrigger = new LPK_EventList.LPK_CHARACTER_EVENTS[] { LPK_EventList.LPK_CHARACTER_EVENTS.LPK_Healed };
LPK_EventManager.InvokeEvent(sendEvent, newData);
}
if (m_bPrintDebug)
{
LPK_PrintDebug(this, "Character Healed");
}
}
//Set the new value
m_iHealth = finalVal;
//Update the display
UpdateDisplay();
if (m_bPrintDebug)
{
LPK_PrintDebug(this, "Current Health:" + m_iHealth);
}
//Dispatch LPK_Death when health reaches 0
if (finalVal == 0)
{
LPK_EventManager.LPK_EventData newData = new LPK_EventManager.LPK_EventData(gameObject, m_DeathReceivers);
LPK_EventList sendEvent = new LPK_EventList();
sendEvent.m_CharacterEventTrigger = new LPK_EventList.LPK_CHARACTER_EVENTS[] { LPK_EventList.LPK_CHARACTER_EVENTS.LPK_Death };
LPK_EventManager.InvokeEvent(sendEvent, newData);
if (m_bPrintDebug)
{
LPK_PrintDebug(this, "Character Died");
}
}
}
/**
* FUNCTION NAME: OnDifficultyLevelChange
* DESCRIPTION : Call the Set Text function.
* INPUTS : data - Event registration data (unused).
* OUTPUTS : None
**/
void OnDifficultyLevelChange(LPK_EventManager.LPK_EventData data)
{
SetText();
}
/**
* \fn AnimationFinished
* \brief Manages how the animator responds if finished.
*
* \return bool - True/False flag for whether or not the animator should animate again.
**/
bool AnimationFinished()
{
if (m_bPrintDebug)
{
LPK_PrintDebug(this, "Finished animation sequence.");
}
LPK_EventManager.LPK_EventData data = new LPK_EventManager.LPK_EventData(gameObject, m_SequenceFinishedReceivers);
LPK_EventList sendEvent = new LPK_EventList();
sendEvent.m_GameplayEventTrigger = new LPK_EventList.LPK_GAMEPLAY_EVENTS[] { LPK_EventList.LPK_GAMEPLAY_EVENTS.LPK_TransformAnimatorSequenceFinished };
LPK_EventManager.InvokeEvent(sendEvent, data);
if (m_eLoopingStyle == LPK_LoopingStyle.LOOP)
{
if (m_KeyFrames.Length < 2)
{
if (m_bPrintDebug)
{
LPK_PrintWarning(this, "Cannot have LOOPING animation if there is only one frame. Changing to PLAY_ONCE.");
}
m_eLoopingStyle = LPK_LoopingStyle.PlAY_ONCE;
m_bIsActive = false;
return(false);
}
m_iCounter = 0;
m_GoalTransformValues = m_KeyFrames[m_iCounter];
return(true);
}
else if (m_eLoopingStyle == LPK_LoopingStyle.PINGPONG)
{
if (m_KeyFrames.Length < 2)
{
if (m_bPrintDebug)
{
LPK_PrintWarning(this, "Cannot have PINGPONG animation if there is only one frame. Changing to PLAY_ONCE.");
}
m_eLoopingStyle = LPK_LoopingStyle.PlAY_ONCE;
m_bIsActive = false;
return(false);
}
//Going backwards.
if (m_iCounterModifier == 1)
{
m_iCounter -= 1;
}
//Going forwards.
else
{
m_iCounter += 1;
}
m_iCounterModifier *= -1;
m_LastTransformValues = m_KeyFrames[m_iCounter];
//Set the next goal.
m_iCounter += 1 * m_iCounterModifier;
m_GoalTransformValues = m_KeyFrames[m_iCounter];
return(true);
}
else
{
m_bIsActive = false;
}
return(false);
}
/**
* FUNCTION NAME: DetectReachNode
* DESCRIPTION : Manage behavior once reaching a node.
* INPUTS : None
* OUTPUTS : None
**/
void DetectReachNode()
{
if (!m_bReachedNode)
{
return;
}
if (!m_bGoingBackwards)
{
m_iCounter++;
}
else
{
m_iCounter--;
}
//Final node reached event sending.
if (m_iCounter > m_Nodes.Length)
{
LPK_EventManager.LPK_EventData data = new LPK_EventManager.LPK_EventData(gameObject, m_ReachFinalNodeReceivers);
LPK_EventList sendEvent = new LPK_EventList();
sendEvent.m_AIEventTrigger = new LPK_EventList.LPK_AI_EVENTS[] { LPK_EventList.LPK_AI_EVENTS.LPK_PathFollowerReachFinalNode };
LPK_EventManager.InvokeEvent(sendEvent, data);
if (m_bPrintDebug)
{
LPK_PrintDebug(this, "Reached end of path.");
}
}
//Move towards the start of the path manually.
if (m_iCounter >= m_Nodes.Length && m_eLoopType == LPK_PathFollowerLoopType.LOOP)
{
m_iCounter = 0;
}
//Teleport to the beggining of the path and resume.
else if (m_iCounter >= m_Nodes.Length && m_eLoopType == LPK_PathFollowerLoopType.LOOP_TELEPORT)
{
m_iCounter = 1;
transform.position = m_Nodes[0].transform.position;
}
//Begin going backwards down the path.
else if ((m_iCounter >= m_Nodes.Length && m_eLoopType == LPK_PathFollowerLoopType.LOOP_BACKTRACK) ||
(m_iCounter < 0 && m_bGoingBackwards))
{
if (!m_bGoingBackwards)
{
m_iCounter = m_Nodes.Length - 2;
}
else
{
//NOTENOTE: Technically the start of the path is now also an end of track, so we call the event here as well.
LPK_EventManager.LPK_EventData data = new LPK_EventManager.LPK_EventData(gameObject, m_ReachFinalNodeReceivers);
LPK_EventList sendEvent = new LPK_EventList();
sendEvent.m_AIEventTrigger = new LPK_EventList.LPK_AI_EVENTS[] { LPK_EventList.LPK_AI_EVENTS.LPK_PathFollowerReachFinalNode };
LPK_EventManager.InvokeEvent(sendEvent, data);
m_iCounter = 1;
}
m_bGoingBackwards = !m_bGoingBackwards;
}
//Reset and move again.
if (m_iCounter < m_Nodes.Length)
{
m_bReachedNode = false;
}
}
/**
* \fn OnEvent
* \brief Sets the active state of the gameobjects.
* \param data - Event data to parse for validation.
*
**/
override protected void OnEvent(LPK_EventManager.LPK_EventData data)
{
//Incorrect object.
if (!ShouldRespondToEvent(data))
{
return;
}
//Debug search.
for (int i = 0; i < m_ModifyGameObject.Length; i++)
{
if (m_ModifyGameObject[i] == null)
{
continue;
}
if (m_ToggleType == LPK_ToggleType.ON)
{
m_ModifyGameObject[i].SetActive(true);
}
else if (m_ToggleType == LPK_ToggleType.OFF)
{
m_ModifyGameObject[i].SetActive(false);
}
else if (m_ToggleType == LPK_ToggleType.TOGGLE)
{
if (!m_ModifyGameObject[i].activeSelf)
{
m_ModifyGameObject[i].SetActive(true);
}
else if (m_ModifyGameObject[i].activeSelf)
{
m_ModifyGameObject[i].SetActive(false);
}
}
//Debug info.
if (m_bPrintDebug && m_ModifyGameObject[i].activeSelf)
{
LPK_PrintDebug(this, "Changing active state of " + m_ModifyGameObject[i] + " to ON.");
}
else if (m_bPrintDebug && !m_ModifyGameObject[i].activeSelf)
{
LPK_PrintDebug(this, "Changing active state of " + m_ModifyGameObject[i] + " to OFF.");
}
}
//Tag search.
for (int i = 0; i < m_ModifyTag.Length; i++)
{
if (m_ModifyTag[i] == null)
{
continue;
}
GameObject[] objects = GameObject.FindGameObjectsWithTag(m_ModifyTag[i]);
for (int j = 0; j < objects.Length; j++)
{
if (m_ToggleType == LPK_ToggleType.ON)
{
objects[j].SetActive(true);
}
else if (m_ToggleType == LPK_ToggleType.OFF)
{
objects[j].SetActive(false);
}
else if (m_ToggleType == LPK_ToggleType.TOGGLE)
{
if (!objects[j].activeSelf)
{
objects[j].SetActive(true);
}
else if (objects[j].activeSelf)
{
objects[j].SetActive(false);
}
}
//Debug info.
if (m_bPrintDebug && objects[j].activeSelf)
{
LPK_PrintDebug(this, "Changing active state of " + objects[j] + " to ON.");
}
else if (m_bPrintDebug && !objects[j].activeSelf)
{
LPK_PrintDebug(this, "Changing active state of " + objects[j] + " to OFF.");
}
}
}
}
/**
* FUNCTION NAME: OnEvent
* DESCRIPTION : Updates the counter value.
* INPUTS : data - modify value.
* OUTPUTS : None
**/
override protected void OnEvent(LPK_EventManager.LPK_EventData data)
{
//Incorrect object.
if (!ShouldRespondToEvent(data))
{
return;
}
//Incorrect data sent.
if (data.m_bData.Count < 1 || data.m_idata.Count < 1)
{
return;
}
int valToSet = 0;
//Set the value to event value.
if (data.m_bData[0])
{
valToSet = data.m_idata[0];
}
//Add the two values.
else if (!data.m_bData[0])
{
valToSet = m_iValue + data.m_idata[0];
}
//Clamp the incoming counter value
int finalVal = Mathf.Clamp(valToSet, m_iMinValue, m_iMaxValue);
if (finalVal > m_iValue)
{
DispatchIncreaseEvent();
}
else if (finalVal < m_iValue)
{
DispatchDecreaseEvent();
}
if (finalVal != m_iValue)
{
DispatchModifyEvent();
}
m_iValue = finalVal;
UpdateDisplay();
//Dispatch threshold event
if (m_eThresholdMode == LPK_CounterThresholdMode.EQUAL_TO && m_iValue == m_iThresholdValue)
{
DispatchThresholdEvent();
}
else if (m_eThresholdMode == LPK_CounterThresholdMode.NOT_EQUAL_TO && m_iValue != m_iThresholdValue)
{
DispatchThresholdEvent();
}
else if (m_eThresholdMode == LPK_CounterThresholdMode.GREATER_THAN && m_iValue > m_iThresholdValue)
{
DispatchThresholdEvent();
}
else if (m_eThresholdMode == LPK_CounterThresholdMode.LESS_THAN && m_iValue < m_iThresholdValue)
{
DispatchThresholdEvent();
}
else if (m_eThresholdMode == LPK_CounterThresholdMode.GREATER_EQUAL && m_iValue >= m_iThresholdValue)
{
DispatchThresholdEvent();
}
else if (m_eThresholdMode == LPK_CounterThresholdMode.LESS_EQUAL && m_iValue <= m_iThresholdValue)
{
DispatchThresholdEvent();
}
if (m_bPrintDebug)
{
LPK_PrintDebug(this, "New Counter Value: " + m_iValue);
}
}
