private void Awake() { this.projectileController = base.GetComponent <ProjectileController>(); this.projectileDamage = base.GetComponent <ProjectileDamage>(); this.stopwatch = this.maxCoefficient; Debug.LogWarning($"start stopwatch: {this.stopwatch}"); }
void OnCollisionEnter2D(Collision2D collision) { ProjectileController projectile = collision.gameObject.GetComponent <ProjectileController> (); if (projectile && projectile.gameObject.tag == "Projectile") { health -= projectile.projectileDamage; projectile.Hit(health, gameObject); } // the impulse is taken from health for damage if (collision.gameObject.tag == "Projectile" || collision.gameObject.tag == "Vessel" || collision.gameObject.tag == "Scenery") { health -= collision.relativeVelocity.magnitude * collision.gameObject.GetComponent <Rigidbody2D>().mass / 20; } if (health <= 0f) { Die(); } if (collision.gameObject.tag == "CivWp") { Destroy(collision.gameObject); } }
//applies kinetic effects private void ApplyKinetics(ProjectileController controller) { for (int i = 0; i < 3; i++) { switch (currentSpell.spellKinetics [i]) { case -1: break; case 0: controller.LatchingKinetic(); break; case 1: controller.BlockingKinetic(); break; case 2: controller.EtherealKinetic(); break; case 3: controller.GuidedKinetic(); break; case 4: controller.PiercingKinetic(); break; case 5: controller.ReboundingKinetic(); break; case 6: controller.SeekingKinetic(); break; case 7: controller.ChainingKinetic(); break; } } }
private void OnTriggerEnter2D(Collider2D collision) { switch (collision.gameObject.tag) { case "Projectile": ProjectileController projectile = collision.gameObject.GetComponent <ProjectileController>(); if (projectile.GetOwnerID() == photonView.Owner.UserId) { return; } if (!photonView.IsMine) { collision.gameObject.SetActive(false); } else { photonView.RPC("RPCSetDamage", RpcTarget.All, projectile.damage); // collision.gameObject.GetPhotonView().InstantiationId, projectile.damage); } break; case "Collectible": CollectItem(collision.gameObject); break; default: break; } }
void Update() { GameObject blackBall = GameObject.Find("BlackBall"); if (blackBall != null && GameMaster.levelReady) { ProjectileController blackBallScript = blackBall.GetComponent <ProjectileController>(); if (blackBallScript.neighbours.Count == 0) { GameMaster.levelReady = false; stopBalls(); changeLevel(); } } //Debug to finish level if (Input.GetKey(KeyCode.Keypad3) && GameMaster.levelReady) { GameMaster.levelReady = false; stopBalls(); changeLevel(); } //Debug colors if (Input.GetKey(KeyCode.Keypad2)) { ColorManager.checkAvailableColor(); } }
private void PlayerCombat() { if (Input.GetMouseButtonDown(0)) { isCasting = true; } if (Input.GetMouseButtonUp(0)) { isCasting = false; } if (!isCasting) { timeBetweenCasts = 0; } else { timeBetweenCasts -= Time.deltaTime; if (timeBetweenCasts <= 0) { timeBetweenCasts = projCastSpeed; ProjectileController newProjectile = Instantiate(projectile, castFromPoint.position, castFromPoint.rotation) as ProjectileController; newProjectile.speed = projTravelSpeed; } } }
private void OnTriggerEnter2D(Collider2D collider) { TeamAssigner teamAssigner = collider.GetComponent <TeamAssigner>(); ProjectileController projectile = collider.GetComponent <ProjectileController>(); if (projectile != null) { if (projectile.firingTeam != firingTeam) { Destroy(projectile.gameObject); Destroy(gameObject); return; } } if (collider.isTrigger || teamAssigner != null && firingTeam == teamAssigner.team) { return; } else { HealthTracker healthTracker = collider.GetComponent <HealthTracker>(); if (healthTracker != null) { healthTracker.TakeDamage(weaponInfo.damage); } Destroy(gameObject); } }
private void ClearNearbyProjectiles() { float num = cfgHoustonRadius.Value; float num2 = num * num; List <ProjectileController> instancesList = InstanceTracker.GetInstancesList <ProjectileController>(); List <ProjectileController> list = new List <ProjectileController>(); int i = 0; int count = instancesList.Count; while (i < count) { ProjectileController projectileController = instancesList[i]; if (projectileController.teamFilter.teamIndex != teamIndex && (projectileController.transform.position - characterMaster.GetBody().corePosition).sqrMagnitude < num2) { list.Add(projectileController); } i++; } int j = 0; int count2 = list.Count; while (j < count2) { ProjectileController projectileController2 = list[j]; if (projectileController2) { UnityEngine.Object.Destroy(projectileController2.gameObject); } j++; } }
private void FireballAttack() { int numberProjectile = PlayerCharacteristics.GetValue(PowerShape.Type.FIRE_BALL_UP1) ? 3 : 1; for (int i = 0; i < numberProjectile; i++) { // Generate fireball GameObject fireball = Instantiate(fireballModel); fireball.transform.position = fireballOrigins[i].position; fireball.transform.right = fireballOrigins[i].right; fireball.transform.SetParent(objects.transform); ProjectileController projectileController = fireball.GetComponent <ProjectileController>(); projectileController.Shoot(fireball.transform.up, gameObject.tag, GameParameters.fireballSpeed, damage); CircleCollider2D fireballCollider = fireball.GetComponent <CircleCollider2D>(); // Ignore collision between the player and the fireball (trigger ok) Physics2D.IgnoreCollision(mainCollider, fireballCollider); if (rockshield.Count > 0) { IgnoreCollisionWithRockShield(fireballCollider); } if (airshield != null) { IgnoreCollisionWithAirShield(fireballCollider); } } }
private void FireServer(Ray aimRay, float scale) { FireProjectileInfo fireProjectileInfo = new FireProjectileInfo { projectilePrefab = Projectiles.yokoPiercingRoundPrefab, position = aimRay.origin, rotation = Util.QuaternionSafeLookRotation(aimRay.direction), owner = base.gameObject, damage = YokoPiercingRifle.damageCoefficient * this.damageStat * scale, force = 100f, crit = base.RollCrit(), damageColorIndex = DamageColorIndex.Default, target = null, speedOverride = YokoPiercingRifle.throwForce, fuseOverride = -1f, damageTypeOverride = null }; GameObject gameObject = UnityEngine.Object.Instantiate <GameObject>(fireProjectileInfo.projectilePrefab, fireProjectileInfo.position, fireProjectileInfo.rotation); ProjectileController component = gameObject.GetComponent <ProjectileController>(); component.NetworkpredictionId = 0; ProjectileManager.InitializeProjectile(component, fireProjectileInfo); var scaleProjectileController = gameObject.GetComponent <ScaleProjectileController>(); scaleProjectileController.NetworkChargeRate = scale; NetworkServer.Spawn(gameObject); }
void OnCollisionEnter(Collision collider) { // when something collides with our ship, we check its layer to see if it is a projectile // (Note: remember when you add projectiles to set the layers correctly!) // by default, we're using layer 17 for projectiles fired by enemies and layer 9 for projectiles fired // by the main player but all we need to know here is that it *is* a projectile of any type if (!isRespawning && !isInvulnerable) // make sure no respawning or invulnerability is happening { // temp ref to this collider's gameobject so that we don't need to keep looking it up tempGO = collider.gameObject; // do a quick layer check to make sure that these are in fact projectiles if (tempGO.layer == 17 || tempGO.layer == 9) { // grab a ref to the projectile's controller aProj = tempGO.GetComponent <ProjectileController>(); // quick check to make sure that this projectile was not launched by this player if (aProj.ownerType_id != id) { // tell the hit function about this collision, passing in the gameobject so that we can // get to its projectile controller script and find out more about where it came from Hit(); // tell our battle controller that we got hit battleControl.Fragged(); // tell the global battle controller who fragged us GlobalBattleManager.Instance.RegisterFrag(aProj.ownerType_id); } } } }
protected override void LoadUpProjectile(ProjectileController projectileController) { base.LoadUpProjectile(projectileController); RocketProjectileController rocketController = projectileController as RocketProjectileController; rocketController.correctionPower = correctionPower; }
private void Start() { this.projectileController = base.GetComponent <ProjectileController>(); this.projectileDamage = base.GetComponent <ProjectileDamage>(); this.ResetOverlap(); }
// Token: 0x060015D7 RID: 5591 RVA: 0x0005D1FC File Offset: 0x0005B3FC private Transform FindAttachmentTransform() { this.projectileGhostController = base.GetComponent <ProjectileGhostController>(); if (this.projectileGhostController) { Transform authorityTransform = this.projectileGhostController.authorityTransform; if (authorityTransform) { ProjectileController component = authorityTransform.GetComponent <ProjectileController>(); if (component) { GameObject owner = component.owner; if (owner) { ModelLocator component2 = owner.GetComponent <ModelLocator>(); if (component2) { Transform modelTransform = component2.modelTransform; if (modelTransform) { ChildLocator component3 = modelTransform.GetComponent <ChildLocator>(); if (component3) { return(component3.FindChild(this.attachmentString)); } } } } } } } return(null); }
public virtual Transform MakeProjectile(int ownerID) { // create a projectile theProjectile = SpawnController.Instance.Spawn(projectileGO, myTransform.position + spawnPosOffset + (myTransform.forward * launchForwardOffset), myTransform.rotation); theProjectileGO = theProjectile.gameObject; theProjectileGO.layer = myLayer; // grab a ref to the projectile's controller so we can pass on some information about it theProjectileController = theProjectileGO.GetComponent <ProjectileController>(); // set owner ID so we know who sent it theProjectileController.SetOwnerType(ownerID); Physics.IgnoreLayerCollision(myTransform.gameObject.layer, myLayer); // NOTE: Make sure that the parentCollider is a collision mesh which represents the firing object // or a collision mesh likely to be hit by a projectile as it is being fired from the vehicle. // One limitation with this system is that it only reliably supports a single collision mesh if (parentCollider != null) { // disable collision between 'us' and our projectile so as not to hit ourselves with it! Physics.IgnoreCollision(theProjectile.GetComponent <Collider>(), parentCollider); } // return this projectile incase we want to do something else to it return(theProjectile); }
// Fires the Weapon public void Fire() { CurrentAmmo -= 1; _timeBtwShots = Weapon.FireRate; // Fire Effect Instantiate(FireEffect, ShotPoint.position, ShotPoint.rotation); // Recoiling the weapon if (Weapon.HasRecoil) { WeaponRecoiler.AddRecoil(); } //Sound effect SoundManager.PlaySound(Weapon.FireSound, transform.position); // Creating bullets for (int i = 0; i < Weapon.BulletPerShot; i++) { float angelBtwBullets = 10f; float zRotation = ((1 - Weapon.BulletPerShot) * angelBtwBullets / 2) + (angelBtwBullets * i); ProjectileController bullet = Instantiate(Weapon.Bullet, ShotPoint.position, Quaternion.Euler(new Vector3(0, 0, ShotPoint.rotation.eulerAngles.z + zRotation))); bullet.ShotByPlayer = (transform.root.tag == "Player"); } }
//On collision with another ball void OnTriggerEnter(Collider other) { //Adds colliding ball to neighbour list. Second condition is to prevent blackBall from having grey neighbours if (other.tag == "BigBall" && !(gameObject.name == "BlackBall" && other.gameObject.renderer.material.color == Color.grey)) { neighbours.Add(other.gameObject); } //If other target is smallBall ->destroy the smallBall if (other.tag == "SmallBall" && !other.transform.IsChildOf(transform) && this.tag != "MagazinedBall" && this.tag != "Floater") { //Rotate cluster according to impact Vector3 deltaVec = other.transform.position - blackBall.transform.position; Vector3 rotateAxis = Vector3.Cross(deltaVec, direction); Vector3 sumVec = deltaVec + direction; Vector3 ortogVec = Vector3.Cross(rotateAxis, deltaVec); float rotSpeed = Vector3.Dot(ortogVec, sumVec); ClusterController clustCon = Camera.main.GetComponent <ClusterController>(); clustCon.setVectors(rotSpeed * 30, rotateAxis); //Destroy the projectile's smallball GameObject smallBall = other.gameObject; GameObject projectile = smallBall.transform.parent.gameObject; ProjectileController projectileScript = projectile.GetComponent <ProjectileController>(); projectileScript.collided = true; Destroy(smallBall); } if (other.tag == "Perimeter") { insidePerimeter = true; } }
public override void OnSkillLeveledUp(int level, CharacterBody characterBody, SkillDef skillDef) { base.OnSkillLeveledUp(level, characterBody, skillDef); var capedLevel = Math.Min(25, level); var shadesWhirlPrefab = Projectiles.shadesWhirlPrefab; if (shadesWhirlPrefab) { var projectileDotZone = shadesWhirlPrefab.GetComponent <ProjectileDotZone>(); if (projectileDotZone) { projectileDotZone.damageCoefficient = AdditiveScaling(0.10f, 0.02f, capedLevel); // increase Dot damage by 20% every level (linear) } ProjectileController projectileController = shadesWhirlPrefab.GetComponent <ProjectileController>(); if (projectileController) { projectileController.ghostPrefab.transform.localScale = Vector3.one * AdditiveScaling(4.0f, 0.6f, capedLevel);// increase shades size by 15% every level (linear) } var hitbox = shadesWhirlPrefab.GetComponentInChildren <HitBox>(); if (hitbox) { hitbox.transform.localScale = new Vector3(8.0f, 3.0f, 8.0f) * AdditiveScaling(1.0f, 0.15f, capedLevel); } } }
protected void FireChild(Vector3 direction) { GameObject gameObject = UnityEngine.Object.Instantiate <GameObject>(this.childrenProjectilePrefab, base.transform.position, Util.QuaternionSafeLookRotation(direction)); ProjectileController component = gameObject.GetComponent <ProjectileController>(); if (component) { component.procChainMask = this.projectileController.procChainMask; component.procCoefficient = this.projectileController.procCoefficient; component.Networkowner = this.projectileController.owner; } gameObject.GetComponent <TeamFilter>().teamIndex = base.GetComponent <TeamFilter>().teamIndex; ProjectileDamage component2 = gameObject.GetComponent <ProjectileDamage>(); if (component2) { component2.damage = this.projectileDamage.damage * this.childrenDamageCoefficient; component2.crit = this.projectileDamage.crit; component2.force = this.projectileDamage.force; component2.damageColorIndex = this.projectileDamage.damageColorIndex; } if (gameObject.GetComponent <ProjectileStickOnImpact>() != null) { ProjectileStickOnImpact stickComponent = gameObject.GetComponent <ProjectileStickOnImpact>(); stickComponent.TrySticking(hitEnemyCollider, hitEnemyInfo.estimatedImpactNormal); } NetworkServer.Spawn(gameObject); }
private static void CreateVoidBlast() { voidBlastPrefab = CloneProjectilePrefab("CommandoGrenadeProjectile", "NemryVoidBlastProjectile"); ProjectileImpactExplosion bombImpactExplosion = voidBlastPrefab.GetComponent <ProjectileImpactExplosion>(); InitializeImpactExplosion(bombImpactExplosion); bombImpactExplosion.blastRadius = 8f; bombImpactExplosion.destroyOnEnemy = true; bombImpactExplosion.lifetime = 12f; bombImpactExplosion.impactEffect = Resources.Load <GameObject>("Prefabs/Effects/NullifierExplosion"); //bombImpactExplosion.lifetimeExpiredSound = Modules.Assets.CreateNetworkSoundEventDef("HenryBombExplosion"); bombImpactExplosion.timerAfterImpact = true; bombImpactExplosion.lifetimeAfterImpact = 0.1f; ProjectileDamage bombDamage = voidBlastPrefab.GetComponent <ProjectileDamage>(); bombDamage.damageType = DamageType.Nullify; ProjectileController bombController = voidBlastPrefab.GetComponent <ProjectileController>(); bombController.ghostPrefab = Resources.Load <GameObject>("Prefabs/ProjectileGhosts/NullifierPreBombGhost"); bombController.startSound = ""; voidBlastPrefab.GetComponent <Rigidbody>().useGravity = false; }
private void OnTriggerEnter(Collider other) { other.GetComponent <TeamFilter>(); Rigidbody component = other.GetComponent <Rigidbody>(); ProjectileController component2 = other.GetComponent <ProjectileController>(); ProjectileDamage component3 = other.GetComponent <ProjectileDamage>(); if (component && !ReflectedProjectileTracker.rigidBodies.Contains(component) && component2 && component3) { if (component2.teamFilter.teamIndex != teamFilter.teamIndex) { component2.teamFilter.teamIndex = teamFilter.teamIndex; if (component2.owner) { component.rotation = Util.QuaternionSafeLookRotation(component2.owner.transform.position - component.position); } } component2.procCoefficient = 0; var tracker = component2.gameObject.AddComponent <ReflectedProjectileTracker>(); tracker.rigidBody = component; ProjectileManager.instance.FireProjectile(other.gameObject, other.transform.position, Util.QuaternionSafeLookRotation(component2.owner.transform.position - component.position), component2.owner, damageMultiplier, component3.force, component3.crit, component3.damageColorIndex, component2.owner); Destroy(other.gameObject); } }
private static void CreateBazookaRocket() { bazookaRocketPrefab = CloneProjectilePrefab("CommandoGrenadeProjectile", "HenryBazookaRocketProjectile"); bazookaRocketPrefab.AddComponent <Modules.Components.BazookaRotation>(); bazookaRocketPrefab.transform.localScale *= 2f; ProjectileImpactExplosion bazookaImpactExplosion = bazookaRocketPrefab.GetComponent <ProjectileImpactExplosion>(); InitializeImpactExplosion(bazookaImpactExplosion); bazookaImpactExplosion.blastRadius = 8f; bazookaImpactExplosion.destroyOnEnemy = true; bazookaImpactExplosion.lifetime = 12f; bazookaImpactExplosion.impactEffect = Modules.Assets.bazookaExplosionEffect; //bazookaImpactExplosion.lifetimeExpiredSound = Modules.Assets.CreateNetworkSoundEventDef("HenryBazookaExplosion"); bazookaImpactExplosion.timerAfterImpact = true; bazookaImpactExplosion.lifetimeAfterImpact = 0f; ProjectileController bazookaController = bazookaRocketPrefab.GetComponent <ProjectileController>(); GameObject bazookaGhost = CreateGhostPrefab("HenryBazookaRocketGhost"); bazookaGhost.GetComponentInChildren <ParticleSystem>().gameObject.AddComponent <Modules.Components.DetachOnDestroy>(); bazookaController.ghostPrefab = bazookaGhost; bazookaController.startSound = ""; }
protected override void Fire() { float face = (float)characterMotor.FaceDirection; foreach (var fireStyle in fireStyles) { ProjectileController projectileController = projectileType.Get <ProjectileController>(); fireOffset = fireStyle.offset; fireRotation = fireStyle.rotation; LoadUpProjectile(projectileController); float rad = fireStyle.direction * Mathf.Deg2Rad; Vector3 velocity = new Vector3(Mathf.Cos(rad) * face, Mathf.Sin(rad), 0).normalized *firePower; projectileController.Fire(velocity); } if (attackSound) { _audioSource.PlayOneShot(attackSound.Source); } if (fireShake != Vector3.zero) { CameraManager.Shake(transform.position, fireShake); } if (fireEffect) { BurstParticleController explosion = fireEffect.Get <BurstParticleController>(); explosion.transform.position = transform.position + new Vector3(transform.lossyScale.x / 2f, 0, 0); explosion.Burst(); } }
/* * For the most part this is very similar to the Shoot() coroutine in my GunController. I should * work to combine these ideas into a more generic "Shootable" interface (maybe Fireable? shootable * sort of implies that it's being hit by the shot) */ void Shoot() { if (target == null) { Debug.LogError("Error: No target for this EnemyShooter Shoot method."); } canShoot = false; GameObject thisShot = (GameObject)Instantiate(projectilePrefab, transform.position + new Vector3(0f, -1.5f, 0f), transform.rotation); ProjectileController shotController = thisShot.GetComponent <ProjectileController> (); shotController.spawnerTag = gameObject.tag; shotController.speed = shotSpeed; shotController.shotDamage = shotDamage; shotController.gameObject.transform.LookAt(target.gameObject.transform); // right now this won't work as the shot isn't rotated to face the player shotController.GetComponent <Rigidbody> ().velocity = shotController.transform.forward * shotController.speed; /* * shotController.GetComponent<Rigidbody> ().velocity = * Vector3.down * shotController.speed; */ Invoke("ResetShoot", shootDelay); }
public void Render() { TowerController.Render(); EnemyController.Render(); ProjectileController.Render(); Statistics.Render(); }
// Use this for initialization void Start() { this.currentWeapon = 0; this.SwitchWeapons(); projectiles = GetComponent <ProjectileController>(); }
public IEnumerator Enemy_BatHealthOnImpact3() { NetworkServer.Listen(7777); Instantiate(Resources.Load("Tests/maincanvas")); Instantiate(Resources.Load("Tests/maincamera")); Instantiate(Resources.Load("Tests/gamemanager")); GameObject enemyBat = Instantiate(Resources.Load("Tests/Enemy_Bat 1")) as GameObject; GameObject projectile = Instantiate(Resources.Load("Tests/FireballProjectile1")) as GameObject; enemyBat.transform.position = new Vector2(0, 0); projectile.transform.position = new Vector2(5, 0); ProjectileController pc = projectile.GetComponent <ProjectileController> (); pc.setVelocityAndRotation(new Vector2(-4, 0), 0); int startHp = enemyBat.GetComponentInChildren <Enemy> ().hp; int damage = startHp - 1; pc.projectileDamage = damage; yield return(new WaitForSeconds(5)); GameObject[] spawnedEnemyBatList = GameObject.FindGameObjectsWithTag("Enemy"); GameObject spawnedEnemyBat = spawnedEnemyBatList[0]; Enemy enemyScript = spawnedEnemyBat.GetComponent <Enemy>(); int expectedhealth = startHp - damage; Assert.AreEqual(expectedhealth, enemyScript.hp); }
private void OnTriggerEnter2D(Collider2D otherCollider) { ProjectileController projectile = null; int destructionLevel = CONSTRUCTION_LEVEL_INVALID; //Debug.Log("Debug : ObstacleController : on trigger enter."); if (otherCollider.gameObject != null) { projectile = otherCollider.gameObject.GetComponent <ProjectileController>(); if (projectile != null) { destructionLevel = projectile.GetDestructionLevel(); if ((destructionLevel != CONSTRUCTION_LEVEL_INVALID) && (destructionLevel >= constructionLevel)) { /*halmeida - in this case, the projectile may affect the obstacle.*/ if (projectile.GetEffectCode() == ProjectileController.EFFECT_CODE_HP_DAMAGE) { DamageObstacle(projectile.GetEffectIntensity(), otherCollider.gameObject); } else if (projectile.GetEffectCode() == ProjectileController.EFFECT_CODE_HP_RECOVERY) { DamageObstacle(projectile.GetEffectIntensity() * -1f, otherCollider.gameObject); } } projectile.Deactivate(); } } }
// Token: 0x06001854 RID: 6228 RVA: 0x00069274 File Offset: 0x00067474 private static void SetProjectilePrefabs(GameObject[] newProjectilePrefabs) { ProjectileCatalog.projectilePrefabs = HGArrayUtilities.Clone <GameObject>(newProjectilePrefabs); int num = 256; if (ProjectileCatalog.projectilePrefabs.Length > num) { Debug.LogErrorFormat("Cannot have more than {0} projectile prefabs defined, which is over the limit for {1}. Check comments at error source for details.", new object[] { num, typeof(byte).Name }); for (int i = num; i < ProjectileCatalog.projectilePrefabs.Length; i++) { Debug.LogErrorFormat("Could not register projectile [{0}/{1}]=\"{2}\"", new object[] { i, num - 1, ProjectileCatalog.projectilePrefabs[i].name }); } } ProjectileCatalog.projectilePrefabProjectileControllerComponents = new ProjectileController[ProjectileCatalog.projectilePrefabs.Length]; ProjectileCatalog.projectileNames = new string[ProjectileCatalog.projectilePrefabs.Length]; for (int j = 0; j < ProjectileCatalog.projectilePrefabs.Length; j++) { GameObject gameObject = ProjectileCatalog.projectilePrefabs[j]; ProjectileController component = gameObject.GetComponent <ProjectileController>(); component.catalogIndex = j; ProjectileCatalog.projectilePrefabProjectileControllerComponents[j] = component; ProjectileCatalog.projectileNames[j] = gameObject.name; } }
public IEnumerator Enemy_BatDestroyOnImpact3() { NetworkServer.Listen(7777); Instantiate(Resources.Load("Tests/maincanvas")); Instantiate(Resources.Load("Tests/maincamera")); Instantiate(Resources.Load("Tests/gamemanager")); GameObject enemyBat = Instantiate(Resources.Load("Tests/Enemy_Bat 1")) as GameObject; enemyBat.transform.position = new Vector2(0, 0); GameObject demoprojectile = Instantiate(Resources.Load("Tests/FireballProjectile1")) as GameObject; int starthealth = enemyBat.GetComponentInChildren <Enemy> ().hp; int damage = demoprojectile.GetComponent <ProjectileController> ().getProjectileDamage(); int count = starthealth / damage; for (int i = 0; i < count - 1; i++) { GameObject projectile = Instantiate(Resources.Load("Tests/FireballProjectile1")) as GameObject; projectile.transform.position = new Vector2(5, 0); ProjectileController pc = projectile.GetComponent <ProjectileController> (); pc.setVelocityAndRotation(new Vector2(-4, 0), 0); //projectile [i] = projectile; } yield return(new WaitForSeconds(5)); Assert.AreEqual((GameObject.FindGameObjectsWithTag("Enemy")).Length, 1); }
public void handleProjectileHit(ProjectileController projectile) { if (projectile.Owner == GameplayManager.Samus && m_invincibilityCounter <= 0) { GameplayManager.Samus.model.setStat("damageDone", GameplayManager.Samus.model.getStat("damageDone") + projectile.Damage); handleSamusProjectileHit(projectile); } }
protected override void handleSamusProjectileHit(ProjectileController projectile) { projectile.handleSceneryHit(); if (projectile.Freezes) { this.m_frozenCounter = s_frozenDuration; this.m_collider.m_type = ColliderType.FrozenEnemy; this.m_invincibilityCounter = s_invincibilityDuration; } }
protected virtual void handleSamusProjectileHit(ProjectileController projectile) { projectile.handleSceneryHit(); if (projectile.Freezes && this.Health <= this.MaxHealth / 2 && !this.IsFrozen) { this.m_frozenCounter = s_frozenDuration; this.m_collider.m_type = ColliderType.FrozenEnemy; this.m_invincibilityCounter = s_invincibilityDuration; } else { this.takeDamage(projectile.Damage); if (this.Health <= 0) { Vector2 explosion = new Vector2( m_position.X, m_position.Y - (float)m_collider.Bounds.Height / 2); GameplayManager.ActiveZone.add(new BulletExplosion(explosion, 8.0f)); } } }
private void UpgradeProjectile(ProjectileController projectile, WeaponType weaponType) { if (GetWeaponRank(weaponType) < 5) { projectile.Damage *= 1.25f; } else if (GetWeaponRank(weaponType) < 10) { projectile.Damage *= 1.15f; } else { projectile.Damage *= 1.05f; } ObjectChaser chaser = projectile.GetComponent<ObjectChaser>(); if (chaser != null) { //increase weapon stats if (GetWeaponRank(weaponType) < 5) { chaser.Delay /= 1.25f; chaser.Precision *= 1.25f; } else if (GetWeaponRank(weaponType) < 10) { chaser.Delay /= 1.15f; chaser.Precision *= 1.15f; } else { chaser.Delay /= 1.05f; chaser.Precision *= 1.05f; } } }
public override void LoadContent() { ContentManager content = ScreenManager.Game.Content; map = content.Load<Map>("map"); MapGeneration.Generate(map); camera = new Camera(ScreenManager.Game.RenderWidth, ScreenManager.Game.RenderHeight, map); //camera.Zoom = 0.5f; text = content.Load<Texture2D>("titles"); hud = new HUD(content.Load<Texture2D>("hud")); waterLevel = ScreenManager.Game.RenderHeight; waterParallax = new Parallax(content.Load<Texture2D>("abovewater-parallax"), 12, 0.5f, waterLevel, (map.TileWidth * map.Width), new Viewport(0, 0, ScreenManager.Game.RenderWidth, ScreenManager.Game.RenderHeight), false, true); underwaterBGParallax = new Parallax(content.Load<Texture2D>("underwater-bg"), 4, 1f, waterLevel + 20, (map.TileWidth * map.Width), new Viewport(0, 0, ScreenManager.Game.RenderWidth, ScreenManager.Game.RenderHeight), true, false); skyBGParallax = new Parallax(content.Load<Texture2D>("sky-bg"), 72, 1f, 70, (map.TileWidth * map.Width), new Viewport(0, 0, ScreenManager.Game.RenderWidth, ScreenManager.Game.RenderHeight), false, false); rocksParallax = new Parallax(content.Load<Texture2D>("seabed-rocks"), 16, 0.35f, (map.TileHeight*map.Height) -15, (map.TileWidth * map.Width), new Viewport(0, 0, ScreenManager.Game.RenderWidth, ScreenManager.Game.RenderHeight), false, false); cloudsParallax = new Parallax(content.Load<Texture2D>("clouds"), 16, 0.35f, 25, (map.TileWidth * map.Width), new Viewport(0, 0, ScreenManager.Game.RenderWidth, ScreenManager.Game.RenderHeight), false, false, true); playerShip = new Ship(content.Load<Texture2D>("playership"), new Rectangle(0,0,10,10), null, Vector2.Zero); playerShip.Position = new Vector2(64, 190); particleController.LoadContent(content); projectileController = new ProjectileController(1000, sheet => new Projectile(sheet, new Rectangle(0, 0, 4, 4), null, new Vector2(0, 0)) , content.Load<Texture2D>("projectiles")); enemyController = new EnemyController(content.Load<Texture2D>("enemies"), content.Load<Texture2D>("boss")); powerupController = new PowerupController(1000,sheet => new Powerup(sheet, new Rectangle(0, 0, 6, 6), null, Vector2.Zero),content.Load<Texture2D>("powerup")); powerupController.BoxCollidesWith.Add(playerShip); projectileController.BoxCollidesWith.Add(playerShip); projectileController.BoxCollidesWith.Add(enemyController); projectileController.BoxCollidesWith.Add(projectileController); enemyController.BoxCollidesWith.Add(playerShip); enemyController.BoxCollidesWith.Add(projectileController); GameController.Reset(); //enemyController.SpawnInitial(GameController.Wave, map); base.LoadContent(); }
// Use this for initialization void Start () { this.currentWeapon = 0; this.SwitchWeapons(); projectiles = GetComponent<ProjectileController>(); }
public void handleProjectileHit(ProjectileController projectile) { m_state = State.ItemRevealed; m_collider.m_type = ColliderType.Trigger; }
protected override void handleSamusProjectileHit(ProjectileController projectile) { this.takeDamage(projectile.Damage); if (this.Health % 3 == 1) { changeState(State.Open); } }
private void fireSpike(int spikeIdx) { Vector2 shootPoint = AnimationController.getShootPoint(this.DrawPosition); shootPoint += getSpikeOffset(spikeIdx); ProjectileController spike = new ProjectileController( this, shootPoint, new Vector2(m_facingRight ? c_spikeSpeed : -c_spikeSpeed, 0), ProjectileType.Spike, 30, c_SpikeTexturePath); GameplayManager.ActiveZone.add(spike); }
private void UpgradeWeapons(int iterationCount, ProjectileController projectilePrefab, WeaponType weaponType) { //upgrade weapons and projectiles for each upgrade point for (int i = 0; i < iterationCount; i++) { //increase stats of projectile prefab UpgradeProjectile(projectilePrefab, weaponType); foreach (WeaponController weapon in player.GetWeapons()) { if (weapon.GetWeaponType() == weaponType) { //increase weapon stats if (GetWeaponRank(weaponType) < 5) { weapon.Interval /= 1.25f; } else if (GetWeaponRank(weaponType) < 10) { weapon.Interval /= 1.15f; } else { weapon.Interval /= 1.05f; } ObjectPooler pooler = weapon.GetComponent<ObjectPooler>(); if (pooler != null) { //increase stats of pooled projectiles foreach (GameObject obj in pooler.GetPooledObjects()) { ProjectileController projectile = obj.GetComponent<ProjectileController>(); UpgradeProjectile(projectile, weaponType); } } } } } }
void Update() { if(Input.GetKey(KeyCode.Keypad9)){ freeView = true; } if(Input.GetKey(KeyCode.Keypad7)){ freeView = false; } time += Time.deltaTime; if(!GameMaster.hasWon && !GameMaster.levelComplete && !GameMaster.hasLost && Time.timeScale == 1.0f){ positionSelected = new Vector3(-1,-1,-1); foreach (Touch touch in Input.touches) { if (touch.phase == TouchPhase.Began) { positionSelected = touch.position; } } if (Input.GetButtonDown("Fire1") && positionSelected==new Vector3(-1,-1,-1)) { positionSelected = Input.mousePosition; } if(freeView){ }else{ if(positionSelected != new Vector3(-1,-1,-1) && weaponReady){ Ray ray = Camera.main.ScreenPointToRay (positionSelected); RaycastHit hit; if (Physics.Raycast(Camera.main.transform.position, ray.direction, out hit) && raycastMagazinedBalls(hit.transform)){ swapBall(); }else if(positionSelected[0] <130 && positionSelected[1] <260){ //Stop from shooting when clicking bomb powerup icon. Values are by trial and error }else{ //Shoots //Sets bomb model and bomb collider size if(balls[0].name=="Bomb"){ float radius = (float)GameMaster.upgrades["BombSize"]/20; (balls[0].gameObject.collider as SphereCollider).radius = radius; Transform bombModel = balls[0].FindChild("Bomb(Clone)"); float size = (float)GameMaster.upgrades["BombSize"]/10; bombModel.transform.localScale = new Vector3(size,size,size); } //Count a freeView powerup used if(freeViewUsedThisRound){ freeViewUsedThisRound = false; GameMaster.upgrades["FreeView"]--; } controllerScript = balls[0].GetComponent<ProjectileController>(); balls[0].transform.localPosition = new Vector3(0,0,0); balls[0].transform.rotation = transform.rotation; balls[0].transform.parent = null; controllerScript.StartMove(ray.direction); balls[0].tag = "BigBall"; weaponReady = false; time = 0; EventManager.ObjectFired(balls[0].name); //Set balls[0] variable to null so a new ball can be loaded balls[0] = null; } } } } /*if(Input.GetKey(KeyCode.Keypad2)){ balls[0].renderer.material.color = Color.blue; magazinedBall.renderer.material.color = Color.blue; }*/ }