public void Eat(M8.EntityBase victim, int score)
{
Vector2 pos = transform.position;
Vector2 dest = victim.transform.position;
Vector2 dir = dest - pos;
float dist = dir.magnitude;
if (dist > 0f)
{
dir /= dist;
}
var spawnPos = pos + dir * spawnArmRadius;
var arm = M8.PoolController.SpawnFromGroup <EntityPhagocyteTentacle>(spawnArmPoolGroup, spawnArmEntityRef, spawnArmEntityRef, null, spawnPos, null);
arm.setStateCallback += OnArmChangeState;
arm.releaseCallback += OnArmRelease;
arm.Gather(victim, dir, dist, score);
mArms.Add(arm);
if (animator && animator.currentPlayingTakeName == takeNormal)
{
animator.Play(takeSeek);
}
}
IEnumerator DoBegin()
{
if (beginActivateGO)
{
beginActivateGO.SetActive(true);
}
//small intro to show stuff
if (!string.IsNullOrEmpty(takeBeginIntro))
{
animator.Play(takeBeginIntro);
while (animator.isPlaying)
{
yield return(null);
}
}
//time to leave
yield return(DoLeaveProcess(takeBeginOutro));
if (beginActivateGO)
{
beginActivateGO.SetActive(false);
}
mRout = null;
EnterStage(0);
}
IEnumerator DoVictory()
{
inputLock = true;
SendSignal(SignalType.Complete, 0);
if (!string.IsNullOrEmpty(takeVictory))
{
mainAnimator.Play(takeVictory);
while (mainAnimator.isPlaying)
{
yield return(null);
}
}
//wait for eating process
while (isProcessingVictims)
{
yield return(null);
}
mRout = null;
ProcessVictory();
}
// Use this for initialization
IEnumerator Start()
{
//setup initial display
animator.ResetTake(animator.GetTakeIndex(takeStart));
animator.ResetTake(animator.GetTakeIndex(takeInteractEnter));
while (M8.SceneManager.instance.isLoading)
{
yield return(null);
}
animator.Play(takeStart);
while (animator.isPlaying)
{
yield return(null);
}
//music
if (startMusicPlaylist)
{
LoLMusicPlaylist.instance.Play();
}
//start up the first page
mCurPageInd = 0;
ShowCurrentPage();
}
void OnGameModeChange(GameMapController.Mode mode)
{
switch (mode)
{
case GameMapController.Mode.Play:
toggleButton.raycastTarget = false;
//play edit mode exit
animator.Play(mTakeEditHideId);
LoLManager.instance.PlaySound(toggleSoundClosePath, false, false);
break;
case GameMapController.Mode.Edit:
toggleButton.raycastTarget = false;
//show active items
for (int i = 0; i < mActiveWidgets.Count; i++)
{
mActiveWidgets[i].gameObject.SetActive(true);
mActiveWidgets[i].UpdateCount();
}
//play edit mode enter
animator.Play(mTakeEditShowId);
LoLManager.instance.PlaySound(toggleSoundOpenPath, false, false);
break;
}
}
void IEntitySpawnerListener.OnSpawnStart()
{
if (mTakeIdleInd == -1)
{
return;
}
animator.Play(mTakeIdleInd);
}
IEnumerator M8.SceneManager.ITransition.Out()
{
activeGO.SetActive(true);
animator.Play(mTakeOutInd);
while (animator.isPlaying)
{
yield return(null);
}
}
public void ClickNope()
{
if (animator.isPlaying || mResultProceedActive)
{
return;
}
nopeButton.interactable = false;
animator.Play(takeResultProceedShow);
}
IEnumerator IOpening.Opening()
{
if (animator && !string.IsNullOrEmpty(takeOpen))
{
animator.Play(takeOpen);
while (animator.isPlaying)
{
yield return(null);
}
}
}
public void Quit()
{
if (animator.isPlaying || mResultProceedActive)
{
return;
}
giveUpButton.interactable = false;
resultProceedButtonGO.SetActive(true);
animator.Play(takeResultProceedShow);
}
protected override void StateChanged()
{
switch ((EntityState)prevState)
{
case EntityState.Normal:
if (mNormalRout != null)
{
StopCoroutine(mNormalRout);
mNormalRout = null;
}
mIsWeak = false;
break;
}
switch ((EntityState)state)
{
case EntityState.Normal:
bodySpriteRender.color = bodyColorNormal;
ApplyNormalState();
break;
case EntityState.Bind:
bodySpriteRender.color = bodyColorNormal;
animator.Play(takeDanger);
bodyAnimator.Play(takeBodyDanger);
break;
case EntityState.Dead:
Debug.Log("dead: " + name);
bodySpriteRender.color = bodyColorDead;
//animate
animator.Play(takeDead);
bodyAnimator.Play(takeBodyDead);
if (body)
{
body.simulated = false;
}
if (coll)
{
coll.enabled = false;
}
break;
}
}
void OnAnimatorComplete(M8.Animator.AnimatorData anim, M8.Animator.AMTakeData take)
{
if (take.name == takeEat)
{
if (mArms.Count > 0)
{
anim.Play(takeSeek);
}
else
{
anim.Play(takeNormal);
}
}
}
IEnumerator DoLaunch()
{
yield return(new WaitForSeconds(launchDelay));
mIsLaunched = true;
//play animator
if (animator)
{
animator.Play(takeLaunch);
while (animator.isPlaying)
{
yield return(null);
}
}
//start post launch, no longer need to track it
for (int i = 0; i < mSpawnedPathogens.Count; i++)
{
if (mSpawnedPathogens[i] && mSpawnedPathogens[i].stats.isAlive)
{
mSpawnedPathogens[i].state = (int)launchPostState;
mSpawnedPathogens[i].releaseCallback -= OnSpawnedEntityRelease; //no longer need to listen
}
}
mSpawnedPathogens.Clear();
mRout = null;
}
IEnumerator DoSpawn()
{
do
{
yield return(null);
} while(M8.SceneManager.instance.isLoading);
if (spawnStartCallback != null)
{
spawnStartCallback();
}
LoLManager.instance.PlaySound(soundSpawnPath, false, false);
//animations and stuff
if (spawnAnim)
{
spawnAnim.gameObject.SetActive(true);
spawnAnim.Play(spawnAnimTake);
while (spawnAnim.isPlaying)
{
yield return(null);
}
spawnAnim.gameObject.SetActive(false);
}
state = (int)EntityState.Normal;
}
IEnumerator DoStageTransition()
{
//show incoming
//apply progress animation to HUD
if (transitionAnimator && !string.IsNullOrEmpty(takeStageTransitionBegin))
{
transitionAnimator.Play(takeStageTransitionBegin);
}
yield return(new WaitForSeconds(transitionBeginDelay));
mRout = null;
ApplyState(State.StagePlay);
}
public void Place(Vector2 pos)
{
mPlacedPos = pos;
transform.position = pos;
animator.Play(takeEnter);
}
public void ClickResults()
{
if (M8.UIModal.Manager.instance.isBusy || animator.isPlaying)
{
return;
}
if (mIsResultShow)
{
animator.Play(takeResultHide);
}
else
{
animator.Play(takeResultShow);
}
mIsResultShow = !mIsResultShow;
}
protected override void StateChanged()
{
if (mRout != null)
{
StopCoroutine(mRout);
mRout = null;
}
switch ((EntityState)prevState)
{
case EntityState.Seek:
mFollow = null;
break;
case EntityState.Launch:
mTarget = null;
break;
}
switch ((EntityState)state)
{
case EntityState.Normal:
animator.Play(takeNormal);
break;
case EntityState.Seek:
animator.Play(takeNormal);
mRout = StartCoroutine(DoFollow());
break;
case EntityState.Launch:
animator.Play(takeLaunch);
mRout = StartCoroutine(DoLaunch());
break;
case EntityState.Leave:
animator.Play(takeLeave);
break;
case EntityState.Dead:
animator.Play(takeExplode);
break;
}
}
public Neutrophil Spawn(string poolRef, string entityRef)
{
if (mEntity) //shouldn't get here
{
return(null);
}
if (animator)
{
mEntity = M8.PoolController.GetPool(poolRef).Spawn <Neutrophil>(entityRef, entityRef, null, point.position, null);
mEntity.Follow(point);
mIsSpawning = true;
animator.Play(takeSpawn);
}
return(mEntity);
}
protected override void StateChanged()
{
if (mRout != null)
{
StopCoroutine(mRout);
mRout = null;
}
switch ((EntityState)prevState)
{
case EntityState.Active:
mIsClicked = false;
break;
}
switch ((EntityState)state)
{
case EntityState.Normal:
animator.Play(takeNormal);
inputGO.SetActive(false);
break;
case EntityState.Alert:
mRout = StartCoroutine(DoPlayAnim(takeAlert, alertDelay, EntityState.Sleep));
inputGO.SetActive(false);
break;
case EntityState.Active:
animator.Play(takeActive);
inputGO.SetActive(true);
break;
case EntityState.Sleep:
mRout = StartCoroutine(DoPlayAnim(takeSleep, sleepDelay, EntityState.Normal));
inputGO.SetActive(false);
break;
}
}
private IEnumerator Start()
{
if (!animator)
{
animator = GetComponent <M8.Animator.AnimatorData>();
}
while (M8.SceneManager.instance.isLoading)
{
yield return(null);
}
animator.Play(take);
}
public void Activate()
{
if (mIsActive)
{
return;
}
mIsActive = true;
gameObject.SetActive(true);
sphereCollider.enabled = true;
if (gatherDisplayRoot)
{
gatherDisplayRoot.SetActive(true);
}
//play active
if (animator && mTakeActivateInd != -1)
{
animator.Play(mTakeActivateInd);
}
}
// Use this for initialization
IEnumerator Start()
{
//wait for scene to load
while (M8.SceneManager.instance.isLoading)
{
yield return(null);
}
//determine which stars to activate
if (GameData.isInstantiated)
{
float score = GameData.instance.currentScore;
float maxScore = GameData.instance.scorePerLevel * 8.0f; //TODO: need actual level count
int index = maxScore > 0f ? Mathf.RoundToInt((stars.Length - 1) * Mathf.Clamp01(score / maxScore)) : 0;
if (index >= stars.Length)
{
index = stars.Length - 1;
}
stars[index].SetActive(true);
}
else
{
stars[Random.Range(0, stars.Length)].SetActive(true);
}
//play
animator.Play(takePlay);
do
{
yield return(null);
} while(animator.isPlaying);
//auto end
if (autoEndDelay > 0f)
{
yield return(new WaitForSeconds(autoEndDelay));
completeButton.interactable = false;
GameFlowController.Complete();
}
}
private void UpdateAnim()
{
switch (mMoveState)
{
case EntityHero.MoveState.Left:
sprite.flipX = true;
break;
case EntityHero.MoveState.Right:
sprite.flipX = false;
break;
}
if (mIsGrounded)
{
switch (mMoveState)
{
case EntityHero.MoveState.Stop:
anim.Play(mTakeIdleInd);
break;
case EntityHero.MoveState.Left:
case EntityHero.MoveState.Right:
anim.Play(mTakeMoveInd);
break;
}
}
else
{
if (mVelY > velYThreshold)
{
anim.Play(mTakeUpInd);
}
else if (mVelY < -velYThreshold)
{
anim.Play(mTakeDownInd);
}
else if (anim.currentPlayingTakeIndex != mTakeUpInd || anim.currentPlayingTakeIndex != mTakeDownInd)
{
if (mVelY > 0f)
{
anim.Play(mTakeUpInd);
}
else
{
anim.Play(mTakeDownInd);
}
}
}
}
IEnumerator DoSpawn()
{
var spawnInfo = mSpawnInfoGen.next;
animator.Play(takeEnter);
//wait one frame for spawnAt to be setup
yield return(null);
//spawn at the position
var spawnParms = new M8.GenericParams();
spawnParms[Params.state] = (int)EntityState.Control;
spawnParms[Params.anchor] = spawnAt;
mSpawnedEntity = M8.PoolController.SpawnFromGroup <EntityCommon>(mSpawnInfoGen.poolGroup, spawnInfo.entityRef, spawnInfo.entityRef, null, spawnAt.position, spawnParms);
if (mSpawnedEntity.cellBind)
{
mSpawnedEntity.cellBind.Populate(spawnInfo.bindData);
}
mSpawnedEntity.releaseCallback += OnEntityRelease; //fail-safe
mSpawnEntitySelectible = mSpawnedEntity.GetComponentInChildren <GameObjectSelectible>();
//wait for play to finish
while (animator.isPlaying)
{
yield return(null);
}
SetLaunchReady(false);
//listen for select, drag
mSpawnEntitySelectible.selectCallback += OnEntitySelect;
mSpawnEntitySelectible.dragBeginCallback += OnEntityDragBegin;
mSpawnEntitySelectible.dragCallback += OnEntityDrag;
mSpawnEntitySelectible.dragEndCallback += OnEntityDragEnd;
mRout = null;
}
IEnumerator DoDead()
{
LoLManager.instance.PlaySound(soundDeathPath, false, false);
//animations and stuff
if (deathAnim)
{
deathAnim.gameObject.SetActive(true);
deathAnim.Play(deathAnimTake);
while (deathAnim.isPlaying)
{
yield return(null);
}
deathAnim.gameObject.SetActive(false);
}
//return to start position
transform.position = mStartPos;
state = (int)EntityState.Spawn;
}
protected override void StateChanged()
{
if (mRout != null)
{
StopCoroutine(mRout);
mRout = null;
}
switch ((EntityState)prevState)
{
case EntityState.Bind:
SetBound(null);
break;
}
switch ((EntityState)state)
{
case EntityState.Normal:
body.simulated = false;
if (mGrowRout == null)
{
animator.Play(stats.takeNormal);
}
break;
case EntityState.Select:
body.simulated = false;
if (mGrowRout == null)
{
animator.Play(stats.takeSelect);
}
break;
case EntityState.Launch:
body.simulated = true;
body.isKinematic = false;
mRout = StartCoroutine(DoLaunch());
break;
case EntityState.Dead:
body.simulated = false;
if (mGrowRout != null)
{
StopCoroutine(mGrowRout);
mGrowRout = null;
ApplyGrowthToScale();
}
animator.Play(stats.takeDeath);
break;
case EntityState.Bind:
body.simulated = false;
mRout = StartCoroutine(DoBound());
break;
}
}
IEnumerator Start()
{
//intro
input.isLocked = true;
animator.Play(takeStart);
while (animator.isPlaying)
{
yield return(null);
}
var parmDlg = new M8.GenericParams();
//start dialog
for (int i = 0; i < dialogsBegin.Length; i++)
{
dialogsBegin[i].Show(parmDlg);
while (dialogsBegin[i].isShowing)
{
yield return(null);
}
}
parmDlg.Clear();
//
//prepare animation
animator.Play(takePrepare);
while (animator.isPlaying)
{
yield return(null);
}
//init play
GenerateQuestions();
mCurScore = 0;
HUD.instance.SetMissionActive(true);
HUD.instance.SetTimeActive(false);
HUD.instance.UpdateScore(mCurScore, mCurScore);
//play
while (mCurQuestionIndex < mQuestions.Length)
{
mIncorrectCounter = 0;
var question = curQuestion;
//deck entry
animator.Play(takeDeckEnter);
while (animator.isPlaying)
{
yield return(null);
}
//populate deck
PopulateDeck();
//dock
SetupDock();
//question dialog
parmDlg[ModalDialog.parmStringRefs] = new string[] { curQuestion.questionStringRef };
parmDlg[ModalDialog.parmPauseOverride] = false;
M8.UIModal.Manager.instance.ModalOpen(modalQuestion, parmDlg);
parmDlg.Clear();
//
input.isLocked = false;
//wait for anchors to be filled
while (mAvailableAnchors.Count > 0)
{
yield return(null);
if (mIsAnswerPicked)
{
input.isLocked = true;
yield return(null);
yield return(null);
mIsAnswerPicked = false;
input.isLocked = false;
}
}
input.isLocked = true;
M8.UIModal.Manager.instance.ModalCloseUpTo(modalQuestion, true);
//deck exit
ClearDeck();
animator.Play(takeDeckExit);
while (animator.isPlaying)
{
yield return(null);
}
bool isResultEnterPlayed = false;
//results dialog
if (!string.IsNullOrEmpty(curQuestion.resultStringRef))
{
//move to an appropriate position
animator.Play(takeQuestionResultEnter);
isResultEnterPlayed = true;
parmDlg[ModalDialog.parmStringRefs] = new string[] { curQuestion.resultStringRef };
parmDlg[ModalDialog.parmPauseOverride] = false;
M8.UIModal.Manager.instance.ModalOpen(modalPostQuestion, parmDlg);
while (M8.UIModal.Manager.instance.isBusy || M8.UIModal.Manager.instance.ModalIsInStack(modalPostQuestion))
{
yield return(null);
}
parmDlg.Clear();
}
else
{
yield return(new WaitForSeconds(1f));
}
//
ClearDock();
//next
mCurQuestionIndex++;
//show multi question dialog explanation
if (mCurQuestionIndex == mQuestionMultiStartIndex)
{
dialogMultiQuestionBegin.Show(parmDlg);
while (dialogMultiQuestionBegin.isShowing)
{
yield return(null);
}
parmDlg.Clear();
}
//move back
if (isResultEnterPlayed)
{
//in case dialog was ended quickly
while (animator.isPlaying)
{
yield return(null);
}
animator.Play(takeQuestionResultExit);
while (animator.isPlaying)
{
yield return(null);
}
}
yield return(null);
}
ClearDock();
//end
input.isLocked = true;
StartCoroutine(DoVictoryMusic());
animator.Play(takeEndPrepare);
while (animator.isPlaying)
{
yield return(null);
}
//end dialog
for (int i = 0; i < dialogsEnd.Length; i++)
{
dialogsEnd[i].Show(parmDlg);
while (dialogsEnd[i].isShowing)
{
yield return(null);
}
}
parmDlg.Clear();
//
animator.Play(takeEnd);
if (takeEndWait)
{
while (animator.isPlaying)
{
if (Input.anyKeyDown)
{
animator.GotoFrame(takeEndSkipFrame);
break;
}
yield return(null);
}
}
parmDlg[ModalStartFinish.parmMaxScore] = mMaxScore;
M8.UIModal.Manager.instance.ModalOpen(modalProceed, parmDlg);
}
public void StartPump()
{
isPumping = true;
animator.Play(takePumping);
}
IEnumerator DoGather()
{
if (mDist > 0f && mTarget)
{
Vector2 sPos = transform.position;
Vector2 ePos = mTarget.transform.position;
float delay = mDist / speed;
//go towards
var ease = DG.Tweening.Core.Easing.EaseManager.ToEaseFunction(DG.Tweening.Ease.OutCirc);
float curTime = 0f;
while (curTime < delay)
{
yield return(null);
curTime += Time.deltaTime;
float t = Mathf.Clamp01(ease(curTime, delay, 0f, 0f));
if (!float.IsNaN(t))
{
pointer.position = Vector2.Lerp(sPos, ePos, t);
}
}
//eat
pointer.up = mTargetDir;
animator.Play(takeEat);
while (animator.isPlaying)
{
yield return(null);
}
mTarget.Release();
mTarget = null;
//pull back
headSpriteRender.sortingLayerName = headPullBackSort;
headSpriteRender.sortingOrder = headPullBackSortOrder;
ease = DG.Tweening.Core.Easing.EaseManager.ToEaseFunction(DG.Tweening.Ease.InCirc);
curTime = 0f;
while (curTime < delay)
{
yield return(null);
curTime += Time.deltaTime;
float t = Mathf.Clamp01(ease(curTime, delay, 0f, 0f));
if (!float.IsNaN(t))
{
pointer.position = Vector2.Lerp(ePos, sPos, t);
}
}
}
mRout = null;
state = (int)EntityState.Gathered;
}
