/** * FUNCTION NAME: JumpInputPress * DESCRIPTION : Manages jump input if set to respond to PRESS. * INPUTS : None * OUTPUTS : None **/ void JumpInputPress() { if (!string.IsNullOrEmpty(m_JumpButton) && Input.GetButtonDown(m_JumpButton)) { //If the character is grounded if (m_GroundedInfo.m_bGrounded) { //Apply upward velocity based on specified speed m_cRigidBody.velocity = new Vector3(m_cRigidBody.velocity.x, m_flJumpSpeed, 0); m_GroundedInfo.m_bGrounded = false; m_iDelayFrame = 2; m_bIsJumping = true; //Dispatch Jump LPK_EventManager.LPK_EventData data = new LPK_EventManager.LPK_EventData(gameObject, m_CharacterJumpEventReceivers); LPK_EventList sendEvent = new LPK_EventList(); sendEvent.m_CharacterEventTrigger = new LPK_EventList.LPK_CHARACTER_EVENTS[] { LPK_EventList.LPK_CHARACTER_EVENTS.LPK_CharacterJump }; LPK_EventManager.InvokeEvent(sendEvent, data); if (m_bPrintDebug) { LPK_PrintError(this, "Jumping via PRESS input."); } } //If character isnt grounded but air jump is enabled and available else if (m_iMaxAirJumps >= 1 && m_iAirJumpsUsed < m_iMaxAirJumps) { m_iAirJumpsUsed++; //Apply upward velocity based on specified speed if (m_bAirJumpDecreaseVelocity) { m_cRigidBody.velocity = new Vector3(m_cRigidBody.velocity.x, (m_flJumpSpeed) / m_iAirJumpsUsed, 0); } else { m_cRigidBody.velocity = new Vector3(m_cRigidBody.velocity.x, m_flJumpSpeed, 0); } m_bIsJumping = true; //Dispatch Jump LPK_EventManager.LPK_EventData data = new LPK_EventManager.LPK_EventData(gameObject, m_CharacterJumpEventReceivers); LPK_EventList sendEvent = new LPK_EventList(); sendEvent.m_CharacterEventTrigger = new LPK_EventList.LPK_CHARACTER_EVENTS[] { LPK_EventList.LPK_CHARACTER_EVENTS.LPK_CharacterJump }; LPK_EventManager.InvokeEvent(sendEvent, data); if (m_bPrintDebug) { LPK_PrintError(this, "Air jump via PRESS input."); } } } }
/** * FUNCTION NAME: ChangeCounter * DESCRIPTION : Changes counter values on event receiving. * INPUTS : None * OUTPUTS : None **/ void ChangeCounter() { if (m_bPrintDebug) { LPK_PrintDebug(this, "LPK_CounterModify Event Dispatched"); } //Set recharging m_bOnCooldown = true; //Event dispatch. LPK_EventManager.LPK_EventData data = new LPK_EventManager.LPK_EventData(gameObject, m_CounterReceiver); if (m_eMode == LPK_CounterModifyMode.SET) { data.m_bData.Add(true); } else { data.m_bData.Add(false); } data.m_idata.Add(m_iValue); LPK_EventList sendEvent = new LPK_EventList(); sendEvent.m_GameplayEventTrigger = new LPK_EventList.LPK_GAMEPLAY_EVENTS[] { LPK_EventList.LPK_GAMEPLAY_EVENTS.LPK_CounterModify }; LPK_EventManager.InvokeEvent(sendEvent, data); StartCoroutine(DelayTimer()); }
/** * \fn ChangeHealth * \brief Changes the health of the target object. * * **/ void ChangeHealth() { if (m_bPrintDebug) { LPK_PrintDebug(this, "Health Change Event Dispatched"); } //Set recharging m_bOnCooldown = true; //Create and dispatch a LPK_HealthModify event //Gather event data. LPK_EventManager.LPK_EventData data = new LPK_EventManager.LPK_EventData(gameObject, m_HealthModificationReceiver); if (m_eMode == LPK_HealthModifyMode.ADD) { data.m_bData.Add(false); } else if (m_eMode == LPK_HealthModifyMode.SET) { data.m_bData.Add(true); } data.m_idata.Add(m_iValue); LPK_EventList sendEvent = new LPK_EventList(); sendEvent.m_CharacterEventTrigger = new LPK_EventList.LPK_CHARACTER_EVENTS[] { LPK_EventList.LPK_CHARACTER_EVENTS.LPK_HealthModified }; LPK_EventManager.InvokeEvent(sendEvent, data); StartCoroutine(DelayTimer()); }
/** * FUNCTION NAME: OnEvent * DESCRIPTION : Sets detecing death events. * INPUTS : data - Event data to parse for validation. * OUTPUTS : None **/ override protected void OnEvent(LPK_EventManager.LPK_EventData data) { //Incorrect object. if (!ShouldRespondToEvent(data)) { return; } --m_iLives; UpdateDisplay(); if (m_bPrintDebug) { LPK_PrintDebug(this, "Character Died"); LPK_PrintDebug(this, "Current Lives: " + m_iLives); } //Dispatch out of lives if (m_iLives <= 0) { LPK_EventManager.LPK_EventData newData = new LPK_EventManager.LPK_EventData(gameObject, m_OutOfLivesReceivers); LPK_EventList sendEvent = new LPK_EventList(); sendEvent.m_CharacterEventTrigger = new LPK_EventList.LPK_CHARACTER_EVENTS[] { LPK_EventList.LPK_CHARACTER_EVENTS.LPK_OutOfLives }; LPK_EventManager.InvokeEvent(sendEvent, newData); } }
/** * \fn CountUp * \brief Detects when timer has finished counting up. * * **/ void CountUp() { //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) { m_flCurrentTime = 0.0f; SetTime(); } else { m_bPaused = true; } }
/** * \fn KeyFrameFinished * \brief Updates what the last keyframe played in the animation was. * * **/ void KeyFrameFinished() { if (m_bPrintDebug) { LPK_PrintDebug(this, "Finished keyframe."); } LPK_EventManager.LPK_EventData data = new LPK_EventManager.LPK_EventData(gameObject, m_KeyFrameFinishedReceivers); data.m_idata.Add(m_iCounter); LPK_EventList sendEvent = new LPK_EventList(); sendEvent.m_GameplayEventTrigger = new LPK_EventList.LPK_GAMEPLAY_EVENTS[] { LPK_EventList.LPK_GAMEPLAY_EVENTS.LPK_TransformAnimatorKeyframeFinished }; LPK_EventManager.InvokeEvent(sendEvent, data); //Reset values. m_LastTransformValues = m_KeyFrames[m_iCounter]; m_flPassedTime = 0.0f; m_iCounter += 1 * m_iCounterModifier; if (m_iCounter >= 0 && m_iCounter < m_KeyFrames.Length) { m_GoalTransformValues = m_KeyFrames[m_iCounter]; } }
void RespondToCollision(int otherTeamID) { //If the otherObject belongs to the same team, send LPK_AllyCollision if (otherTeamID == m_iTeam) { LPK_EventManager.LPK_EventData data = new LPK_EventManager.LPK_EventData(gameObject, m_TeamCollisionReceivers); LPK_EventList sendEvent = new LPK_EventList(); sendEvent.m_CharacterEventTrigger = new LPK_EventList.LPK_CHARACTER_EVENTS[] { LPK_EventList.LPK_CHARACTER_EVENTS.LPK_AllyCollision }; LPK_EventManager.InvokeEvent(sendEvent, data); if (m_bPrintDebug) { LPK_PrintDebug(this, "Ally Collision Event Dispatched"); } } //If the otherObject belongs to a different team, send LPK_EnemyCollision if (otherTeamID != m_iTeam) { LPK_EventManager.LPK_EventData data = new LPK_EventManager.LPK_EventData(gameObject, m_TeamCollisionReceivers); LPK_EventList sendEvent = new LPK_EventList(); sendEvent.m_CharacterEventTrigger = new LPK_EventList.LPK_CHARACTER_EVENTS[] { LPK_EventList.LPK_CHARACTER_EVENTS.LPK_EnemyCollision }; LPK_EventManager.InvokeEvent(sendEvent, data); if (m_bPrintDebug) { LPK_PrintDebug(this, "Enemy Collision Event Dispatched"); } } }
/** * FUNCTION NAME: StopVibration * DESCRIPTION : Stop vibration and send out appropriate event. Also manages cooldown since a Corutine delay results * in some unfortunate behavior. * INPUTS : None * OUTPUTS : None **/ void StopVibration() { //Stop vibration based on the controller number selected. for (int i = 0; i < m_pGamepads.Count; i++) { if ((int)m_pGamepads[i].m_iID != (int)m_eControllerNumber && m_eControllerNumber != LPK_ControllerNumber.ALL) { continue; } m_pGamepads[i].Rumble(0.0f, m_vecLeftRightMods); } m_flCurDuration += Time.deltaTime; //Cool down time is over. if (m_flCurDuration >= m_flCoolDown + m_flVibrateDuration) { if (m_bPrintDebug) { LPK_PrintDebug(this, "Stopping Controller Vibration"); } //Dispatch event. LPK_EventManager.LPK_EventData data = new LPK_EventManager.LPK_EventData(gameObject, m_VibrationStopReceivers); LPK_EventList sendEvent = new LPK_EventList(); sendEvent.m_InputEventTrigger = new LPK_EventList.LPK_INPUT_EVENTS[] { LPK_EventList.LPK_INPUT_EVENTS.LPK_VibrationStop }; LPK_EventManager.InvokeEvent(sendEvent, data); m_bActive = false; } }
/** * FUNCTION NAME: OnEvent * DESCRIPTION : Manages object movement towards the next node in the path. * INPUTS : None * OUTPUTS : None **/ void MoveAlongPath() { if (m_bReachedNode) { return; } if (m_Nodes.Length <= 0) { return; } transform.position = Vector3.MoveTowards(transform.position, m_Nodes[m_iCounter].transform.position, Time.deltaTime * m_flSpeed); if (transform.position == m_Nodes[m_iCounter].transform.position) { m_bReachedNode = true; //Dispatch event. LPK_EventManager.LPK_EventData data = new LPK_EventManager.LPK_EventData(gameObject, m_ReachNodeReceivers); LPK_EventList sendEvent = new LPK_EventList(); sendEvent.m_AIEventTrigger = new LPK_EventList.LPK_AI_EVENTS[] { LPK_EventList.LPK_AI_EVENTS.LPK_PathFollowerReachNode }; LPK_EventManager.InvokeEvent(sendEvent, data); if (m_bPrintDebug) { LPK_PrintDebug(this, "Reached Node"); } } }
/************************************************************************************/ /** * \fn OnStart * \brief Initializes Health Modification detection. * * **/ override protected void OnStart() { LPK_EventList healthList = new LPK_EventList(); healthList.m_CharacterEventTrigger = new LPK_EventList.LPK_CHARACTER_EVENTS[] { LPK_EventList.LPK_CHARACTER_EVENTS.LPK_HealthModified }; InitializeEvent(healthList, OnEvent); }
/** * FUNCTION NAME: DispatchDecreaseEvent * DESCRIPTION : Sends counter decreased event. * INPUTS : None * OUTPUTS : None **/ void DispatchDecreaseEvent() { LPK_EventManager.LPK_EventData data = new LPK_EventManager.LPK_EventData(gameObject, m_CounterDecreasedReceivers); LPK_EventList sendEvent = new LPK_EventList(); sendEvent.m_GameplayEventTrigger = new LPK_EventList.LPK_GAMEPLAY_EVENTS[] { LPK_EventList.LPK_GAMEPLAY_EVENTS.LPK_CounterDecrease }; LPK_EventManager.InvokeEvent(sendEvent, data); }
/** * \fn DispatchDestructionEvent * \brief Sends out the object destroyed event. * * **/ void DispatchDestructionEvent() { LPK_EventManager.LPK_EventData data = new LPK_EventManager.LPK_EventData(gameObject, ObjectDeletedReceivers); LPK_EventList sendEvent = new LPK_EventList(); sendEvent.m_GameplayEventTrigger = new LPK_EventList.LPK_GAMEPLAY_EVENTS[] { LPK_EventList.LPK_GAMEPLAY_EVENTS.LPK_GameObjectDestroy }; LPK_EventManager.InvokeEvent(sendEvent, data); }
/** * FUNCTION NAME: OnStart * DESCRIPTION : Initializes Death Event detection. * INPUTS : None * OUTPUTS : None **/ override protected void OnStart() { LPK_EventList deathList = new LPK_EventList(); deathList.m_CharacterEventTrigger = new LPK_EventList.LPK_CHARACTER_EVENTS[] { LPK_EventList.LPK_CHARACTER_EVENTS.LPK_Death }; InitializeEvent(deathList, OnEvent); m_iStatingLives = m_iLives; UpdateDisplay(); }
/** * FUNCTION NAME: DispatchEvent * DESCRIPTION : Dispatch audio levels adjusted event. * INPUTS : None * OUTPUTS : None **/ void DispatchEvent() { //Event dispatch. LPK_EventManager.LPK_EventData data = new LPK_EventManager.LPK_EventData(null, null); LPK_EventList sendEvent = new LPK_EventList(); sendEvent.m_OptionManagerEventTrigger = new LPK_EventList.LPK_OPTION_MANAGER_EVENTS[] { LPK_EventList.LPK_OPTION_MANAGER_EVENTS.LPK_AudioLevelsAdjusted }; LPK_EventManager.InvokeEvent(sendEvent, data); }
/** * FUNCTION NAME: UpdateDisplay * DESCRIPTION : Sends display update change event. * INPUTS : None * OUTPUTS : None **/ void UpdateDisplay() { LPK_EventManager.LPK_EventData data = new LPK_EventManager.LPK_EventData(gameObject, m_DisplayUpdateReceiver); data.m_flData.Add(m_iValue); data.m_flData.Add(m_iMaxValue); LPK_EventList sendEvent = new LPK_EventList(); sendEvent.m_GameplayEventTrigger = new LPK_EventList.LPK_GAMEPLAY_EVENTS[] { LPK_EventList.LPK_GAMEPLAY_EVENTS.LPK_DisplayUpdate }; LPK_EventManager.InvokeEvent(sendEvent, data); }
/** * FUNCTION NAME: OnStart * DESCRIPTION : Connects to event listening and initial display. * INPUTS : None * OUTPUTS : None **/ protected override void OnStart() { m_cText = GetComponent <Text>(); SetText(); LPK_EventList difficultyList = new LPK_EventList(); difficultyList.m_OptionManagerEventTrigger = new LPK_EventList.LPK_OPTION_MANAGER_EVENTS[] { LPK_EventList.LPK_OPTION_MANAGER_EVENTS.LPK_DifficultyLevelAdjusted }; InitializeEvent(difficultyList, OnDifficultyLevelChange, false); }
/** * FUNCTION NAME: Unpause * DESCRIPTION : Resumes the scene and the actions of any LPK component. * INPUTS : None * OUTPUTS : None **/ public static void Unpause() { Time.timeScale = 1.0f; LPK_EventManager.LPK_EventData data = new LPK_EventManager.LPK_EventData(null, null); LPK_EventList sendEvent = new LPK_EventList(); sendEvent.m_PauseEventTrigger = new LPK_EventList.LPK_PAUSE_EVENTS[] { LPK_EventList.LPK_PAUSE_EVENTS.LPK_GameUnpaused }; LPK_EventManager.InvokeEvent(sendEvent, data); }
/** * FUNCTION NAME: OnStart * DESCRIPTION : Connects to event listening and initial display. * INPUTS : None * OUTPUTS : None **/ override protected void OnStart() { m_cText = gameObject.GetComponent <Text>(); SetText(); LPK_EventList audioLevelsList = new LPK_EventList(); audioLevelsList.m_OptionManagerEventTrigger = new LPK_EventList.LPK_OPTION_MANAGER_EVENTS[] { LPK_EventList.LPK_OPTION_MANAGER_EVENTS.LPK_AudioLevelsAdjusted }; InitializeEvent(audioLevelsList, OnAudioLevelsChange, false); }
/** * FUNCTION NAME: UpdateDisplay * DESCRIPTION : Invokes the UpdateDisplay events for objects that may be subscribed. * INPUTS : None * OUTPUTS : None **/ void UpdateDisplay() { //Gather event data. LPK_EventManager.LPK_EventData data = new LPK_EventManager.LPK_EventData(gameObject, m_DisplayUpdateReceivers); data.m_flData.Add(m_iLives); data.m_flData.Add(m_iStatingLives); LPK_EventList sendEvent = new LPK_EventList(); sendEvent.m_GameplayEventTrigger = new LPK_EventList.LPK_GAMEPLAY_EVENTS[] { LPK_EventList.LPK_GAMEPLAY_EVENTS.LPK_DisplayUpdate }; LPK_EventManager.InvokeEvent(sendEvent, data); }
/** * FUNCTION NAME: OnStart * DESCRIPTION : Connects to event listening. * INPUTS : None * OUTPUTS : None **/ override protected void OnStart() { m_cAudioSource = GetComponent <AudioSource>(); //Set initial audio levels. SetAudioLevel(); LPK_EventList audioLevelsList = new LPK_EventList(); audioLevelsList.m_OptionManagerEventTrigger = new LPK_EventList.LPK_OPTION_MANAGER_EVENTS[] { LPK_EventList.LPK_OPTION_MANAGER_EVENTS.LPK_AudioLevelsAdjusted }; InitializeEvent(audioLevelsList, OnAudioLevelsChange, false); }
/** * FUNCTION NAME: DispatchGradientFinishedEvent * DESCRIPTION : Send out event when a gradient finishes an animation cycle. * INPUTS : None * OUTPUTS : None **/ void DispatchGradientFinishedEvent() { LPK_EventManager.LPK_EventData data = new LPK_EventManager.LPK_EventData(gameObject, m_GradientFinishedReceivers); LPK_EventList sendEvent = new LPK_EventList(); sendEvent.m_GameplayEventTrigger = new LPK_EventList.LPK_GAMEPLAY_EVENTS[] { LPK_EventList.LPK_GAMEPLAY_EVENTS.LPK_GradientAnimationFinished }; LPK_EventManager.InvokeEvent(sendEvent, data); if (m_bPrintDebug) { LPK_PrintDebug(this, "Event dispatched"); } }
/** * FUNCTION NAME: DispatchAnimationCycleEvent * DESCRIPTION : Sends event out for a cycle of the animation being finished. * INPUTS : None * OUTPUTS : None **/ void DispatchAnimationCycleEvent() { if (m_bPrintDebug) { LPK_PrintDebug(this, "Animation cycle event dispatched."); } LPK_EventManager.LPK_EventData newData = new LPK_EventManager.LPK_EventData(gameObject, m_AnimatorCycleFinishedReceivers); LPK_EventList sendEvent = new LPK_EventList(); sendEvent.m_GameplayEventTrigger = new LPK_EventList.LPK_GAMEPLAY_EVENTS[] { LPK_EventList.LPK_GAMEPLAY_EVENTS.LPK_AnimationCycleFinished }; LPK_EventManager.InvokeEvent(sendEvent, newData); }
/** * FUNCTION NAME: DispatchLostEvent * DESCRIPTION : Send out a lost event. * INPUTS : None * OUTPUTS : None **/ void DispatchLostEvent() { if (m_bPrintDebug) { LPK_PrintDebug(this, "Enemy lost"); } LPK_EventManager.LPK_EventData data = new LPK_EventManager.LPK_EventData(gameObject, m_LostEnemyReceivers); LPK_EventList sendEvent = new LPK_EventList(); sendEvent.m_AIEventTrigger = new LPK_EventList.LPK_AI_EVENTS[] { LPK_EventList.LPK_AI_EVENTS.LPK_PathFollowerLostEnemy }; LPK_EventManager.InvokeEvent(sendEvent, data); }
/** * \fn DispatchMaintainEvent * \brief Dispatches the maintained LOS event. * \param target - Object that was seen. Only used for debug logging here. * **/ void DispatchMaintainEvent(GameObject target) { LPK_EventManager.LPK_EventData data = new LPK_EventManager.LPK_EventData(gameObject, m_LineOfSightMaintainedReceivers); LPK_EventList sendEvent = new LPK_EventList(); sendEvent.m_AIEventTrigger = new LPK_EventList.LPK_AI_EVENTS[] { LPK_EventList.LPK_AI_EVENTS.LPK_LineOfSightMaintained }; LPK_EventManager.InvokeEvent(sendEvent, data); if (m_bPrintDebug) { LPK_PrintDebug(this, "Line of sight maintained between " + m_pSource.name + " and " + target); } }
/** * \fn DispatchLPKMouseInputEvent * \brief Dispatches the mouse event and prints debug info if set. * * **/ void DispatchLPKMouseInputEvent() { LPK_EventManager.LPK_EventData data = new LPK_EventManager.LPK_EventData(gameObject, m_InputReceiver); LPK_EventList sendEvent = new LPK_EventList(); sendEvent.m_InputEventTrigger = new LPK_EventList.LPK_INPUT_EVENTS[] { LPK_EventList.LPK_INPUT_EVENTS.LPK_MouseInput }; LPK_EventManager.InvokeEvent(sendEvent, data); if (m_bPrintDebug) { LPK_PrintDebug(this, "Mouse Input dispatched"); } }
/** * \fn TypeUIText * \brief Plays typing animation for UI text. * * **/ void TypeUIText() { m_flDelay = m_flSpeed; //Extra delay for a comma. if (m_aCharacters[m_iCounter] == "," || m_aCharacters[m_iCounter] == ";") { m_flDelay += m_flCommaPauseTime; } //Extra delay for end of sentence quotations. else if (m_aCharacters[m_iCounter] == "." || m_aCharacters[m_iCounter] == "?" || m_aCharacters[m_iCounter] == "!" || m_aCharacters[m_iCounter] == ":") { m_flDelay += m_flPunctuationPauseTime; } //Notifying the owner that a letter has been typed. Could be used for audio, for example. LPK_EventManager.LPK_EventData data = new LPK_EventManager.LPK_EventData(gameObject, m_TypingUpdateReceivers); LPK_EventList sendEvent = new LPK_EventList(); sendEvent.m_GameplayEventTrigger = new LPK_EventList.LPK_GAMEPLAY_EVENTS[] { LPK_EventList.LPK_GAMEPLAY_EVENTS.LPK_TypingTextUpdate }; LPK_EventManager.InvokeEvent(sendEvent, data); if (m_bPrintDebug) { LPK_PrintDebug(this, "Typing effect update."); } //Inputing the new text. m_cText.text = m_sPreviosulyTyped + m_aCharacters[m_iCounter]; m_sPreviosulyTyped = m_cText.text; m_iCounter++; //Marks the text as finished. if (m_cText.text == m_sText) { TypingFinished(); } //Typing the next letter. else { m_bActive = false; StartCoroutine(DelayType()); } }
/** * FUNCTION NAME: DispatchButtonEvent * DESCRIPTION : Send out event for virtual button input. * INPUTS : None * OUTPUTS : None **/ void DispatchButtonEvent() { LPK_EventManager.LPK_EventData data = new LPK_EventManager.LPK_EventData(gameObject, m_VirtualButtonReceivers); data.m_sPressedButton = m_sButton; LPK_EventList sendEvent = new LPK_EventList(); sendEvent.m_InputEventTrigger = new LPK_EventList.LPK_INPUT_EVENTS[] { LPK_EventList.LPK_INPUT_EVENTS.LPK_ButtonInput }; LPK_EventManager.InvokeEvent(sendEvent, data); if (m_bPrintDebug) { LPK_PrintDebug(this, "Button event dispatched"); } }
/** * \fn UICharacterScroll * \brief Plays typing animation for UI character scroll display. * * **/ void UICharacterScroll() { m_flDelay = m_flSpeed; //Extra delay for a comma. if (m_aCharacters[m_iCounter].ToCharArray()[0] >= ' ' && m_aCharacters[m_iCounter].ToCharArray()[0] <= '/') { m_sLastChar = m_aCharacters[m_iCounter].ToCharArray()[0]; } //Inputing the new text. m_cText.text = m_sPreviosulyTyped + m_sLastChar; if (m_cText.text.Length > 0 && m_cText.text[m_cText.text.Length - 1] == m_aCharacters[m_iCounter].ToCharArray()[0]) { //Notifying the owner that a letter has been typed. Could be used for audio, for example. LPK_EventManager.LPK_EventData data = new LPK_EventManager.LPK_EventData(gameObject, m_TypingUpdateReceivers); LPK_EventList sendEvent = new LPK_EventList(); sendEvent.m_GameplayEventTrigger = new LPK_EventList.LPK_GAMEPLAY_EVENTS[] { LPK_EventList.LPK_GAMEPLAY_EVENTS.LPK_TypingTextUpdate }; LPK_EventManager.InvokeEvent(sendEvent, data); if (m_bPrintDebug) { LPK_PrintDebug(this, "Typing effect update."); } m_iCounter++; m_sPreviosulyTyped = m_cText.text; m_sLastChar = '0'; } //Marks the text as finished. if (m_cText.text == m_sText) { TypingFinished(); } //Typing the next letter. else { m_bActive = false; m_sLastChar++; StartCoroutine(DelayType()); } }
/** * FUNCTION NAME: JumpInputHold * DESCRIPTION : Manages jump input if set to respond to HOLD. * INPUTS : None * OUTPUTS : None **/ void JumpInputHold() { //Resets data on initial button press. if (!string.IsNullOrEmpty(m_JumpButton) && Input.GetButtonDown(m_JumpButton)) { if (m_iAirJumpsUsed > m_iMaxAirJumps) { return; } if (!m_GroundedInfo.m_bGrounded) { m_iAirJumpsUsed++; } m_flAirTime = 0.0f; m_bIsJumping = true; //Dispatch event. LPK_EventManager.LPK_EventData data = new LPK_EventManager.LPK_EventData(gameObject, m_CharacterJumpEventReceivers); LPK_EventList sendEvent = new LPK_EventList(); sendEvent.m_CharacterEventTrigger = new LPK_EventList.LPK_CHARACTER_EVENTS[] { LPK_EventList.LPK_CHARACTER_EVENTS.LPK_CharacterJump }; LPK_EventManager.InvokeEvent(sendEvent, data); m_cRigidBody.velocity = new Vector3(m_cRigidBody.velocity.x, m_flJumpSpeed, 0); if (m_bPrintDebug) { LPK_PrintError(this, "Jumping via HOLD input."); } } //Manages actual velocity change. if (!string.IsNullOrEmpty(m_JumpButton) && Input.GetButton(m_JumpButton) && m_flAirTime <= m_flMaxAirTime) { if (m_iAirJumpsUsed > m_iMaxAirJumps) { return; } m_cRigidBody.velocity = new Vector3(m_cRigidBody.velocity.x, m_flJumpSpeed, 0); m_flAirTime += Time.deltaTime; } }
/** * \fn DestroyOwner * \brief Destroy this object's owner and send out the event. * * **/ void DestroyOwner() { LPK_EventManager.LPK_EventData data = new LPK_EventManager.LPK_EventData(gameObject, ObjectDeletedReceivers); LPK_EventList sendEvent = new LPK_EventList(); sendEvent.m_GameplayEventTrigger = new LPK_EventList.LPK_GAMEPLAY_EVENTS[] { LPK_EventList.LPK_GAMEPLAY_EVENTS.LPK_GameObjectDestroy }; LPK_EventManager.InvokeEvent(sendEvent, data); Object.Destroy(gameObject); if (m_bPrintDebug) { LPK_PrintDebug(this, "Object Destroyed"); } }