public void SetRegisterInput(EntityMucusFormInput input, bool add)
{
if (add)
{
mRegisteredInputs.Add(input);
}
else
{
mRegisteredInputs.Remove(input);
}
}
public void RemoveFromActive(Blob blob)
{
if (mBlobActives.Remove(blob))
{
blob.poolData.despawnCallback -= OnBlobRelease;
}
}
public void SetLogFilter(LogType logType, bool active)
{
bool isChanged = false;
if (active)
{
bool isFound = false;
for (int i = 0; i < mLogTypeFilters.Count; i++)
{
if (mLogTypeFilters[i] == logType)
{
isFound = true;
break;
}
}
if (!isFound)
{
mLogTypeFilters.Add(logType);
isChanged = true;
}
}
else
{
isChanged = mLogTypeFilters.Remove(logType);
}
if (isChanged)
{
Refresh();
}
}
private void RemoveTarget(UnitEntity ent)
{
if (mActiveTargets.Remove(ent))
{
ent.setStateCallback -= OnTargetChangeState;
ent.releaseCallback -= OnTargetReleased;
}
}
void OnEntityRelease(M8.EntityBase ent)
{
ent.releaseCallback -= OnEntityRelease;
mActiveUnits.Remove(ent);
UpdateState();
}
private void RemoveBlobFromGroup(Group grp, Blob blob)
{
grp.RemoveBlob(blob);
if (grp.isEmpty)
{
mGroupActives.Remove(grp);
mGroupCache.Add(grp);
}
}
private Group NewGroup()
{
var newGrp = mGroupCache.Remove();
if (newGrp != null)
{
mGroupActives.Add(newGrp);
}
return(newGrp);
}
void OnCategoryDragEnd(ShapeAnalyzeCategoryWidget widget, PointerEventData eventData)
{
categoryHighlightGO.SetActive(false);
bool isInCategoryPanel = IsInCategoryPanel(widget.dragRoot);
if (isInCategoryPanel)
{
//add to placed
if (!mShapeCategoryWidgetActivePlaced.Exists(widget))
{
mShapeCategoryWidgetActivePicks.Remove(widget);
widget.transform.SetParent(categoryContainer, false);
mShapeCategoryWidgetActivePlaced.Add(widget);
//show next if first time
if (mShapeCategoryWidgetActivePlaced.Count == 1)
{
if (!nextBase.gameObject.activeSelf || !nextBase.isEntering)
{
CancelRout();
nextBase.gameObject.SetActive(true);
nextBase.PlayEnter();
}
}
}
}
else
{
//add to picks
if (!mShapeCategoryWidgetActivePicks.Exists(widget))
{
mShapeCategoryWidgetActivePlaced.Remove(widget);
widget.transform.SetParent(categoryPickContainer, false);
mShapeCategoryWidgetActivePicks.Add(widget);
//hide next if no categories picked
if (mShapeCategoryWidgetActivePlaced.Count == 0)
{
if (nextBase.gameObject.activeSelf && !nextBase.isExiting)
{
CancelRout();
mRout = StartCoroutine(DoNextHide());
}
}
}
}
ApplyDragInstruct();
}
SoundPlayer GetAvailable()
{
SoundPlayer ret = mAvailable.Remove();
if (ret)
{
ret.gameObject.SetActive(true);
}
return(ret);
}
IEnumerator DoLaunch()
{
while (true)
{
if (mTargetPotentialEntities.Count == 0)
{
break;
}
//check if potential target is still valid
var potentialTarget = mTargetPotentialEntities[0];
if (potentialTarget == null || !potentialTarget.stats.isAlive)
{
mTargetPotentialEntities.Remove();
continue;
}
//grab launch ready
SpawnPoint spawnPt = null;
for (int i = 0; i < spawnPts.Length; i++)
{
if (spawnPts[i].entity && !spawnPts[i].isSpawning && !spawnPts[i].target)
{
spawnPt = spawnPts[i];
break;
}
}
if (spawnPt != null)
{
//launch at target
spawnPt.Launch(potentialTarget);
mTargetPotentialEntities.Remove();
}
yield return(null);
}
mLaunchRout = null;
}
void OnTriggerExit2D(Collider2D other)
{
if (UnitVerify(other))
{
CleanUp();
if (mUnits.Remove(other))
{
UnitRemoved(other);
}
}
}
public void Release(PoolDataController pdc)
{
pdc.gameObject.SetActive(false);
Transform t = pdc.transform;
t.SetParent(mInactiveHolder, false);
mAvailable.Add(pdc);
mActives.Remove(pdc);
}
public override void Signal(SignalType signal, object parms)
{
switch (signal)
{
case SignalType.EnemyRegister:
mEnemies.Add((EntityCommon)parms);
break;
case SignalType.EnemyUnregister:
mEnemies.Remove((EntityCommon)parms);
break;
}
}
void OnTriggerExit2D(Collider2D other)
{
if (ColliderVerify(other))
{
CleanUp();
T unit = other.GetComponent <T>();
if (unit != null && mUnits.Remove(unit))
{
UnitRemoved(unit);
}
}
}
void OnTriggerExit2D(Collider2D collision)
{
if (!string.IsNullOrEmpty(tagActionFilter) && !collision.CompareTag(tagActionFilter))
{
return;
}
var action = collision.GetComponent <PlayerAction>();
if (action)
{
mActInvokes.Remove(action);
}
}
void OnCellWallStateChanged(M8.EntityBase ent)
{
switch ((EntityState)ent.state)
{
case EntityState.Dead:
//remove from cache
mCellWallsAlive.Remove((EntityCommon)ent);
Debug.Log("cell wall dead: " + ent.name);
//if(mCellWallsAlive.Count <= 0)
//ApplyState(State.Defeat);
break;
}
}
void ReleaseArm(EntityPhagocyteTentacle arm)
{
mArms.Remove(arm);
arm.setStateCallback -= OnArmChangeState;
arm.releaseCallback -= OnArmRelease;
//score
MissionController.instance.ScoreAt(transform.position, arm.score);
arm.Release();
if (animator && animator.currentPlayingTakeName != takeEat)
{
animator.Play(takeEat);
}
//antigen presentation?
}
protected virtual void OnTriggerExit2D(Collider2D col)
{
if (mForceFields.Count == 0)
{
return;
}
if (fieldTagFilter.Length > 0)
{
bool isTagFound = false;
for (int i = 0; i < fieldTagFilter.Length; i++)
{
if (col.CompareTag(fieldTagFilter[i]))
{
isTagFound = true;
break;
}
}
if (!isTagFound)
{
return;
}
}
var forceField = col.GetComponent <ForceFieldBase2D>();
if (!forceField)
{
return;
}
if (mForceFields.Remove(forceField))
{
forceField.ItemRemoved(this);
}
}
void OnWidgetRelease(PaletteItemWidget widget)
{
widget.releaseCallback -= OnWidgetRelease;
mActiveWidgets.Remove(widget);
}
void OnSpawnedEntityRelease(M8.EntityBase ent)
{
ent.releaseCallback -= OnSpawnedEntityRelease;
mSpawnedPathogens.Remove((EntityPathogen)ent);
}
public void ActionRemoveCallback(ActionCallback cb)
{
mActionCallbacks.Remove(cb);
}
private void GenerateEvaluation()
{
//group up entities
var entGroups = entityContainer.GenerateEntityGroups();
var evals = new M8.CacheList <EvaluateData>(entGroups.Count);
for (int i = 0; i < entGroups.Count; i++)
{
var grp = entGroups[i];
evals.Add(new EvaluateData(grp));
}
//filter based on goals
goalEvaluations = new EvaluateData[levelData.goals.Length];
for (int i = 0; i < levelData.goals.Length; i++)
{
var goal = levelData.goals[i];
var goalVolume = goal.volume * levelData.unitVolume;
//grab most matching evaluation
EvaluateData?dat = null;
var datIsMet = false;
var datVolumeDelta = float.MaxValue;
for (int j = evals.Count - 1; j >= 0; j--)
{
var eval = evals[j];
if (eval.data != goal.data)
{
continue;
}
//check if met with goal
var isMet = eval.GoalIsVolumeMet(goal) && eval.GoalIsHeightMet(goal);
var delta = Mathf.Abs(eval.volume.fValue - goalVolume.fValue);
if (!dat.HasValue || (isMet && !datIsMet))
{
dat = eval;
datVolumeDelta = delta;
datIsMet = isMet;
}
else if (isMet && delta < datVolumeDelta)
{
dat = eval;
datVolumeDelta = delta;
}
}
if (dat.HasValue)
{
evals.Remove(dat.Value);
goalEvaluations[i] = dat.Value;
}
else
{
goalEvaluations[i] = new EvaluateData();
}
}
}
void OnSpawnRelease(M8.PoolDataController item)
{
item.despawnCallback -= OnSpawnRelease;
mActives.Remove(item);
}
