void OnDisable()
{
if (mRout != null)
{
StopCoroutine(mRout);
mRout = null;
}
if (mLaunchRout != null)
{
StopCoroutine(mLaunchRout);
mLaunchRout = null;
}
mSpawnCount = 0;
for (int i = 0; i < spawnPts.Length; i++)
{
if (spawnPts[i].entity)
{
SpawnHookUpCallback(spawnPts[i].entity, false);
}
spawnPts[i].Reset(true);
}
mTargetPotentialEntities.Clear();
if (detectTrigger)
{
detectTrigger.gameObject.SetActive(false);
}
}
public virtual void ResetCollision()
{
mCollFlags = CollisionFlags.None;
mCollLayerMask = 0;
mIsSlopSlide = false;
mColls.Clear();
mCurMoveAxis = Vector2.zero;
mCurMoveDir = Vector2.zero;
mIsLocalVelocityComputed = false;
}
public virtual void ResetCollision()
{
if (mColls == null)
{
return; //not initialized yet
}
mCollFlags = CollisionFlags.None;
mCollLayerMask = 0;
mIsSlopSlide = false;
mColls.Clear();
mCurMoveAxis = Vector2.zero;
mCurMoveDir = Vector2.zero;
mIsLocalVelocityComputed = false;
}
IEnumerator DoOpenCurrent()
{
if (mModalStack.Count > 0)
{
mModalCache.Clear();
foreach (var ctrl in mModalStack)
{
mModalCache.Add(ctrl);
if (ctrl.isExclusive)
{
break;
}
}
//open from back to front
for (int i = mModalCache.Count - 1; i >= 0; i--)
{
var ctrl = mModalCache[i];
ctrl.SetShow(true);
ctrl.Open();
yield return(ctrl.Opening());
}
//set top active
mModalStack.Peek().SetActive(true);
}
}
private void ClearSlots()
{
//slots
for (int i = 0; i < mItemSlotActives.Count; i++)
{
var slot = mItemSlotActives[i];
if (slot)
{
slot.transform.SetParent(templateCacheHolder);
mItemSlotCache.Add(slot);
}
}
mItemSlotActives.Clear();
//slot items
for (int i = 0; i < mItemActives.Count; i++)
{
var itm = mItemActives[i];
if (itm)
{
itm.Deinit(templateCacheHolder);
mItemCache.Add(itm);
}
}
mItemActives.Clear();
}
public void DespawnAllBlobs()
{
if (mBlobActives == null)
{
return;
}
for (int i = 0; i < mBlobActives.Count; i++)
{
var blob = mBlobActives[i];
if (!blob)
{
continue;
}
if (blob.poolData)
{
blob.poolData.despawnCallback -= OnBlobRelease;
}
blob.state = Blob.State.Despawning;
}
mBlobActives.Clear();
}
private void ClearMeasureDisplays()
{
//clear angles
for (int i = 0; i < mAngleWidgetActives.Count; i++)
{
var widget = mAngleWidgetActives[i];
widget.transform.SetParent(cacheRoot);
mAngleWidgetCache.Add(widget);
}
mAngleWidgetActives.Clear();
//clear lengths
for (int i = 0; i < mLengthWidgetActives.Count; i++)
{
var itm = mLengthWidgetActives[i];
itm.transform.SetParent(cacheRoot);
mLengthWidgetCache.Add(itm);
}
mLengthWidgetActives.Clear();
//clear texts
for (int i = 0; i < mTextActives.Count; i++)
{
var itm = mTextActives[i];
itm.transform.SetParent(cacheRoot);
mTextCache.Add(itm);
}
mTextActives.Clear();
}
void OnGameChangeMode(GameMapController.Mode mode)
{
switch (mode)
{
case GameMapController.Mode.Play:
ClearDragging();
//deploy active ghosts
mGhostActives.Sort();
for (int i = 0; i < mGhostActives.Count; i++)
{
var ghostBlock = mGhostActives[i];
if (ghostBlock && !ghostBlock.isReleased)
{
ghostBlock.dimensionChangedCallback -= OnGhostBlockDimensionChanged;
ghostBlock.releaseCallback -= OnGhostBlockRelease;
if (ghostBlock.EditIsPlacementValid())
{
ghostBlock.mode = Block.Mode.Solid;
}
else
{
mGhostMatterCount -= ghostBlock.matterCount;
ghostBlock.Release();
}
}
}
mGhostActives.Clear();
GameMapController.instance.PaletteChange(blockName, -mGhostMatterCount);
mGhostMatterCount = 0;
//
UpdateCount();
break;
}
UpdateInteractible();
}
protected override void OnDespawned()
{
if (mJumpRout != null)
{
StopCoroutine(mJumpRout);
mJumpRout = null;
}
ClearStateRout();
mGroundLastWallChecked = null;
//reset stuff here
mMoveCtrl.ResetCollision();
mHeatCollides.Clear();
transform.rotation = Quaternion.identity;
transform.localScale = Vector3.one;
}
public void ClearAllGroup()
{
for (int i = 0; i < mGroupActives.Count; i++)
{
var grp = mGroupActives[i];
grp.Clear();
mGroupCache.Add(grp);
}
mGroupActives.Clear();
}
private void ClearCategoryPicks()
{
for (int i = 0; i < mShapeCategoryWidgetActivePicks.Count; i++)
{
var widget = mShapeCategoryWidgetActivePicks[i];
widget.transform.SetParent(cacheRoot);
mShapeCategoryWidgetCache.Add(widget);
}
mShapeCategoryWidgetActivePicks.Clear();
}
public override bool Evaluate(ShapeProfile shapeProfile)
{
var equalCount = 0;
var sides = shapeProfile.sideLengths;
if (sides.Length % 2 != 0)
{
return(false);
}
var hSideCount = sides.Length / 2;
if (mPairs == null || mPairs.Count != hSideCount)
{
mPairs = new M8.CacheList <Pair>(hSideCount);
}
else
{
mPairs.Clear();
}
for (int i = 0; i < sides.Length; i++)
{
//make sure these are not already paired
var indA = i;
if (IsPaired(indA))
{
continue;
}
var indB = i < sides.Length - 1 ? i + 1 : 0;
if (IsPaired(indB))
{
continue;
}
var sideLenA = Mathf.RoundToInt(sides[indA]);
var sideLenB = Mathf.RoundToInt(sides[indB]);
if (sideLenA == sideLenB)
{
mPairs.Add(new Pair {
indA = indA, indB = indB
});
equalCount++;
}
}
return(equalCount >= count);
}
private void GenerateCheckNumbers()
{
mCheckNumbers.Clear();
for (int i = 0; i < blobSpawner.blobActives.Count; i++)
{
mCheckNumbers.Add(blobSpawner.blobActives[i].number);
}
foreach (var inf in blobSpawner.spawnQueue)
{
mCheckNumbers.Add(inf.number);
}
}
void OnDisable()
{
//deactivate current actives
for (int i = 0; i < mActives.Count; i++)
{
var active = mActives[i];
if (active.activator)
{
active.activator.Deactivate();
}
}
mActives.Clear();
}
void OnDisable()
{
if (mRout != null)
{
StopCoroutine(mRout);
mRout = null;
}
if (entityDeathWatch)
{
entityDeathWatch.releaseCallback -= OnEntityDeathWatchRelease;
}
//clear out spawns, shouldn't be filled at this point
for (int i = 0; i < mSpawnedPathogens.Count; i++)
{
if (mSpawnedPathogens[i])
{
mSpawnedPathogens[i].releaseCallback -= OnSpawnedEntityRelease;
}
}
mSpawnedPathogens.Clear();
}
void OnDisable()
{
mActInvokes.Clear();
if (mCurRout != null)
{
StopCoroutine(mCurRout);
mCurRout = null;
}
if (quitActiveGO)
{
quitActiveGO.SetActive(false);
}
}
public void DeInit()
{
for (int i = 0; i < mActives.Count; i++)
{
Destroy(mActives[i].gameObject);
}
for (int i = 0; i < mAvailable.Count; i++)
{
Destroy(mAvailable[i].gameObject);
}
mActives.Clear();
mAvailable.Clear();
mInactiveHolder = null;
}
void OnDisable()
{
if (mActives != null)
{
for (int i = 0; i < mActives.Count; i++)
{
var itm = mActives[i];
if (itm)
{
itm.despawnCallback -= OnSpawnRelease;
itm.Release();
}
}
mActives.Clear();
}
}
protected override void OnInstanceDeinit()
{
nextSignal.callback -= OnNext;
if (mActiveTargets != null)
{
for (int i = 0; i < mActiveTargets.Count; i++)
{
if (mActiveTargets[i])
{
mActiveTargets[i].setStateCallback -= OnTargetChangeState;
mActiveTargets[i].releaseCallback -= OnTargetReleased;
}
}
mActiveTargets.Clear();
}
base.OnInstanceDeinit();
}
void OnGameModeChange(GameMapController.Mode mode)
{
switch (mode)
{
case GameMapController.Mode.Edit:
StopAllCoroutines();
//disconnect current blocks
for (int i = 0; i < mAttachedBlocks.Count; i++)
{
BlockConnectController.instance.SetConnect(mAttachedBlocks[i].blockName, false);
}
mAttachedBlocks.Clear();
break;
case GameMapController.Mode.Play:
StartCoroutine(DoBlockUpdate());
break;
}
}
public void Clear()
{
if (mDots == null || mLines == null)
{
return;
}
for (int i = 0; i < mDots.Count; i++)
{
mDots[i].t.gameObject.SetActive(false);
mDotsCache.Add(mDots[i]);
}
mDots.Clear();
for (int i = 0; i < mLines.Count; i++)
{
mLines[i].gameObject.SetActive(false);
mLinesCache.Add(mLines[i]);
}
mLines.Clear();
}
public void Init(CriteriaWidget template, int count, List <InfoData> dataList)
{
mItems = dataList;
//clear previous
if (mWidgets.Count > 0)
{
for (int i = 0; i < mWidgets.Count; i++)
{
var widget = mWidgets[i];
widget.gameObject.SetActive(false);
mWidgetCache.Add(widget);
}
mWidgets.Clear();
}
//add based on count
for (int i = 0; i < count; i++)
{
CriteriaWidget newWidget;
if (mWidgetCache.Count > 0)
{
newWidget = mWidgetCache.RemoveLast();
}
else
{
newWidget = Instantiate(template, root);
}
newWidget.gameObject.SetActive(true);
mWidgets.Add(newWidget);
}
Refresh();
}
protected override void OnDespawned()
{
//reset stuff here
if (MissionController.instance)
{
MissionController.instance.signalCallback += OnMissionSignal;
}
mRout = null;
//release any active arms
for (int i = 0; i < mArms.Count; i++)
{
if (mArms[i] && !mArms[i].isReleased)
{
mArms[i].setStateCallback -= OnArmChangeState;
mArms[i].releaseCallback -= OnArmRelease;
mArms[i].Release();
}
}
mArms.Clear();
}
IEnumerator DoScore()
{
//lock inputs, enabled clicks on placed
for (int i = 0; i < mShapeCategoryWidgetActivePicks.Count; i++)
{
mShapeCategoryWidgetActivePicks[i].isDragEnabled = false;
}
for (int i = 0; i < mShapeCategoryWidgetActivePlaced.Count; i++)
{
mShapeCategoryWidgetActivePlaced[i].isDragEnabled = false;
mShapeCategoryWidgetActivePlaced[i].isClickEnabled = true;
}
//hide next
yield return(nextBase.PlayExitWait());
nextBase.gameObject.SetActive(false);
//hide pick category
yield return(categoryPickBase.PlayExitWait());
categoryPickBase.gameObject.SetActive(false);
//clear out picks
ClearCategoryPicks();
//ClearMeasureDisplays();
bool showCategoryDetailInstruct = false;
int correctCount = 0;
int wrongCount = 0;
var wait = new WaitForSeconds(evaluateDelay);
mShapeCategoriesPlaced.Clear();
//evaluate placed categories
for (int i = 0; i < mShapeCategoryWidgetActivePlaced.Count; i++)
{
var widget = mShapeCategoryWidgetActivePlaced[i];
var category = widget.data;
//check if matched
if (mShapeCategories.Exists(category))
{
widget.correctGO.SetActive(true);
correctCount++;
mShapeCategoriesPlaced.Add(category);
M8.SoundPlaylist.instance.Play(sfxCorrect, false);
}
else
{
widget.errorGO.SetActive(true);
wrongCount++;
M8.SoundPlaylist.instance.Play(sfxWrong, false);
showCategoryDetailInstruct = true;
}
yield return(wait);
}
//add missed categories
for (int i = 0; i < mShapeCategories.Count; i++)
{
var category = mShapeCategories[i];
if (!mShapeCategoriesPlaced.Exists(category))
{
if (mShapeCategoryWidgetCache.Count > 0)
{
var widget = mShapeCategoryWidgetCache.RemoveLast();
widget.Setup(category);
widget.isClickEnabled = true;
widget.missGO.SetActive(true);
widget.transform.SetParent(categoryContainer, false);
mShapeCategoryWidgetActivePlaced.Add(widget);
M8.SoundPlaylist.instance.Play(sfxMiss, false);
showCategoryDetailInstruct = true;
yield return(wait);
}
}
}
if (showCategoryDetailInstruct)
{
categoryInstructGO.SetActive(true);
}
//compute score
float score = Mathf.Clamp01((float)correctCount / mShapeCategories.Count) * GameData.instance.scoreShape;
score -= wrongCount * GameData.instance.scorePenalty;
if (score < 0f)
{
score = 0f;
}
if (mShapeProfile)
{
mShapeProfile.score = Mathf.RoundToInt(score);
scoreCounter.count = mShapeProfile.score;
}
M8.SoundPlaylist.instance.Play(sfxEnter, false);
//show score
scoreBase.gameObject.SetActive(true);
yield return(scoreBase.PlayEnterWait());
//show next
nextBase.gameObject.SetActive(true);
nextBase.PlayEnter();
mRout = null;
}
void ApplyState(State state)
{
if (mCurState != state)
{
var prevState = mCurState;
mCurState = state;
if (mRout != null)
{
StopCoroutine(mRout);
mRout = null;
}
switch (prevState)
{
case State.StagePlay:
HUD.instance.SetTimeActive(false);
if (dangerGO)
{
dangerGO.SetActive(false);
}
mEnemies.Clear();
mIsStagePlaying = false;
mIsStageDuration = false;
isStageTimePause = false;
break;
case State.StageTransition:
if (incomingGO)
{
incomingGO.SetActive(false);
}
break;
}
switch (state)
{
case State.StageTransition:
mRout = StartCoroutine(DoStageTransition());
break;
case State.StagePlay:
if (mCurStageInd >= 0 && mCurStageInd < stages.Length)
{
stages[mCurStageInd].gameObject.SetActive(true);
}
mIsStageDuration = stages[mCurStageInd].duration > 0f;
SendSignal(SignalType.NewStage, mCurStageInd);
mRout = StartCoroutine(DoStagePlay());
break;
case State.Victory:
mRout = StartCoroutine(DoVictory());
break;
case State.Defeat:
mRout = StartCoroutine(DoDefeat());
break;
}
}
}
public void Show(bool aShow)
{
if (mIsShow != aShow)
{
mIsShow = aShow;
if (mIsShow)
{
gameObject.SetActive(true);
//add widgets
var blocks = GameData.instance.blocks;
for (int i = 0; i < blocks.Length; i++)
{
var blockInfo = blocks[i];
if (GameMapController.instance.PaletteCount(blockInfo.name) > 0)
{
AddNewPaletteItem(blockInfo, false);
}
}
//ensure we are positioned properly
switch (GameMapController.instance.mode)
{
case GameMapController.Mode.Play:
toggleButton.transform.localScale = new Vector3(-1f, 1f, 1f);
animator.ResetTake(mTakeEditShowId);
break;
case GameMapController.Mode.Edit:
toggleButton.transform.localScale = new Vector3(1f, 1f, 1f);
animator.ResetTake(mTakeEditHideId);
break;
}
GameMapController.instance.paletteUpdateCallback += OnGamePaletteUpdate;
GameMapController.instance.modeChangeCallback += OnGameModeChange;
GameMapController.instance.blockSelectedChangeCallback += OnGameBlockSelectChanged;
}
else
{
GameMapController.instance.paletteUpdateCallback -= OnGamePaletteUpdate;
GameMapController.instance.modeChangeCallback -= OnGameModeChange;
GameMapController.instance.blockSelectedChangeCallback -= OnGameBlockSelectChanged;
//clear up widgets
for (int i = 0; i < mActiveWidgets.Count; i++)
{
if (mActiveWidgets[i])
{
mActiveWidgets[i].releaseCallback -= OnWidgetRelease;
widgetPool.Release(mActiveWidgets[i].gameObject);
}
}
mActiveWidgets.Clear();
gameObject.SetActive(false);
}
}
}
void ResetContacts()
{
mTriggerContacts.Clear();
mCollisionContacts.Clear();
}
void M8.IModalPop.Pop()
{
mActivateGOs.Clear();
}
void Update()
{
if (curEnergy <= 0f || energyTransferScale == 0f || !mTriggerBoxColl || (block && block.state == (int)EntityState.Dead))
{
return;
}
float curTime = Time.time;
if (curTime - mLastUpdateTime >= energyTransferDelay)
{
mLastUpdateTime = curTime;
//setup energy to transfer
bool isDeath = explodeOnOverCapacity && isCapacityReached;
float energyTransfer = curEnergy * energyTransferScale;
curEnergy -= energyTransfer;
mReceivers.Clear();
int contactCount = Physics2D.GetContacts(mTriggerBoxColl, mCollContacts);
if (contactCount > 0)
{
M8.EntityBase killEnt = null;
for (int i = 0; i < contactCount; i++)
{
var coll = mCollContacts[i];
//kill?
if (!string.IsNullOrEmpty(killTag) && !killEnt && coll.gameObject.CompareTag(killTag))
{
killEnt = coll.GetComponent <M8.EntityBase>();
continue;
}
var conductive = coll.GetComponent <ConductiveController>();
//check criterias
if (coll == mTriggerBoxColl)
{
continue;
}
if (conductive.energyReceiveScale == 0f) //cannot receive energy?
{
continue;
}
if (conductive.isCapacityReached) //capacity already reached
{
continue;
}
if (conductive.IsReceiver(this)) //are we already a receiver from this conductor?
{
continue;
}
mReceivers.Add(new Contact(coll, conductive));
}
//distribute energy transfer
if (mReceivers.Count > 0)
{
float energyPerReceiver = energyTransfer / mReceivers.Count;
for (int i = 0; i < mReceivers.Count; i++)
{
var ctrl = mReceivers[i].ctrl;
ctrl.curEnergy += energyPerReceiver;
if (ctrl.receivedCallback != null)
{
ctrl.receivedCallback(this, energyPerReceiver);
}
}
}
//kill entity?
if (killEnt)
{
//check if it is within kill bounds
if (colliderBody)
{
Vector2 pos = transform.worldToLocalMatrix.MultiplyPoint3x4(killEnt.transform.position);
Vector2 boxPos = mTriggerBoxColl.offset;
Vector2 min = boxPos - mKillExt, max = boxPos + mKillExt;
if (pos.x >= min.x && pos.x <= max.x && pos.y >= min.y && pos.y <= max.y)
{
killEnt.state = (int)EntityState.Dead;
}
}
else
{
killEnt.state = (int)EntityState.Dead;
}
}
}
//die from capacity reached?
if (isDeath && block && !block.isReleased)
{
block.state = (int)EntityState.Dead;
}
}
}
protected virtual void OnDisable()
{
ApplyOrientDir(mOrientDestDir);
mForceFields.Clear();
}
