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); } }