/// <summary>
/// The main interface for communicating between behaviours. Using polymorphism, we
/// define a bunch of different messages deriving from BehaviourMessage. Each behaviour
/// can then check for particular upcasted messahe types, and either grab some data
/// from it (set message) or store some data in it (get message).
/// </summary>
/// <param name="msg">The message being communicated to the behaviour.</param>
public override void OnMessage(ref BehaviourMessage msg)
{
// Which type of message was sent to us?
if (msg is SetDestinationMessage)
{
SetDestinationMessage tmp = (SetDestinationMessage)msg;
SetDestination(tmp.mDestination_In);
}
else if (msg is ClearDestinationMessage)
{
ClearDestination();
}
else if (msg is SetSourceMessage)
{
SetSourceMessage tmp = (SetSourceMessage)msg;
SetSource(tmp.mSource_In);
}
else if (msg is GetCurrentBestNodeMessage)
{
GetCurrentBestNodeMessage tmp = (GetCurrentBestNodeMessage)msg;
// If the low level search hasn't started yet, return the high level one, so that
// movement can start as soon as possible.
tmp.mBest_Out = mLowLevelBest; // mLowLevelBest != null ? mLowLevelBest : mPlannerNavMesh.pCurrentBest;
}
else if (msg is Level.OnNavMeshInvalidatedMessage)
{
mPlannerNavMesh.InvalidateCurrentPath();
mPlannerTileMap.InvalidateCurrentPath();
SetSource(mParentGOH.pPosition);
}
}
/// <summary>
/// The main interface for communicating between behaviours. Using polymorphism, we
/// define a bunch of different messages deriving from BehaviourMessage. Each behaviour
/// can then check for particular upcasted messahe types, and either grab some data
/// from it (set message) or store some data in it (get message).
/// </summary>
/// <param name="msg">The message being communicated to the behaviour.</param>
public override void OnMessage(ref BehaviourMessage msg)
{
if (msg is SetTargetObjectMessage)
{
SetTargetObjectMessage temp = (SetTargetObjectMessage)msg;
mTarget = temp.mTarget_In;
if (null != mTarget)
{
mSetDestinationMsg.mDestination_In = mTarget.pPosition + mParentGOH.pCollisionRoot;
mParentGOH.OnMessage(mSetDestinationMsg);
}
}
else if (msg is PathFind.OnPathFindFailedMessage)
{
PathFind.OnPathFindFailedMessage temp = (PathFind.OnPathFindFailedMessage)msg;
// Handle the case were the user places a tile right on top of the destination.
if (null != mTarget && temp.mReason == PathFind.OnPathFindFailedMessage.Reason.InvalidLocation)
{
mSetDestinationMsg.mDestination_In = mTarget.pPosition + mParentGOH.pCollisionRoot;
mParentGOH.OnMessage(mSetDestinationMsg);
}
}
}
/// <summary>
/// See parent.
/// </summary>
/// <param name="msg"></param>
public override void OnMessage(ref BehaviourMessage msg)
{
if (msg is TrialModeManager.OnTrialModeChangedMessage)
{
UpdateStatus();
}
}
/// <summary>
/// The main interface for communicating between behaviours. Using polymorphism, we
/// define a bunch of different messages deriving from BehaviourMessage. Each behaviour
/// can then check for particular upcasted messahe types, and either grab some data
/// from it (set message) or store some data in it (get message).
/// </summary>
/// <param name="msg">The message being communicated to the behaviour.</param>
public override void OnMessage(ref BehaviourMessage msg)
{
if (msg is Health.OnZeroHealthMessage)
{
mSetTileTypeAtPositionMsg.mType_In = Level.Tile.TileTypes.Empty;
mSetTileTypeAtPositionMsg.mPosition_In = mParentGOH.pPosition;
MBHEngine.World.WorldManager.pInstance.pCurrentLevel.OnMessage(mSetTileTypeAtPositionMsg, mParentGOH);
}
}
/// <summary>
/// The main interface for communicating between behaviours. Using polymorphism, we
/// define a bunch of different messages deriving from BehaviourMessage. Each behaviour
/// can then check for particular upcasted messahe types, and either grab some data
/// from it (set message) or store some data in it (get message).
/// </summary>
/// <param name="msg">The message being communicated to the behaviour.</param>
public override void OnMessage(ref BehaviourMessage msg)
{
if (msg is Health.OnZeroHealthMessage)
{
mSetTileTypeAtPositionMsg.mType_In = Level.Tile.TileTypes.Empty;
mSetTileTypeAtPositionMsg.mPosition_In = mParentGOH.pPosition;
MBHEngine.World.WorldManager.pInstance.pCurrentLevel.OnMessage(mSetTileTypeAtPositionMsg, mParentGOH);
}
}
/// <summary>
/// The main interface for communicating between behaviours. Using polymorphism, we
/// define a bunch of different messages deriving from BehaviourMessage. Each behaviour
/// can then check for particular upcasted messahe types, and either grab some data
/// from it (set message) or store some data in it (get message).
/// </summary>
/// <param name="msg">The message being communicated to the behaviour.</param>
public override void OnMessage(ref BehaviourMessage msg)
{
// Which type of message was sent to us?
if (msg is SimulatedPhysics.GetBodyMessage)
{
SimulatedPhysics.GetBodyMessage temp = (SimulatedPhysics.GetBodyMessage)msg;
temp.mBody_Out = mBody;
msg = temp;
}
}
/// <summary>
/// The main interface for communicating between behaviours. Using polymorphism, we
/// define a bunch of different messages deriving from BehaviourMessage. Each behaviour
/// can then check for particular upcasted messahe types, and either grab some data
/// from it (set message) or store some data in it (get message).
/// </summary>
/// <param name="msg">The message being communicated to the behaviour.</param>
public override void OnMessage(ref BehaviourMessage msg)
{
base.OnMessage(ref msg);
if (msg is Player.OnGameRestartMessage || msg is Player.OnMatchRestartMessage || msg is TrialModeManager.OnTrialModeChangedMessage)
{
mSetStateMsg.Reset();
mSetStateMsg.mNextState_In = "StateEmpty";
pParentGOH.OnMessage(mSetStateMsg);
}
}
/// <summary>
/// The main interface for communicating between behaviours. Using polymorphism, we
/// define a bunch of different messages deriving from BehaviourMessage. Each behaviour
/// can then check for particular upcasted messahe types, and either grab some data
/// from it (set message) or store some data in it (get message).
/// </summary>
/// <param name="msg">The message being communicated to the behaviour.</param>
public override void OnMessage(ref BehaviourMessage msg)
{
if (msg is SetStateMessage)
{
SetStateMessage temp = (SetStateMessage)msg;
AdvanceToState(temp.mNextState_In);
}
// Pass the message down to the currently running state.
mCurrentState.OnMessage(ref msg);
}
/// <summary>
/// The main interface for communicating between behaviours. Using polymorphism, we
/// define a bunch of different messages deriving from BehaviourMessage. Each behaviour
/// can then check for particular upcasted messahe types, and either grab some data
/// from it (set message) or store some data in it (get message).
/// </summary>
/// <param name="msg">The message being communicated to the behaviour.</param>
public override void OnMessage(ref BehaviourMessage msg)
{
if (msg is SetLookTargetMessage)
{
SetLookTargetMessage temp = (SetLookTargetMessage)msg;
mTarget = temp.mTarget_In;
}
else if (msg is Health.OnZeroHealthMessage)
{
mParentGOH.SetBehaviourEnabled <FaceForward>(false);
}
}
/// <summary>
/// The main interface for communicating between behaviours. Using polymorphism, we
/// define a bunch of different messages deriving from BehaviourMessage. Each behaviour
/// can then check for particular upcasted messahe types, and either grab some data
/// from it (set message) or store some data in it (get message).
/// </summary>
/// <param name="msg">The message being communicated to the behaviour.</param>
public override void OnMessage(ref BehaviourMessage msg)
{
// Which type of message was sent to us?
if (msg is ApplyDamageMessage)
{
ApplyDamageMessage temp = (ApplyDamageMessage)msg;
ApplyDamage(temp.mDamageAmount_In);
}
else if (msg is IncrementHealthMessage)
{
IncrementHealthMessage temp = (IncrementHealthMessage)msg;
mCurrentHealth = System.Math.Min(mMaxHealth, mCurrentHealth + temp.mIncrementAmount_In);
}
else if (msg is GetHealthMessage)
{
GetHealthMessage temp = (GetHealthMessage)msg;
temp.mCurrentHealth_Out = mCurrentHealth;
temp.mMaxHealth_Out = mMaxHealth;
}
else if (msg is SetMaxHealthMessage)
{
SetMaxHealthMessage temp = (SetMaxHealthMessage)msg;
Single percent = mCurrentHealth / mMaxHealth;
mMaxHealth = temp.mMaxHealth_In;
mCurrentHealth = percent * mMaxHealth;
}
else if (msg is IncrementMaxHealthMessage)
{
IncrementMaxHealthMessage temp = (IncrementMaxHealthMessage)msg;
Single percent = mCurrentHealth / mMaxHealth;
mMaxHealth += temp.mIncrementAmount_In;
mCurrentHealth = percent * mMaxHealth;
}
}
/// <summary>
/// The main interface for communicating between behaviours. Using polymorphism, we
/// define a bunch of different messages deriving from BehaviourMessage. Each behaviour
/// can then check for particular upcasted messahe types, and either grab some data
/// from it (set message) or store some data in it (get message).
/// </summary>
/// <param name="msg">The message being communicated to the behaviour.</param>
public override void OnMessage(ref BehaviourMessage msg)
{
if (msg is Health.OnZeroHealthMessage)
{
// By default just spawn the object where this object is.
GameObject.GameObject go = GameObjectFactory.pInstance.GetTemplate(mTemplateFileName);
Vector2 spawnPos = mParentGOH.pPosition;
// Optionally, there could be an attachment point specified.
if (null != mAttachmentPoint)
{
// Grab that attachment point and position the new object there.
mGetAttachmentPointMsg.mName_In = mAttachmentPoint;
mParentGOH.OnMessage(mGetAttachmentPointMsg);
spawnPos = mGetAttachmentPointMsg.mPoisitionInWorld_Out;
}
go.pPosition = spawnPos;
GameObjectManager.pInstance.Add(go);
}
}
/// <summary>
/// The main interface for communicating between behaviours. Using polymorphism, we
/// define a bunch of different messages deriving from BehaviourMessage. Each behaviour
/// can then check for particular upcasted messahe types, and either grab some data
/// from it (set message) or store some data in it (get message).
/// </summary>
/// <param name="msg">The message being communicated to the behaviour.</param>
public override void OnMessage(ref BehaviourMessage msg)
{
if (msg is Health.OnZeroHealthMessage)
{
// By default just spawn the object where this object is.
GameObject.GameObject go = GameObjectFactory.pInstance.GetTemplate(mTemplateFileName);
Vector2 spawnPos = mParentGOH.pPosition;
// Optionally, there could be an attachment point specified.
if (null != mAttachmentPoint)
{
// Grab that attachment point and position the new object there.
mGetAttachmentPointMsg.mName_In = mAttachmentPoint;
mParentGOH.OnMessage(mGetAttachmentPointMsg);
spawnPos = mGetAttachmentPointMsg.mPoisitionInWorld_Out;
}
go.pPosition = spawnPos;
GameObjectManager.pInstance.Add(go);
}
}
/// <summary>
/// The main interface for communicating between behaviours. Using polymorphism, we
/// define a bunch of different messages deriving from BehaviourMessage. Each behaviour
/// can then check for particular upcasted messahe types, and either grab some data
/// from it (set message) or store some data in it (get message).
/// </summary>
/// <param name="msg">The message being communicated to the behaviour.</param>
public override void OnMessage(ref BehaviourMessage msg)
{
if (msg is SetTargetObjectMessage)
{
SetTargetObjectMessage temp = (SetTargetObjectMessage)msg;
mTarget = temp.mTarget_In;
if (null != mTarget)
{
mSetDestinationMsg.mDestination_In = mTarget.pPosition + mParentGOH.pCollisionRoot;
mParentGOH.OnMessage(mSetDestinationMsg);
}
}
else if (msg is PathFind.OnPathFindFailedMessage)
{
PathFind.OnPathFindFailedMessage temp = (PathFind.OnPathFindFailedMessage)msg;
// Handle the case were the user places a tile right on top of the destination.
if (null != mTarget && temp.mReason == PathFind.OnPathFindFailedMessage.Reason.InvalidLocation)
{
mSetDestinationMsg.mDestination_In = mTarget.pPosition + mParentGOH.pCollisionRoot;
mParentGOH.OnMessage(mSetDestinationMsg);
}
}
}
/// <summary>
/// The main interface for communicating between behaviours. Using polymorphism, we
/// define a bunch of different messages deriving from BehaviourMessage. Each behaviour
/// can then check for particular upcasted messahe types, and either grab some data
/// from it (set message) or store some data in it (get message).
/// </summary>
/// <param name="msg">The message being communicated to the behaviour.</param>
public override void OnMessage(ref BehaviourMessage msg)
{
if (msg is Player.OnMatchRestartMessage || msg is Player.OnGameRestartMessage)
{
mHitCount = 0;
}
else if (msg is TutorialManager.HighlightPartnerMessage)
{
TutorialManager.HighlightPartnerMessage temp = (TutorialManager.HighlightPartnerMessage)msg;
if (temp.mEnable)
{
mParentGOH.pRenderPriority = 100;
}
else
{
mParentGOH.pRenderPriority = mStartingRenderPriority;
}
}
else if (msg is GetCurrentHitCountMessage)
{
GetCurrentHitCountMessage temp = (GetCurrentHitCountMessage)msg;
temp.mHitCount_Out = mHitCount;
}
}
/// <summary>
/// The main interface for communicating between behaviours. Using polymorphism, we
/// define a bunch of different messages deriving from BehaviourMessage. Each behaviour
/// can then check for particular upcasted messahe types, and either grab some data
/// from it (set message) or store some data in it (get message).
/// </summary>
/// <param name="msg">The message being communicated to the behaviour.</param>
public override void OnMessage(ref BehaviourMessage msg)
{
base.OnMessage(ref msg);
if (msg is Button.OnButtonPressedMessage)
{
mFxMenuSelect.Play();
if (msg.pSender == mLeaveCreditsButton)
{
mSetStateMsg.Reset();
mSetStateMsg.mNextState_In = "StateMainMenuRoot";
pParentGOH.OnMessage(mSetStateMsg, pParentGOH);
}
}
}
/// <summary>
/// See parent.
/// </summary>
/// <param name="msg"></param>
public override void OnMessage(ref BehaviourMessage msg)
{
base.OnMessage(ref msg);
if (msg is Button.OnButtonPressedMessage)
{
Button.OnButtonPressedMessage temp = (Button.OnButtonPressedMessage)msg;
if (temp.pSender == mContinueButton)
{
temp.mHandled_Out = true;
mSetStateMsg.Reset();
mSetStateMsg.mNextState_In = "StateTrialModeLimitGameplay";
pParentGOH.OnMessage(mSetStateMsg);
}
}
else if (msg is TrialModeManager.OnTrialModeChangedMessage)
{
System.Diagnostics.Debug.Assert(!TrialModeManager.pInstance.pIsTrialMode, "Not expecting to reach this point and still be in Trial Mode.");
mSetStateMsg.Reset();
mSetStateMsg.mNextState_In = "StateEmpty";
pParentGOH.OnMessage(mSetStateMsg);
}
}
/// <summary>
/// The main interface for communicating between behaviours. Using polymorphism, we
/// define a bunch of different messages deriving from BehaviourMessage. Each behaviour
/// can then check for particular upcasted messahe types, and either grab some data
/// from it (set message) or store some data in it (get message).
/// </summary>
/// <param name="msg">The message being communicated to the behaviour.</param>
public override void OnMessage(ref BehaviourMessage msg)
{
base.OnMessage(ref msg);
if (msg is Button.OnButtonPressedMessage)
{
if (msg.pSender == mResumeButton)
{
GameObjectManager.pInstance.pCurUpdatePass = MBHEngineContentDefs.BehaviourDefinition.Passes.GAME_PLAY;
GameObjectManager.pInstance.Remove(pParentGOH);
}
else if (msg.pSender == mQuitButton)
{
GameObjectManager.pInstance.pCurUpdatePass = MBHEngineContentDefs.BehaviourDefinition.Passes.QUIT;
GameObjectManager.pInstance.Remove(pParentGOH);
}
else if (msg.pSender == mMainMenuButton)
{
// Save the score when going back to the main menu. This will be filtered out
// of modes that could be exploited (eg. trick attack).
GameObjectManager.pInstance.BroadcastMessage(mForceUpdateSaveGameDataMsg, pParentGOH);
GameObjectManager.pInstance.pCurUpdatePass = MBHEngineContentDefs.BehaviourDefinition.Passes.MAIN_MENU;
TutorialManager.pInstance.StopTutorial();
GameObject mainMenu = GameObjectFactory.pInstance.GetTemplate("GameObjects\\UI\\MainMenu\\FSMMainMenu\\FSMMainMenu");
GameObjectManager.pInstance.Add(mainMenu);
GameObjectManager.pInstance.Remove(pParentGOH);
}
else if (msg.pSender == mAchievementsButton)
{
#if __ANDROID__
BumpSetSpike_Android.Activity1 activity = Game1.Activity as BumpSetSpike_Android.Activity1;
if (activity.pGooglePlayClient.IsConnected)
{
activity.StartActivityForResult(activity.pGooglePlayClient.AchievementsIntent, BumpSetSpike_Android.Activity1.REQUEST_ACHIEVEMENTS);
}
else
{
activity.pGooglePlayClient.Connect();
}
#endif // __ANDROID__
}
}
else if (msg is TrialModeManager.OnTrialModeChangedMessage)
{
if (mPurchaseButton != null)
{
GameObjectManager.pInstance.Remove(mPurchaseButton);
mPurchaseButton = null;
}
}
}
/// <summary>
/// The main interface for communicating between behaviours. Using polymorphism, we
/// define a bunch of different messages deriving from BehaviourMessage. Each behaviour
/// can then check for particular upcasted messahe types, and either grab some data
/// from it (set message) or store some data in it (get message).
/// </summary>
/// <param name="msg">The message being communicated to the behaviour.</param>
public virtual void OnMessage(ref BehaviourMessage msg)
{
}
/// <summary>
/// The main interface for communicating between behaviours. Using polymorphism, we
/// define a bunch of different messages deriving from BehaviourMessage. Each behaviour
/// can then check for particular upcasted messahe types, and either grab some data
/// from it (set message) or store some data in it (get message).
/// </summary>
/// <param name="msg">The message being communicated to the behaviour.</param>
public override void OnMessage(ref BehaviourMessage msg)
{
// Which type of message was sent to us?
if (msg is SpriteRender.GetSpriteEffectsMessage)
{
SpriteRender.GetSpriteEffectsMessage temp = (SpriteRender.GetSpriteEffectsMessage)msg;
temp.mSpriteEffects_Out = mSpriteEffects;
msg = temp;
}
else if (msg is SpriteRender.SetSpriteEffectsMessage)
{
SpriteRender.SetSpriteEffectsMessage temp = (SpriteRender.SetSpriteEffectsMessage)msg;
mSpriteEffects = temp.mSpriteEffects_In;
}
else if (msg is GetActiveAnimationMessage)
{
SpriteRender.GetActiveAnimationMessage temp = (SpriteRender.GetActiveAnimationMessage)msg;
temp.mAnimationSetName_Out = mAnimations[mActiveAnimation].mName;
msg = temp;
}
else if (msg is SetActiveAnimationMessage)
{
SpriteRender.SetActiveAnimationMessage temp = (SpriteRender.SetActiveAnimationMessage)msg;
// If the animation is not currently playing we need to find it.
if (mAnimations[mActiveAnimation].mName != temp.mAnimationSetName_In)
{
Boolean animationFound = false;
for (int i = 0; i < mAnimations.Count; i++)
{
if (mAnimations[i].mName == temp.mAnimationSetName_In)
{
mActiveAnimation = i;
mCurrentAnimationFrame = 0;
mAnimations[mActiveAnimation].mAnimationComplete = false;
animationFound = true;
break;
}
}
System.Diagnostics.Debug.Assert(animationFound, "Attempting to set unknown Animation: " + temp.mAnimationSetName_In);
}
// In the case where it is a non-looping animation which has completed, we need to reset the
// animation to the beginning.
// If it is a looping animation we don't do anything and assume that they just wanted to continue
// the animation.
else if (mAnimations[mActiveAnimation].mAnimationComplete && !temp.mDoNotRestartIfCompleted_In)
{
mCurrentAnimationFrame = 0;
mAnimations[mActiveAnimation].mAnimationComplete = false;
}
}
else if (msg is GetAttachmentPointMessage)
{
GetAttachmentPointMessage temp = (GetAttachmentPointMessage)msg;
FindAttachmentPointInWorldSpace(temp.mName_In, ref temp.mPoisitionInWorld_Out);
}
else if (msg is SetColorMessage)
{
SetColorMessage temp = (SetColorMessage)msg;
mColor = temp.mColor_In;
}
else if (msg is SetTintMessage)
{
SetTintMessage temp = (SetTintMessage)msg;
mTint = temp.mColor_In;
}
else if (msg is GetTexture2DMessage)
{
GetTexture2DMessage temp = (GetTexture2DMessage)msg;
temp.mTexture_Out = mTexture;
}
}
/// <summary>
/// See parent.
/// </summary>
/// <param name="msg"></param>
public override void OnMessage(ref BehaviourMessage msg)
{
base.OnMessage(ref msg);
if (msg is Button.OnButtonPressedMessage)
{
Button.OnButtonPressedMessage temp = msg as Button.OnButtonPressedMessage;
if (temp.pSender == mLeaderboardButton)
{
#if __ANDROID__
BumpSetSpike_Android.Activity1 activity = (Game1.Activity as BumpSetSpike_Android.Activity1);
if (!activity.pGooglePlayClient.IsConnected)
{
activity.pGooglePlayClient.Connect();
}
else
{
mGetCurrentHitCountMsg.Reset();
GameObjectManager.pInstance.BroadcastMessage(mGetCurrentHitCountMsg, mParentGOH);
// Show a different leaderboard based on the current
int board = (GameModeManager.pInstance.pMode == GameModeManager.GameMode.Endurance) ? Resource.String.leaderboard_endurance : Resource.String.leaderboard_trick_attack;
int hiScore = (GameModeManager.pInstance.pMode == GameModeManager.GameMode.Endurance) ? LeaderBoardManager.pInstance.pTopHits : LeaderBoardManager.pInstance.pTopScore;
// The high score will not have been saved yet, so we need to manually update it here.
string boardString = activity.Resources.GetString(board);
activity.pGooglePlayClient.SubmitScoreImmediate(activity, boardString, mGetCurrentHitCountMsg.mCount_Out);
activity.StartActivityForResult(activity.pGooglePlayClient.GetLeaderboardIntent(boardString), BumpSetSpike_Android.Activity1.REQUEST_LEADERBOARD);
}
#endif // __ANDROID__
temp.mHandled_Out = true;
}
}
}
/// <summary>
/// The main interface for communicating between behaviours. Using polymorphism, we
/// define a bunch of different messages deriving from BehaviourMessage. Each behaviour
/// can then check for particular upcasted messahe types, and either grab some data
/// from it (set message) or store some data in it (get message).
/// </summary>
/// <param name="msg">The message being communicated to the behaviour.</param>
public override void OnMessage(ref BehaviourMessage msg)
{
if (!mDisplayRecord && msg is IncrementHitCountMessage)
{
SetScore(mHitCount + 1);
}
else if (!mDisplayRecord && (msg is ClearHitCountMessage || msg is Player.OnGameRestartMessage))
{
if (GameObjectManager.pInstance.pCurUpdatePass != MBHEngineContentDefs.BehaviourDefinition.Passes.GAME_OVER_LOSS)
{
LeaderBoardManager.pInstance.SetCurrentModeTopScore(mHitCount);
}
ScoreManager.pInstance.OnMatchOver();
SetScore(0);
}
else if (!mDisplayRecord && msg is GetCurrentHitCountMessage)
{
GetCurrentHitCountMessage temp = (GetCurrentHitCountMessage)msg;
temp.mCount_Out = mHitCount;
}
else if (msg is SaveGameManager.ForceUpdateSaveDataMessage)
{
// We don't save trick attack because they might not have finished this move.
if (GameModeManager.pInstance.pMode == GameModeManager.GameMode.Endurance)
{
LeaderBoardManager.pInstance.pTopHits = mHitCount;
}
}
else if (!mDisplayRecord && msg is SetScoreMessage)
{
SetScoreMessage temp = (SetScoreMessage)msg;
SetScore(temp.mCount_In);
}
else if (msg is ResetGameMessage)
{
if (mHitCounterNums.Count > 0)
{
if (mDisplayRecord)
{
SetScore(LeaderBoardManager.pInstance.GetCurrentModeTopScore());
}
else
{
SetScore(0);
}
}
}
}
/// <summary>
/// The main interface for communicating between behaviours. Using polymorphism, we
/// define a bunch of different messages deriving from BehaviourMessage. Each behaviour
/// can then check for particular upcasted messahe types, and either grab some data
/// from it (set message) or store some data in it (get message).
/// </summary>
/// <param name="msg">The message being communicated to the behaviour.</param>
public override void OnMessage(ref BehaviourMessage msg)
{
base.OnMessage(ref msg);
if (msg is Button.OnButtonPressedMessage)
{
mFxMenuSelect.Play();
if (msg.pSender == mEnduranceModeButton)
{
GameModeManager.pInstance.pMode = GameModeManager.GameMode.Endurance;
}
else if (msg.pSender == mScoreAttackModeButton)
{
GameModeManager.pInstance.pMode = GameModeManager.GameMode.TrickAttack;
}
mSetStateMsg.Reset();
mSetStateMsg.mNextState_In = "StateMainMenuModeSelectDesc";
pParentGOH.OnMessage(mSetStateMsg, pParentGOH);
}
}
/// <summary>
/// The main interface for communicating between behaviours. Using polymorphism, we
/// define a bunch of different messages deriving from BehaviourMessage. Each behaviour
/// can then check for particular upcasted messahe types, and either grab some data
/// from it (set message) or store some data in it (get message).
/// </summary>
/// <param name="msg">The message being communicated to the behaviour.</param>
public override void OnMessage(ref BehaviourMessage msg)
{
if (msg is SetStateMessage)
{
SetStateMessage temp = (SetStateMessage)msg;
AdvanceToState(temp.mNextState_In);
}
// Pass the message down to the currently running state.
mCurrentState.OnMessage(ref msg);
}
/// <summary>
/// The main interface for communicating between behaviours. Using polymorphism, we
/// define a bunch of different messages deriving from BehaviourMessage. Each behaviour
/// can then check for particular upcasted messahe types, and either grab some data
/// from it (set message) or store some data in it (get message).
/// </summary>
/// <param name="msg">The message being communicated to the behaviour.</param>
public override void OnMessage(ref BehaviourMessage msg)
{
}
/// <summary>
/// The main interface for communicating between behaviours. Using polymorphism, we
/// define a bunch of different messages deriving from BehaviourMessage. Each behaviour
/// can then check for particular upcasted messahe types, and either grab some data
/// from it (set message) or store some data in it (get message).
/// </summary>
/// <param name="msg">The message being communicated to the behaviour.</param>
public override void OnMessage(ref BehaviourMessage msg)
{
if (msg is Player.OnMatchRestartMessage || msg is Player.OnGameRestartMessage)
{
mPlayOver = false;
mHasHitNet = false;
mParentGOH.pPosX = 110.0f;
mParentGOH.pPosY = -16.0f;
// -30 -> -90
Single speed = ((Single)RandomManager.pInstance.RandomPercent() * 2.0f) + 5.0f;
Vector2 dest = new Vector2((Single)RandomManager.pInstance.RandomPercent() * -60.0f - 30.0f, 16.0f);
if (!TutorialManager.pInstance.pTutorialCompleted)
{
dest.X = -90;
}
mSetServeDestinationMsg.mDestination_Out = dest;
GameObjectManager.pInstance.BroadcastMessage(mSetServeDestinationMsg, mParentGOH);
Vector2 vel = MBHEngine.Math.Util.GetArcVelocity(mParentGOH.pPosition, dest, speed, 0.2f);
mParentGOH.pDirection.mForward = vel;
mTimeOnGroundToEndPlay.Restart();
mTimeOnGroundToEndPlay.pIsPaused = true;
}
else if (msg is TutorialManager.HighlightBallMessage)
{
TutorialManager.HighlightBallMessage temp = (TutorialManager.HighlightBallMessage)msg;
if (temp.mEnable)
{
mParentGOH.pRenderPriority = 100;
}
else
{
mParentGOH.pRenderPriority = mStartingRenderPriority;
}
}
}
/// <summary>
/// The main interface for communicating between behaviours. Using polymorphism, we
/// define a bunch of different messages deriving from BehaviourMessage. Each behaviour
/// can then check for particular upcasted messahe types, and either grab some data
/// from it (set message) or store some data in it (get message).
/// </summary>
/// <param name="msg">The message being communicated to the behaviour.</param>
public override void OnMessage(ref BehaviourMessage msg)
{
base.OnMessage(ref msg);
}
/// <summary>
/// The main interface for communicating between behaviours. Using polymorphism, we
/// define a bunch of different messages deriving from BehaviourMessage. Each behaviour
/// can then check for particular upcasted messahe types, and either grab some data
/// from it (set message) or store some data in it (get message).
/// </summary>
/// <param name="msg">The message being communicated to the behaviour.</param>
public override void OnMessage(ref BehaviourMessage msg)
{
// Which type of message was sent to us?
if (msg is Level.GetCollisionInfoMessage)
{
Level.GetCollisionInfoMessage temp = (Level.GetCollisionInfoMessage)msg;
temp.mCollisionDetected_Out = CheckForCollision(temp.mOriginalRect_In,
temp.mDesiredRect_In,
out temp.mCollisionDetectedX_Out,
out temp.mCollisionDetectedY_Out,
out temp.mCollisionPointX_Out,
out temp.mCollisionPointY_Out);
msg = temp;
}
else if (msg is GetTileAtPositionMessage)
{
GetTileAtPositionMessage temp = (GetTileAtPositionMessage)msg;
temp.mTile_Out = GetTileAtPosition(temp.mPosition_In.X, temp.mPosition_In.Y);
msg = temp;
}
else if (msg is GetTileAtObjectMessage)
{
GetTileAtObjectMessage temp = (GetTileAtObjectMessage)msg;
temp.mTile_Out = GetTileAtObject(temp.mObject_In);
msg = temp;
}
else if (msg is SetTileTypeAtPositionMessage)
{
SetTileTypeAtPositionMessage temp = (SetTileTypeAtPositionMessage)msg;
Tile t = GetTileAtPosition(temp.mPosition_In.X, temp.mPosition_In.Y);
temp.mPreviousType_Out = t.mType;
if (t.mType != temp.mType_In)
{
t.mType = temp.mType_In;
DetermineAndSetImage(t);
UpdateEdgeCollisionData(t, true);
mNavMesh.RegenerateCluster(temp.mPosition_In);
GameObjectManager.pInstance.BroadcastMessage(mOnNavMeshInvalidatedMsg);
}
}
else if (msg is GetMapInfoMessage)
{
GetMapInfoMessage temp = (GetMapInfoMessage)msg;
temp.mInfo_Out = mMapInfo;
msg = temp;
}
else if (msg is GetNavMeshMessage)
{
GetNavMeshMessage temp = (GetNavMeshMessage)msg;
temp.mNavMesh_Out = mNavMesh;
}
}
/// <summary>
/// See parent.
/// </summary>
/// <param name="msg"></param>
public override void OnMessage(ref BehaviourMessage msg)
{
// Some things need to reset when the game is restarted.
if (msg is HitCountDisplay.ResetGameMessage)
{
Reset();
}
}
/// <summary>
/// The main interface for communicating between behaviours. Using polymorphism, we
/// define a bunch of different messages deriving from BehaviourMessage. Each behaviour
/// can then check for particular upcasted messahe types, and either grab some data
/// from it (set message) or store some data in it (get message).
/// </summary>
/// <param name="msg">The message being communicated to the behaviour.</param>
public override void OnMessage(ref BehaviourMessage msg)
{
if (msg is Ball.GetServeDestinationMessage)
{
Ball.GetServeDestinationMessage temp = (Ball.GetServeDestinationMessage)msg;
mWalkToDestination.X = temp.mDestination_Out.X - 4.0f;
// The player may have been in mid air when the round ended.
mWalkToDestination.Y = 0.0f;
// Ensure that we aren't asked to walk to a position which we can't reach. In those cases,
// just get as close as possible.
mWalkToDestination = Vector2.Clamp(mWalkToDestination, mTopLeft, mBottomRight);
mCurrentState = State.Receiving;
}
else if (msg is GetCurrentStateMessage)
{
GetCurrentStateMessage temp = (GetCurrentStateMessage)msg;
temp.mState_Out = mCurrentState;
}
else if (msg is TutorialManager.HighlightPlayerMessage)
{
TutorialManager.HighlightPlayerMessage temp = (TutorialManager.HighlightPlayerMessage)msg;
if (temp.mEnable)
{
mParentGOH.pRenderPriority = 100;
}
else
{
mParentGOH.pRenderPriority = mStartingRenderPriority;
}
}
else if (msg is Player.OnGameRestartMessage || msg is Player.OnMatchRestartMessage) // During tutorials if the player misses the ball we only do a match restart.
{
mHasMultipleHitsBeforePartner = false;
if (msg is Player.OnGameRestartMessage)
{
mTrialLimitReached = false;
}
// If the player is on the other side of the net, teleport them to the proper side.
if (mParentGOH.pPosX > 0.0f)
{
mParentGOH.pPosX = mTopLeft.X;
mParentGOH.pPosY = mBottomRight.Y;
// There were issues where after jumping over the net in the turorial, the player was
// still walking on the next match.
mParentGOH.pDirection.mForward = Vector2.Zero;
}
EndJumpZoom();
}
else if (msg is Ball.OnPlayOverMessage)
{
EndJumpZoom();
}
else if (msg is HitCountDisplay.TrialScoreLimitReachedMessage)
{
mTrialLimitReached = true;
}
else if (msg is TrialModeManager.OnTrialModeChangedMessage)
{
mTrialLimitReached = false;
}
else if (msg is GetHasMultipleHitsBeforePartnerMessage)
{
GetHasMultipleHitsBeforePartnerMessage temp = (GetHasMultipleHitsBeforePartnerMessage)msg;
temp.mHasMultipleHits_Out = mHasMultipleHitsBeforePartner;
}
}
/// <summary>
/// The main interface for communicating between behaviours. Using polymorphism, we
/// define a bunch of different messages deriving from BehaviourMessage. Each behaviour
/// can then check for particular upcasted messahe types, and either grab some data
/// from it (set message) or store some data in it (get message).
/// </summary>
/// <param name="msg">The message being communicated to the behaviour.</param>
public override void OnMessage(ref BehaviourMessage msg)
{
if (msg is Player.OnMatchRestartMessage)
{
mKabooomAvail = true;
mKaboomCount = 0;
}
else if (msg is Player.OnGameRestartMessage)
{
mKabooomAvail = true;
mCurrentState = State.Idle;
mParentGOH.pPosition = mStartPos;
mKaboomCount = 0;
}
else if (msg is Ball.OnPlayOverMessage)
{
// The ball has hit the ground. We don't want bouncing balls to KABOOOM the opponent.
mKabooomAvail = false;
}
}
/// <summary>
/// The main interface for communicating between behaviours. Using polymorphism, we
/// define a bunch of different messages deriving from BehaviourMessage. Each behaviour
/// can then check for particular upcasted messahe types, and either grab some data
/// from it (set message) or store some data in it (get message).
/// </summary>
/// <param name="msg">The message being communicated to the behaviour.</param>
public override void OnMessage(ref BehaviourMessage msg)
{
base.OnMessage(ref msg);
if (msg is Button.OnButtonPressedMessage)
{
mFxMenuSelect.Play();
if (msg.pSender == mTapStart)
{
// The did it! They actually played the game!!
AchievementManager.pInstance.UnlockAchievement(AchievementManager.Achievements.TheUbi);
mSetStateMsg.Reset();
mSetStateMsg.mNextState_In = "StateMainMenuModeSelect";
pParentGOH.OnMessage(mSetStateMsg, pParentGOH);
}
if (msg.pSender == mCreditsButton)
{
mSetStateMsg.Reset();
mSetStateMsg.mNextState_In = "StateMainMenuCredits";
pParentGOH.OnMessage(mSetStateMsg, pParentGOH);
}
}
}
/// <summary>
/// The main interface for communicating between behaviours. Using polymorphism, we
/// define a bunch of different messages deriving from BehaviourMessage. Each behaviour
/// can then check for particular upcasted messahe types, and either grab some data
/// from it (set message) or store some data in it (get message).
/// </summary>
/// <param name="msg">The message being communicated to the behaviour.</param>
public override void OnMessage(ref BehaviourMessage msg)
{
base.OnMessage(ref msg);
if (msg is Button.OnButtonPressedMessage)
{
if (msg.pSender == mGoButton)
{
mFxMenuSelect.Play();
mSetStateMsg.Reset();
mSetStateMsg.mNextState_In = "StateMainMenuCameraPan";
pParentGOH.OnMessage(mSetStateMsg, pParentGOH);
}
else if (msg.pSender == mEnduranceModeButton && GameModeManager.pInstance.pMode != GameModeManager.GameMode.Endurance)
{
mFxMenuSelect.Play();
GameModeManager.pInstance.pMode = GameModeManager.GameMode.Endurance;
// If they click a different game mode, just restart this state.
mSetStateMsg.Reset();
mSetStateMsg.mNextState_In = "StateMainMenuModeSelectDesc";
pParentGOH.OnMessage(mSetStateMsg, pParentGOH);
}
else if (msg.pSender == mScoreAttackModeButton && GameModeManager.pInstance.pMode != GameModeManager.GameMode.TrickAttack)
{
mFxMenuSelect.Play();
GameModeManager.pInstance.pMode = GameModeManager.GameMode.TrickAttack;
// If they click a different game mode, just restart this state.
mSetStateMsg.Reset();
mSetStateMsg.mNextState_In = "StateMainMenuModeSelectDesc";
pParentGOH.OnMessage(mSetStateMsg, pParentGOH);
}
}
}
/// <summary>
/// See parent.
/// </summary>
/// <param name="msg"></param>
public override void OnMessage(ref BehaviourMessage msg)
{
if (msg is Player.OnGameRestartMessage || msg is Player.OnMatchRestartMessage)
{
mHighScoreSoundPlayed = false;
}
}
/// <summary>
/// The main interface for communicating between behaviours. Using polymorphism, we
/// define a bunch of different messages deriving from BehaviourMessage. Each behaviour
/// can then check for particular upcasted messahe types, and either grab some data
/// from it (set message) or store some data in it (get message).
/// </summary>
/// <param name="msg">The message being communicated to the behaviour.</param>
public override void OnMessage(ref BehaviourMessage msg)
{
// Which type of message was sent to us?
if (msg is SpriteRender.GetSpriteEffectsMessage)
{
SpriteRender.GetSpriteEffectsMessage temp = (SpriteRender.GetSpriteEffectsMessage)msg;
temp.mSpriteEffects_Out = mSpriteEffects;
msg = temp;
}
else if (msg is SpriteRender.SetSpriteEffectsMessage)
{
SpriteRender.SetSpriteEffectsMessage temp = (SpriteRender.SetSpriteEffectsMessage)msg;
mSpriteEffects = temp.mSpriteEffects_In;
}
else if (msg is GetActiveAnimationMessage)
{
SpriteRender.GetActiveAnimationMessage temp = (SpriteRender.GetActiveAnimationMessage)msg;
temp.mAnimationSetName_Out = mAnimations[mActiveAnimation].mName;
msg = temp;
}
else if (msg is SetActiveAnimationMessage)
{
SpriteRender.SetActiveAnimationMessage temp = (SpriteRender.SetActiveAnimationMessage)msg;
// If the animation is not currently playing we need to find it.
if (mAnimations[mActiveAnimation].mName != temp.mAnimationSetName_In)
{
Boolean animationFound = false;
for (int i = 0; i < mAnimations.Count; i++)
{
if (mAnimations[i].mName == temp.mAnimationSetName_In)
{
mActiveAnimation = i;
mCurrentAnimationFrame = 0;
mAnimations[mActiveAnimation].mAnimationComplete = false;
animationFound = true;
break;
}
}
System.Diagnostics.Debug.Assert(animationFound, "Attempting to set unknown Animation: " + temp.mAnimationSetName_In);
}
// In the case where it is a non-looping animation which has completed, we need to reset the
// animation to the beginning.
// If it is a looping animation we don't do anything and assume that they just wanted to continue
// the animation.
else if (mAnimations[mActiveAnimation].mAnimationComplete)
{
mCurrentAnimationFrame = 0;
mAnimations[mActiveAnimation].mAnimationComplete = false;
}
}
else if (msg is GetAttachmentPointMessage)
{
GetAttachmentPointMessage temp = (GetAttachmentPointMessage)msg;
FindAttachmentPointInWorldSpace(temp.mName_In, ref temp.mPoisitionInWorld_Out);
}
else if (msg is SetColorMessage)
{
SetColorMessage temp = (SetColorMessage)msg;
mColor = temp.mColor_In;
}
else if (msg is SetTintMessage)
{
SetTintMessage temp = (SetTintMessage)msg;
mTint = temp.mColor_In;
}
else if (msg is GetTexture2DMessage)
{
GetTexture2DMessage temp = (GetTexture2DMessage)msg;
temp.mTexture_Out = mTexture;
}
}
/// <summary>
/// The main interface for communicating between behaviours. Using polymorphism, we
/// define a bunch of different messages deriving from BehaviourMessage. Each behaviour
/// can then check for particular upcasted messahe types, and either grab some data
/// from it (set message) or store some data in it (get message).
/// </summary>
/// <param name="msg">The message being communicated to the behaviour.</param>
public override void OnMessage(ref BehaviourMessage msg)
{
}
/// <summary>
/// The main interface for communicating between behaviours. Using polymorphism, we
/// define a bunch of different messages deriving from BehaviourMessage. Each behaviour
/// can then check for particular upcasted messahe types, and either grab some data
/// from it (set message) or store some data in it (get message).
/// </summary>
/// <param name="msg">The message being communicated to the behaviour.</param>
public override void OnMessage(ref BehaviourMessage msg)
{
// Which type of message was sent to us?
if (msg is SimulatedPhysics.GetBodyMessage)
{
SimulatedPhysics.GetBodyMessage temp = (SimulatedPhysics.GetBodyMessage)msg;
temp.mBody_Out = mBody;
msg = temp;
}
}
/// <summary>
/// The main interface for communicating between behaviours. Using polymorphism, we
/// define a bunch of different messages deriving from BehaviourMessage. Each behaviour
/// can then check for particular upcasted messahe types, and either grab some data
/// from it (set message) or store some data in it (get message).
/// </summary>
/// <param name="msg">The message being communicated to the behaviour.</param>
public override void OnMessage(ref BehaviourMessage msg)
{
// Which type of message was sent to us?
if (msg is SetDestinationMessage)
{
SetDestinationMessage tmp = (SetDestinationMessage)msg;
SetDestination(tmp.mDestination_In);
}
else if (msg is ClearDestinationMessage)
{
ClearDestination();
}
else if (msg is SetSourceMessage)
{
SetSourceMessage tmp = (SetSourceMessage)msg;
SetSource(tmp.mSource_In);
}
else if (msg is GetCurrentBestNodeMessage)
{
GetCurrentBestNodeMessage tmp = (GetCurrentBestNodeMessage)msg;
// If the low level search hasn't started yet, return the high level one, so that
// movement can start as soon as possible.
tmp.mBest_Out = mLowLevelBest; // mLowLevelBest != null ? mLowLevelBest : mPlannerNavMesh.pCurrentBest;
}
else if (msg is Level.OnNavMeshInvalidatedMessage)
{
mPlannerNavMesh.InvalidateCurrentPath();
mPlannerTileMap.InvalidateCurrentPath();
SetSource(mParentGOH.pPosition);
}
}
/// <summary>
/// The main interface for communicating between behaviours. Using polymorphism, we
/// define a bunch of different messages deriving from BehaviourMessage. Each behaviour
/// can then check for particular upcasted messahe types, and either grab some data
/// from it (set message) or store some data in it (get message).
/// </summary>
/// <param name="msg">The message being communicated to the behaviour.</param>
public virtual void OnMessage(ref BehaviourMessage msg) { }
/// <summary>
/// The main interface for communicating between behaviours. Using polymorphism, we
/// define a bunch of different messages deriving from BehaviourMessage. Each behaviour
/// can then check for particular upcasted messahe types, and either grab some data
/// from it (set message) or store some data in it (get message).
/// </summary>
/// <param name="msg">The message being communicated to the behaviour.</param>
public override void OnMessage(ref BehaviourMessage msg)
{
if (msg is SetTargetMessage)
{
SetTargetMessage temp = (SetTargetMessage)msg;
mTarget = temp.mTarget_In;
}
}
/// <summary>
/// The main interface for communicating between behaviours. Using polymorphism, we
/// define a bunch of different messages deriving from BehaviourMessage. Each behaviour
/// can then check for particular upcasted messahe types, and either grab some data
/// from it (set message) or store some data in it (get message).
/// </summary>
/// <param name="msg">The message being communicated to the behaviour.</param>
public override void OnMessage(ref BehaviourMessage msg)
{
if (msg is SetLookTargetMessage)
{
SetLookTargetMessage temp = (SetLookTargetMessage)msg;
mTarget = temp.mTarget_In;
}
else if (msg is Health.OnZeroHealthMessage)
{
mParentGOH.SetBehaviourEnabled<FaceForward>(false);
}
}
/// <summary>
/// The main interface for communicating between behaviours. Using polymorphism, we
/// define a bunch of different messages deriving from BehaviourMessage. Each behaviour
/// can then check for particular upcasted messahe types, and either grab some data
/// from it (set message) or store some data in it (get message).
/// </summary>
/// <param name="msg">The message being communicated to the behaviour.</param>
public override void OnMessage(ref BehaviourMessage msg)
{
if (msg is SetScoreMessage)
{
SetScoreMessage temp = (SetScoreMessage)msg;
SetScore(temp.mScore_In);
}
}
