public bool Unspawn(GameObject obj) { if (activeList.Contains(obj)) { obj.transform.parent = ObjectPoolManager.GetOPMTransform(); activeList.Remove(obj); inactiveList.Add(obj); obj.SetActive(false); return(true); } return(false); }
public void MatchObjectCount(int count) { if (count > cap) { return; } int currentCount = GetTotalObjectCount(); for (int i = currentCount; i < count; i++) { GameObject obj = (GameObject)MonoBehaviour.Instantiate(prefab); obj.SetActive(false); obj.transform.parent = ObjectPoolManager.GetOPMTransform(); inactiveList.Add(obj); } }
private void Hit() { hit = true; if (hitEffect != null) { print("show hit effect "); ObjectPoolManager.Spawn(hitEffect, targetPos, Quaternion.identity); } if (spell.effects.Count > 0) { Debug.Log("Cast spell effects"); CastSpell(spell, targetPos, target); } ObjectPoolManager.Unspawn(gameObject); }
private IEnumerator FireCoroutine() { //yield return new WaitForSeconds(.1f); ShootObject2D arrow = ObjectPoolManager.Spawn(shootObject).GetComponent <ShootObject2D>(); arrow.transform.position = shootPosition.position; print("arrow.Shoot"); AttackInstance2D attInstance = new AttackInstance2D(); attInstance.srcUnit = this; attInstance.tgtUnit = target; attInstance.Process(); arrow.Shoot(attInstance, shootPosition); yield return(null); //arrow.transform.DOLocalMove(target.targetPosition.position, .5f).OnComplete(() => { base.Fire(); Destroy(arrow.gameObject); }); }
void Awake() { speed_cached = speed; bouncing_max_targets_bk = bouncing_max_targets; thisObj = gameObject; thisT = transform; thisObj.layer = LayerManager.LayerShootObject(); if (autoSearchLineRenderer) { LineRenderer[] lines = thisObj.GetComponentsInChildren <LineRenderer>(true); for (int i = 0; i < lines.Length; i++) { lineList.Add(lines[i]); } } TrailRenderer[] trails = thisObj.GetComponentsInChildren <TrailRenderer>(true); for (int i = 0; i < trails.Length; i++) { trailList.Add(trails[i]); } if (type == _ShootObjectType.FPSProjectile) { SphereCollider sphereCol = GetComponent <SphereCollider>(); if (sphereCol == null) { sphereCol = thisObj.AddComponent <SphereCollider>(); sphereCol.radius = 0.15f; } hitRadius = sphereCol.radius; } if (shootEffect != null) { ObjectPoolManager.New(shootEffect); } if (hitEffect != null) { ObjectPoolManager.New(hitEffect); } }
// Use this for initialization void Start() { foreach (Spawner spawner in prefabs) { ObjectPoolManager.New(spawner.prefab); } DOVirtual.DelayedCall(delay, () => { foreach (Spawner spawner in prefabs) { for (int i = 0; i < spawner.quatity; i++) { ObjectPoolManager.Spawn(spawner.prefab, spawner.StartingPosition); } } }); }
void EffectSettings_CollisionEnter(object sender, CollisionInfo e) { if (Effect == null) { return; } var colliders = Physics.OverlapSphere(transform.position, EffectSettings.EffectRadius, EffectSettings.LayerMask); foreach (var coll in colliders) { var hitGO = coll.transform; var renderer = hitGO.GetComponentInChildren <Renderer>(); var effectInstance = ObjectPoolManager.Spawn(Effect) as GameObject; effectInstance.transform.parent = renderer.transform; effectInstance.transform.localPosition = Vector3.zero; effectInstance.GetComponent <AddMaterialOnHit>().UpdateMaterial(coll.transform); } }
//called by any external component to build tower, uses buildInfo public static string BuildTower(UnitTower tower) { if (buildInfo == null) { return("Select a Build Point First"); } //dont allow building of resource tower before game started if (tower.type == _TowerType.Resource && !GameControl.IsGameStarted()) { return("Cant Build Tower before spawn start"); } UnitTower sampleTower = GetSampleTower(tower); //check if there are sufficient resource List <int> cost = sampleTower.GetCost(); int suffCost = ResourceManager.HasSufficientResource(cost); if (suffCost == -1) { ResourceManager.SpendResource(cost); GameObject towerObj = (GameObject)ObjectPoolManager.Spawn(tower.gameObject, buildInfo.position, buildInfo.platform.thisT.rotation); UnitTower towerInstance = towerObj.GetComponent <UnitTower>(); towerInstance.InitTower(instance.towerCount += 1); towerInstance.Build(); //register the tower to the platform if (buildInfo.platform != null) { buildInfo.platform.BuildTower(buildInfo.position, towerInstance); } //clear the build info and indicator for build manager ClearBuildPoint(); return(""); } return("Insufficient Resource"); }
IEnumerator ResourceTowerRoutine() { while (true) { yield return(new WaitForSeconds(GetCooldown())); while (stunned || IsInConstruction()) { yield return(null); } Transform soPrefab = GetShootObjectT(); if (soPrefab != null) { ObjectPoolManager.Spawn(soPrefab, thisT.position, thisT.rotation); } ResourceManager.GainResource(GetResourceGain(), PerkManager.GetRscTowerGain()); } }
//called from ActivateAbility, cast the ability, visual effect and actual effect goes here public void CastAbility(Ability ab, Vector3 pos = default(Vector3), Unit target = null) { GameObject effect = null; //print((ab.Caster ? "Unknown" : ab.Caster.unitName) + " casted " + ab.name + " on " + target); if (ab.prefab != null) { if (ab.abilityType == Ability.AbilityType.Summoning) { effect = ObjectPoolManager.Spawn(ab.prefab, ab.caster.GetTargetT().position + Vector3.right * -2f, Quaternion.identity); BuildManager.PreBuildTower(effect.GetComponent <UnitDefender>()); } else if (ab.selfCast || ab.castAtCaster) { effect = ObjectPoolManager.Spawn(ab.prefab, ab.caster.thisT.position, Quaternion.identity); if (ab.caster) { print("Set parent"); effect.transform.parent = ab.caster.transform; } } else { effect = ObjectPoolManager.Spawn(ab.prefab, target ? target.GetTargetT().position : pos, Quaternion.identity); } } if (ab.useDefaultEffect) { StartCoroutine(ApplyAbilityEffect(ab, pos, target)); } //else if (effect) //{ // AbilityBehavior abilityBehavior = effect.GetComponent<AbilityBehavior>(); // if (abilityBehavior) // { // StartCoroutine(ApplyAbilityEffect(abilityBehavior.ability, pos, target)); // } //} }
IEnumerator MineRoutine() { LayerMask maskTarget = 1 << LayerManager.LayerCreep(); while (true) { if (!dead && !IsInConstruction()) { Collider[] cols = Physics.OverlapSphere(thisT.position, GetAttackRange(), maskTarget); if (cols.Length > 0) { Collider[] colls = Physics.OverlapSphere(thisT.position, GetAOERadius(), maskTarget); for (int i = 0; i < colls.Length; i++) { Unit unit = colls[i].transform.GetComponent <Unit>(); if (unit == null && !unit.dead) { continue; } AttackInstance attInstance = new AttackInstance(); attInstance.srcUnit = this; attInstance.tgtUnit = unit; attInstance.Process(); unit.ApplyEffect(attInstance); } Transform soPrefab = GetShootObjectT(); if (soPrefab != null) { ObjectPoolManager.Spawn(soPrefab, thisT.position, thisT.rotation); } Dead(); } } yield return(new WaitForSeconds(0.1f)); } }
IEnumerator FPSEffectRoutine() { yield return(new WaitForSeconds(0.05f)); RaycastHit raycastHit; Vector3 dir = thisT.TransformDirection(new Vector3(0, 0, 1)); if (Physics.SphereCast(thisT.position, hitRadius / 2, dir, out raycastHit)) { Unit unit = raycastHit.transform.GetComponent <Unit>(); FPSHit(unit, raycastHit.point); if (hitEffect != null) { ObjectPoolManager.Spawn(hitEffect, raycastHit.point, Quaternion.identity); } } yield return(new WaitForSeconds(0.1f)); ObjectPoolManager.Unspawn(thisObj); }
IEnumerator FPSBeamRoutine(Transform sp) { thisT.parent = sp; float duration = 0; while (duration < beamDuration) { RaycastHit raycastHit; Vector3 dir = thisT.TransformDirection(new Vector3(0, 0, 1)); bool hitCollider = Physics.SphereCast(thisT.position, hitRadius, dir, out raycastHit); if (hitCollider) { if (!hit) { hit = true; Unit unit = raycastHit.transform.GetComponent <Unit>(); FPSHit(unit, raycastHit.point); if (hitEffect != null) { ObjectPoolManager.Spawn(hitEffect, raycastHit.point, Quaternion.identity); } } } float lineDist = raycastHit.distance == 0 ? 9999 : raycastHit.distance; for (int i = 0; i < lineList.Count; i++) { lineList[i].SetPosition(1, new Vector3(0, 0, lineDist)); } duration += Time.fixedDeltaTime; yield return(new WaitForSeconds(Time.fixedDeltaTime)); } thisT.parent = null; ObjectPoolManager.Unspawn(thisObj); }
private IEnumerator BulletRoutine() { print("BulletRoutine"); if (shootEffect != null) { ObjectPoolManager.Spawn(shootEffect, transform.position, transform.rotation); } yield return(new WaitForSeconds(shootDelay)); //while the shootObject havent hit the target while (!hit) { if (target != null) { targetPos = target.GetTargetTransform().position; } //calculating distance to targetPos Vector3 curPos = transform.position; //curPos.y = y; float currentDist = Vector2.Distance(curPos, targetPos); //if the target is close enough, trigger a hit if (currentDist < hitThreshold && !hit) { Hit(); break; } transform.LookAt(targetPos); //move forward transform.Translate(Vector3.forward * Mathf.Min(speed * Time.deltaTime, currentDist)); //transform.rotation = Quaternion.Euler(0, 0, 0); transform.rotation = Quaternion.Euler(0, 0, -transform.rotation.eulerAngles.x); speed += accel * Time.deltaTime; yield return(null); } }
public UnitTower CreateSampleTower(UnitTower towerPrefab) { GameObject towerObj = (GameObject)ObjectPoolManager.Spawn(towerPrefab.gameObject); towerObj.transform.parent = transform; if (towerObj.GetComponent <Collider>() != null) { Destroy(towerObj.GetComponent <Collider>()); } Utility.DestroyColliderRecursively(towerObj.transform); //foreach(Transform child in towerObj.transform){ // Animator animator=child.gameObject.GetComponent<Animator>(); // if(animator!=null) animator.enabled=false; //} towerObj.SetActive(false); UnitTower towerInstance = towerObj.GetComponent <UnitTower>(); towerInstance.SetAsSampleTower(towerPrefab); return(towerInstance); }
void Fire() { //if(!weapon.ReadyToFire()) return; if (currentWeapon.Shoot()) { AttackInstance attInstance = new AttackInstance(); attInstance.srcWeapon = currentWeapon; for (int i = 0; i < currentWeapon.shootPoints.Count; i++) { Transform shootP = currentWeapon.shootPoints[i]; Transform shootObjT = (Transform)ObjectPoolManager.Spawn(currentWeapon.GetShootObject(), shootP.position, shootP.rotation); shootObjT.GetComponent <ShootObject>().ShootFPS(attInstance, shootP); } Recoil(currentWeapon.recoil); if (onFPSShootE != null) { onFPSShootE(); } } }
private IEnumerator ProjectileRoutine() { if (shootEffect != null) { ObjectPoolManager.Spawn(shootEffect, transform.position, transform.rotation); } yield return(new WaitForSeconds(shootDelay)); //make sure the shootObject is facing the target and adjust the projectile angle transform.LookAt(targetPos); float angle = Mathf.Min(1, Vector3.Distance(transform.position, targetPos) / maxShootRange) * maxShootAngle; //clamp the angle magnitude to be less than 45 or less the dist ratio will be off transform.rotation = transform.rotation * Quaternion.Euler(-angle, 0, 0); Vector3 startPos = transform.position; float iniRotX = transform.rotation.eulerAngles.x; float y = Mathf.Min(targetPos.y, startPos.y); float totalDist = Vector3.Distance(startPos, targetPos); float timeShot = Time.time; //while the shootObject havent been hitting the target while (!hit) { if (target != null && updateTargetPosition) { targetPos = target.GetTargetTransform().position; } //calculating distance to targetPos Vector3 curPos = transform.position; //curPos.y = y; float currentDist = Vector2.Distance(curPos, targetPos); //if the target is close enough, trigger a hit if (currentDist < hitThreshold && !hit) { Hit(); break; } if (Time.time - timeShot < 3f) { //calculate ratio of distance covered to total distance float invR = 1 - Mathf.Min(.5f, currentDist * smoothly / totalDist); //use the distance information to set the rotation, //as the projectile approach target, it will aim straight at the target Vector3 wantedDir = targetPos - transform.position; if (wantedDir != Vector3.zero) { Quaternion wantedRotation = Quaternion.LookRotation(wantedDir); float rotX = Mathf.LerpAngle(iniRotX, wantedRotation.eulerAngles.x, invR); //make y-rotation always face target transform.rotation = Quaternion.Euler(rotX, wantedRotation.eulerAngles.y, wantedRotation.eulerAngles.z); } } else { //this shoot time exceed 3 sec, abort the trajectory and just head to the target transform.LookAt(targetPos); } //move forward //transform.LookAt(targetPos); transform.Translate(Vector3.forward * Mathf.Min(speed * Time.deltaTime, currentDist)); transform.rotation = Quaternion.Euler(0, 0, transform.rotation.eulerAngles.x); yield return(null); } }
IEnumerator Building(float duration, bool reverse = false) { //reverse flag is set to true when selling (thus unbuilding) the tower construction = !reverse ? _Construction.Constructing : _Construction.Deconstructing; builtDuration = 0; buildDuration = duration; if (onConstructionStartE != null) { onConstructionStartE(this); } yield return(null); if (!reverse && playConstructAnimation != null) { playConstructAnimation(); } else if (reverse && playDeconstructAnimation != null) { playDeconstructAnimation(); } if (SpawnEffect) { SpawnEffect = ObjectPoolManager.Spawn(SpawnEffect, thisT.position, thisT.rotation); foreach (Renderer render in renderParent) { render.enabled = false; } } while (true) { yield return(null); builtDuration += Time.deltaTime; if (builtDuration > buildDuration) { break; } } if (SpawnEffect) { ObjectPoolManager.Unspawn(SpawnEffect); foreach (Renderer render in renderParent) { render.enabled = true; } } construction = _Construction.None; if (!reverse && onConstructionCompleteE != null) { onConstructionCompleteE(this); } if (reverse) { if (onSoldE != null) { onSoldE(this); } if (occupiedPlatform != null) { occupiedPlatform.UnbuildTower(occupiedNode); } ResourceManager.GainResource(GetValue()); Dead(); } }
void Awake() { Time.fixedDeltaTime = timeStep; instance = this; thisT = transform; //ObjectPoolManager.Init(); BuildManager buildManager = (BuildManager)FindObjectOfType(typeof(BuildManager)); buildManager.Init(); NodeGenerator nodeGenerator = (NodeGenerator)FindObjectOfType(typeof(NodeGenerator)); if (nodeGenerator != null) { nodeGenerator.Awake(); } PathFinder pathFinder = (PathFinder)FindObjectOfType(typeof(PathFinder)); if (pathFinder != null) { pathFinder.Awake(); } PathTD[] paths = FindObjectsOfType(typeof(PathTD)) as PathTD[]; for (int i = 0; i < paths.Length; i++) { paths[i].Init(); } for (int i = 0; i < buildManager.buildPlatforms.Count; i++) { buildManager.buildPlatforms[i].Init(); } gameObject.GetComponent <ResourceManager>().Init(); PerkManager perkManager = (PerkManager)FindObjectOfType(typeof(PerkManager)); if (perkManager != null) { perkManager.Init(); } if (loadAudioManager) { Instantiate(Resources.Load("AudioManager", typeof(GameObject))); } if (rangeIndicator) { rangeIndicator = (Transform)ObjectPoolManager.Spawn(rangeIndicator); rangeIndicator.parent = thisT; rangeIndicatorObj = rangeIndicator.gameObject; } if (rangeIndicatorCone) { rangeIndicatorCone = (Transform)ObjectPoolManager.Spawn(rangeIndicatorCone); rangeIndicatorCone.parent = thisT; rangeIndicatorConeObj = rangeIndicatorCone.gameObject; } ClearSelectedTower(); Time.timeScale = 1; }
IEnumerator AOETowerRoutine() { if (CurrentStat.customMask > -1) { TargetMask = CurrentStat.customMask; } else if (targetMode == _TargetMode.Hybrid) { LayerMask mask1 = 1 << LayerManager.LayerCreep(); LayerMask mask2 = 1 << LayerManager.LayerCreepF(); TargetMask = mask1 | mask2; } else if (targetMode == _TargetMode.Air) { TargetMask = 1 << LayerManager.LayerCreepF(); } else if (targetMode == _TargetMode.Ground) { TargetMask = 1 << LayerManager.LayerCreep(); } while (true) { yield return(new WaitForSeconds(GetCooldown())); while (stunned || IsInConstruction()) { yield return(null); } Collider[] cols = Physics.OverlapSphere(thisT.position, GetAttackRange(), TargetMask); if (cols.Length > 0) { Transform soPrefab = GetShootObjectT(); if (soPrefab != null) { ObjectPoolManager.Spawn(soPrefab, thisT.position, thisT.rotation); } //SendMessage("OnAttackTargetStarted", SendMessageOptions.DontRequireReceiver); //print("AOE attack"); for (int i = 0; i < cols.Length; i++) { Unit unit = cols[i].transform.GetComponent <Unit>(); //damage all units in its range if (unit == null && !unit.dead) { continue; } AttackInstance attInstance = new AttackInstance(); attInstance.srcUnit = this; attInstance.tgtUnit = unit; attInstance.Process(); unit.ApplyEffect(attInstance); } } else { //SendMessage("OnAttackTargetStopped", SendMessageOptions.DontRequireReceiver); //print("AOE stopped"); } } }
void Hit() { hit = true; if (isArrow) //leave an arrow in the ground effect { targetPos = new Vector3(targetPos.x + Random.value - .5f, 0.05f, targetPos.z + Random.value - .5f); } if (hitEffect != null) { ObjectPoolManager.Spawn(hitEffect, targetPos, isArrow ? Quaternion.Euler(-180, Random.Range(0, 30), Random.Range(0, 30)) : Quaternion.identity); } //apply ability if (Ab_End_Holder) { AbilityManager.instance.ActivateAbility(Ab_End_Holder.ability, attInstance.srcUnit, targetPos, target); } thisT.position = targetPos; attInstance.impactPoint = thisT.position; LayerMask mask = attInstance.srcUnit.TargetMask; if (attInstance.srcUnit.GetAOERadius() > 0) { Collider[] cols = Physics.OverlapSphere(thisT.position, attInstance.srcUnit.GetAOERadius(), mask); AttackTargets(cols); print("Splash attack kill more " + cols.Length); } else { if (target != null) { target.ApplyEffect(attInstance); if (target.alarmWhenGotAttacked && !target.isAlarming && target.GetAttackRange() < 2 && attInstance.damage > 0) { target.isAlarming = true; target.attacker = attInstance.srcUnit; target.StartCoroutine(SetAlarmOff(target, 10)); } if (penetratable && penetration_distance > 0) //penetratable attack { Vector3 position = shootPoint.position; Vector3 direction = target.GetTargetT().position - position; RaycastHit[] hits = Physics.RaycastAll(position, direction.normalized, penetration_distance); AttackTargets(hits.GetColliders()); print("Penetrate attack kill more " + hits.Length); } } } //DestroyImmediate(thisObj); if (!bouncing) { ObjectPoolManager.Unspawn(thisObj); } else { Collider[] cols = Physics.OverlapSphere(thisT.position, bouncing_radius, mask); if (cols.Length > 0) { print("Bonce"); List <Unit> tgtList = new List <Unit>(); for (int i = 0; i < cols.Length; i++) { Unit unit = cols[i].gameObject.GetComponent <Unit>(); if (unit && !unit.dead && unit != attInstance.tgtUnit) { tgtList.Add(unit); } } if (tgtList.Count > 0 && bouncing_max_targets >= 0) { bouncing_max_targets--; attInstance.tgtUnit = tgtList[0]; Shoot(attInstance, thisT); } } else { ObjectPoolManager.Unspawn(thisObj); } } }
IEnumerator SpawnSubWave(SubWave subWave, Wave parentWave) { yield return(new WaitForSeconds(subWave.delay)); PathTD path = defaultPath; if (subWave.path != null) { path = subWave.path; } Vector3 pos = path.GetSpawnPoint().position; Quaternion rot = path.GetSpawnPoint().rotation; int spawnCount = 0; while (spawnCount < subWave.count) { GameObject obj = ObjectPoolManager.Spawn(subWave.unit, pos, rot); UnitCreep unit = obj.GetComponent <UnitCreep>(); if (subWave.overrideShield > 0) { unit.defaultShield = subWave.overrideShield; } if (subWave.overrideMoveSpd > 0) { unit.moveSpeed = subWave.overrideMoveSpd; } unit.Init(path, totalSpawnCount, parentWave.waveID); totalSpawnCount += 1; activeUnitCount += 1; parentWave.activeUnitCount += 1; spawnCount += 1; if (spawnCount == subWave.count) { break; } yield return(new WaitForSeconds(subWave.interval)); } parentWave.subWaveSpawnedCount += 1; if (parentWave.subWaveSpawnedCount == parentWave.subWaveList.Count) { parentWave.spawned = true; spawning = false; //Debug.Log("wave "+(parentWave.waveID+1)+" has done spawning"); yield return(new WaitForSeconds(0.5f)); if (currentWaveID <= waveList.Count - 2) { //for UI to show spawn button again if (spawnMode == _SpawnMode.Continous && allowSkip && onEnableSpawnE != null) { onEnableSpawnE(); } if (spawnMode == _SpawnMode.WaveCleared && allowSkip && onEnableSpawnE != null) { onEnableSpawnE(); } } } }
public void Shoot(AttackInstance attInst = null, Transform sp = null) { if (attInst.tgtUnit == null || attInst.tgtUnit.GetTargetT() == null) { ObjectPoolManager.Unspawn(thisObj); return; } attInstance = attInst; target = attInstance.tgtUnit; //print(attInstance.srcUnit.unitName + " attacks " + attInstance.tgtUnit.unitName + " with " + attInstance.damage + " damage"); targetPos = target.GetTargetT().position; #if Game_2D hitThreshold = Mathf.Max(.01f, target.hitThreshold); #else hitThreshold = Mathf.Max(.1f, target.hitThreshold); #endif shootPoint = sp; if (shootPoint != null) { thisT.rotation = shootPoint.rotation; } if (shootEffect != null && !target.dead) { GameObject shootEffectInstance = ObjectPoolManager.Spawn(shootEffect, thisT.position, thisT.rotation); if (shootEffectInstance) { effectSetting = shootEffectInstance.GetComponent <EffectSettings>(); if (effectSetting == null) { effectSetting = shootEffectInstance.GetComponentInChildren <EffectSettings>(); } if (effectSetting) { if (effectSetting.EffectType == EffectSettings.EffectTypeEnum.Other) { Vector3 direction = (targetPos - thisT.position).normalized; shootEffectInstance.transform.rotation = Quaternion.LookRotation(direction); } effectSetting.Target = target.GetTargetT().gameObject; SelfDeactivator selfDeactivator = shootEffectInstance.GetComponent <SelfDeactivator>(); if (selfDeactivator == null) { selfDeactivator = shootEffectInstance.AddComponent <SelfDeactivator>(); } selfDeactivator.duration = attInstance.srcUnit.CurrentStat.cooldown; } } Unit.onDestroyedE += OnTargetDestroy; } hit = false; if (Ab_Start_Holder) { AbilityManager.instance.ActivateAbility(Ab_Start_Holder.ability, attInstance.srcUnit, targetPos, target); } if (type == _ShootObjectType.Projectile) { StartCoroutine(ProjectileRoutine()); } else if (type == _ShootObjectType.Beam) { StartCoroutine(BeamRoutine()); } else if (type == _ShootObjectType.Missile) { StartCoroutine(MissileRoutine()); } else if (type == _ShootObjectType.Effect && EffectDelay > 0) { StartCoroutine(EffectRoutine()); } else { Hit(); } }
IEnumerator _ReachDestination(float duration) { yield return(new WaitForSeconds(duration)); ObjectPoolManager.Unspawn(thisObj); }