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();
}
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);
}
}
public void ClearGroup(Group group)
{
for (int i = 0; i < mGroupActives.Count; i++)
{
if (mGroupActives[i] == group)
{
group.Clear();
mGroupActives.RemoveAt(i);
mGroupCache.Add(group);
break;
}
}
}
void OnCollisionEnter2D(Collision2D collision)
{
var coll = collision.collider;
//check if already contained
for (int i = 0; i < mCollisionContacts.Count; i++)
{
if (mCollisionContacts[i].coll == coll)
{
return;
}
}
//add
HeatController heat = coll.GetComponent <HeatController>();
if (heat)
{
if (mCollisionContacts.IsFull)
{
mCollisionContacts.Expand();
}
mCollisionContacts.Add(new Contact(coll, heat));
}
}
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);
}
}
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();
}
IEnumerator DoSpawn()
{
var waitStart = new WaitForSeconds(startDelay);
var waitAfterSpawn = new WaitForSeconds(spawnAfterDelay);
yield return(waitStart);
while (true)
{
Vector2 spawnPt = spawnPoint.position;
#if UNITY_EDITOR
ApplyParams();
#endif
var spawn = mPool.Spawn(template.name, template.name, null, mParms);
spawn.despawnCallback += OnSpawnRelease;
spawn.transform.position = spawnPt;
mActives.Add(spawn);
while (mActives.Count == activeCount)
{
yield return(null);
}
yield return(waitAfterSpawn);
}
}
void OnTriggerEnter2D(Collider2D collision)
{
if (!string.IsNullOrEmpty(tagFilter) && !collision.CompareTag(tagFilter))
{
return;
}
bool exists = false;
for (int i = 0; i < mBodies.Count; i++)
{
if (mBodies[i] && mBodies[i].gameObject == collision.gameObject)
{
exists = true;
break;
}
}
if (!exists)
{
var body = collision.GetComponent <Rigidbody2D>();
if (body)
{
mBodies.Add(body);
}
}
}
void Awake()
{
cardTemplate.gameObject.SetActive(false);
//setup cards
var itemGrp = GridEditController.instance.levelData;
var items = itemGrp.items;
cards = new M8.CacheList <GridEntityCardWidget>(items.Length);
for (int i = 0; i < items.Length; i++)
{
var itm = items[i];
var cardWidget = Instantiate(cardTemplate, container);
cardWidget.Setup(itm);
cardWidget.gameObject.SetActive(true);
cards.Add(cardWidget);
}
RefreshCount();
signalListenEntitySizeChanged.callback += OnEntitySizeChanged;
signalListenMapChanged.callback += OnMapChanged;
GridEditController.instance.editChangedCallback += OnEditModeChanged;
}
void Update()
{
var activeCount = mPlantActives.Count;
if (activeCount > mCurCount)
{
int count = activeCount - mCurCount;
for (int i = 0; i < count; i++)
{
var pdc = mPlantActives.RemoveLast();
mSpawnPts.Add(pdc.transform.parent);
pdc.Release();
}
}
else if (activeCount < mCurCount)
{
int count = mCurCount - activeCount;
for (int i = 0; i < count; i++)
{
int spawnToInd = Random.Range(0, mSpawnPts.Count);
var spawnToTrans = mSpawnPts[spawnToInd];
mSpawnPts.RemoveAt(spawnToInd);
var parms = new M8.GenericParams();
parms[Plant.parmSourceSun] = sourceSun;
var pdc = mPoolCtrl.Spawn(template.name, "plant", spawnToTrans, parms);
pdc.transform.localPosition = Vector3.zero;
pdc.transform.localScale = Vector3.one;
mPlantActives.Add(pdc);
}
}
}
IEnumerator DoBlockUpdate()
{
yield return(null);
Vector2 pos = transform.position + bounds.center;
//grab blocks
int collCount = Physics2D.OverlapBoxNonAlloc(pos, bounds.size, 0f, mColls, blockLayerMask);
for (int i = 0; i < collCount; i++)
{
var b = mColls[i].GetComponent <Block>();
if (b)
{
int ind = GetIDData(b);
if (ind != -1)
{
mAttachedBlocks.Add(b);
ids[ind].ApplyColor();
BlockConnectController.instance.SetConnect(b.blockName, true);
}
}
}
}
void OnMoveCollisionEnter(EntityHeroMoveController ctrl, Collision2D coll)
{
//check if it's a side collision
//if(!ctrl.isSlopSlide && (ctrl.collisionFlags & CollisionFlags.Sides) != CollisionFlags.None)
//ctrl.moveHorizontal *= -1.0f;
//check for heat controller
bool isFound = false;
for (int i = 0; i < mHeatCollides.Count; i++)
{
if (mHeatCollides[i].coll == coll.collider)
{
isFound = true;
break;
}
}
if (!isFound)
{
var heatCtrl = coll.collider.GetComponent <HeatController>();
if (heatCtrl)
{
if (mHeatCollides.IsFull)
{
mHeatCollides.Expand();
}
mHeatCollides.Add(new HeatController.Contact(coll.collider, heatCtrl));
}
}
}
IEnumerator DoSpawnQueue()
{
var wait = new WaitForSeconds(spawnDelay);
while (mSpawnQueue.Count > 0)
{
while (mBlobActives.IsFull) //wait for blobs to release
{
yield return(null);
}
yield return(wait);
var spawnInfo = mSpawnQueue.Dequeue();
//find valid spawn point
Vector2 spawnPt = Vector2.zero;
while (true)
{
var pt = mSpawnPts[mCurSpawnPtInd];
mCurSpawnPtInd++;
if (mCurSpawnPtInd == mSpawnPts.Length)
{
mCurSpawnPtInd = 0;
}
//check if valid
var coll = Physics2D.OverlapCircle(pt, spawnPointCheckRadius, spawnPointCheckMask);
if (!coll)
{
spawnPt = pt;
break;
}
//invalid, check next
yield return(null);
}
//spawn
mSpawnParms[JellySpriteSpawnController.parmPosition] = spawnPt;
mSpawnParms[Blob.parmNumber] = spawnInfo.number;
var template = templateGroups[spawnInfo.templateIndex].template;
mBlobNameCache.Clear();
mBlobNameCache.Append(template.name);
mBlobNameCache.Append(' ');
mBlobNameCache.Append(spawnInfo.number);
var blob = mPool.Spawn <Blob>(template.name, mBlobNameCache.ToString(), null, mSpawnParms);
blob.poolData.despawnCallback += OnBlobRelease;
mBlobActives.Add(blob);
}
mSpawnRout = null;
}
protected override IEnumerator Start()
{
yield return(base.Start());
//hook stuff up after others init
mucusGatherInput.pointerDownCallback += OnMucusFieldInputDown;
mucusGatherInput.pointerDragCallback += OnMucusFieldInputDrag;
mucusGatherInput.pointerUpCallback += OnMucusFieldInputUp;
mucusGatherInput.lockChangeCallback += OnMucusFieldInputLockChange;
for (int i = 0; i < cellWalls.Length; i++)
{
if (cellWalls[i])
{
cellWalls[i].setStateCallback += OnCellWallStateChanged;
mCellWallsAlive.Add(cellWalls[i]);
}
}
HUD.instance.SetMissionActive(true);
HUD.instance.SetTimeActive(false);
if (dangerGO)
{
dangerGO.SetActive(false);
}
inputLock = true;
while (M8.SceneManager.instance.isLoading)
{
yield return(null);
}
inputLock = false;
mCurStageInd = -1;
int toStage = 0;
if (isRetry)
{
toStage = M8.SceneState.instance.global.GetValue(SceneStateVars.curStage);
}
else
{
toStage = M8.SceneState.instance.global.GetValue(SceneStateVars.debugStartStage);
if (toStage > 1) //activate mucus
{
ActivateSpawners();
}
}
ResetUpgrades();
EnterStage(toStage);
}
void Awake()
{
shapeSolid.Configure();
shapeOutline.Configure();
//generate category widget cache
for (int i = 0; i < mShapeCategoryWidgetCache.Capacity; i++)
{
var inst = Instantiate(categoryWidgetTemplate, cacheRoot);
inst.dragCallback += OnCategoryDrag;
inst.dragEndCallback += OnCategoryDragEnd;
inst.dragCancelCallback += OnCategoryDragCancel;
mShapeCategoryWidgetCache.Add(inst);
}
categoryWidgetTemplate.gameObject.SetActive(false);
//generate measure display caches
for (int i = 0; i < mAngleWidgetCache.Capacity; i++)
{
var angleWidget = Instantiate(angleTemplate, cacheRoot);
mAngleWidgetCache.Add(angleWidget);
}
angleTemplate.gameObject.SetActive(false);
//generate length display caches
for (int i = 0; i < mLengthWidgetCache.Capacity; i++)
{
var itm = Instantiate(lengthTemplate, cacheRoot);
mLengthWidgetCache.Add(itm);
}
lengthTemplate.gameObject.SetActive(false);
//generate text cache
for (int i = 0; i < mTextCache.Capacity; i++)
{
var itm = Instantiate(measureTextTemplate, cacheRoot);
mTextCache.Add(itm);
}
measureTextTemplate.gameObject.SetActive(false);
}
/// <summary>
/// Call this with SoundPlayer returned by Play, normally use this for looping clip
/// </summary>
public void Stop(SoundPlayer sp)
{
//in case parent is set elsewhere
sp.transform.SetParent(transform, false);
sp.gameObject.SetActive(false);
mAvailable.Add(sp);
}
public void Clear()
{
while (mDisplayActives.Count > 0)
{
var go = mDisplayActives.RemoveLast();
go.SetActive(false);
mDisplayInactives.Add(go);
}
}
private Group NewGroup()
{
var newGrp = mGroupCache.Remove();
if (newGrp != null)
{
mGroupActives.Add(newGrp);
}
return(newGrp);
}
public void Expand(string group, int num)
{
mCapacity += num;
if (mCapacity > maxCapacity)
{
int diff = mCapacity - maxCapacity;
maxCapacity = mCapacity;
mActives.Expand(diff);
mAvailable.Expand(diff);
}
for (int i = 0; i < num; i++)
{
var pdc = PoolDataController.Generate(name, template, group, mInactiveHolder);
mAvailable.Add(pdc);
}
}
private void Cache(AudioSourceProxy src)
{
if (mSourceCache == null)
{
SetupSourceRoot(null);
}
src.gameObject.SetActive(false);
mSourceCache.Add(src);
}
public void SetRegisterInput(EntityMucusFormInput input, bool add)
{
if (add)
{
mRegisteredInputs.Add(input);
}
else
{
mRegisteredInputs.Remove(input);
}
}
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);
}
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 Awake()
{
mDisplayActives = new M8.CacheList <GameObject>(capacity);
mDisplayInactives = new M8.CacheList <GameObject>(capacity);
for (int i = 0; i < capacity; i++)
{
var newGO = Object.Instantiate <GameObject>(template);
newGO.transform.SetParent(templateRoot);
newGO.SetActive(false);
mDisplayInactives.Add(newGO);
}
}
void Awake()
{
mSpawnPts = new M8.CacheList <Transform>(root.childCount);
for (int i = 0; i < root.childCount; i++)
{
mSpawnPts.Add(root.GetChild(i));
}
mPlantActives = new M8.CacheList <M8.PoolDataController>(root.childCount);
mPoolCtrl = M8.PoolController.CreatePool(poolName);
mPoolCtrl.AddType(template, mSpawnPts.Capacity, mSpawnPts.Capacity);
signalTreeChanged.callback += OnScaleTreeChange;
}
void OnDetectTriggerEnter(Collider2D coll)
{
EntityCommon ent = coll.GetComponent <EntityCommon>();
//make sure it's alive and is't already added
if (ent.stats.isAlive && ent.stats.data.type == StatEntity.Type.Biological && !mTargetPotentialEntities.IsFull && !mTargetPotentialEntities.Exists(ent))
{
mTargetPotentialEntities.Add(ent);
if (mLaunchRout == null)
{
mLaunchRout = StartCoroutine(DoLaunch());
}
}
}
void OnTriggerEnter2D(Collider2D other)
{
CleanUp();
if (mUnits.IsFull)
{
Debug.LogWarning(name + ": Unit Capacity is full.");
return;
}
if (UnitVerify(other) && !mUnits.Exists(other))
{
mUnits.Add(other);
UnitAdded(other);
}
}
void IEndDragHandler.OnEndDrag(PointerEventData eventData)
{
if (!mIsDragging)
{
return;
}
//only put the block if it's in the game area, away from the panel
if (!HUD.instance.paletteItemDrag.isShown)
{
//make sure its placement is valid
if (mBlockGhost && mBlockGhost.EditIsPlacementValid())
{
//make sure it's within camera bounds
var blockBounds = mBlockGhost.editBounds;
if (GameCamera.instance.isVisible(blockBounds))
{
var block = mBlockGhost;
mBlockGhost = null;
//add to active ghosts
mGhostActives.Add(block);
mGhostMatterCount += block.matterCount;
GameMapController.instance.PaletteBlockGhostDropped(block);
LoLManager.instance.PlaySound(GameData.instance.soundBlockPlacePath, false, false);
}
else
{
LoLManager.instance.PlaySound(GameData.instance.soundBlockInvalidPath, false, false);
}
}
else
{
LoLManager.instance.PlaySound(GameData.instance.soundBlockInvalidPath, false, false);
}
}
ClearDragging();
HUD.instance.blockMatterExpandPanel.isMoveMode = false;
UpdateCount();
UpdateInteractible();
}
void OnTriggerEnter2D(Collider2D collision)
{
if (!string.IsNullOrEmpty(tagActionFilter) && !collision.CompareTag(tagActionFilter))
{
return;
}
var action = collision.GetComponent <PlayerAction>();
if (action)
{
if (!mActInvokes.Exists(action))
{
mActInvokes.Add(action);
}
}
}
public void ActionAddCallback(ActionCallback cb)
{
int actInd = -1;
for (int i = 0; i < mActionCallbacks.Count; i++)
{
if (mActionCallbacks[i] == cb)
{
actInd = i;
break;
}
}
if (actInd == -1)
{
mActionCallbacks.Add(cb);
}
}
