public override void Initalize(BulletController controller)
{
updateController(controller);
explosion = controller.GetComponentInChildren<AutoExplosion>();
target = enemy.transform;
m_startPosition = bulletController.gameObject.transform.localPosition;
// tinh khoang cach giua vien dan va muc tieu
m_fX = bulletController.gameObject.transform.InverseTransformPoint(target.position).x;
if (m_fX >= 0 && m_fX < 5)
{
m_fX = 5;
}
else if(m_fX < 0 && m_fX > -5)
{
m_fX = -5;
}
m_fY = bulletController.gameObject.transform.InverseTransformPoint(target.position).y;
calculatorByTime(calculatorByVelocity(Random.Range(55, 60)));
//canCollision = false;
}
void Start()
{
transform.localPosition = transform.parent.InverseTransformPoint(transform.position);
bulletController = this.GetComponent<BulletController>();
bulletController.ATK = UnityEngine.Random.Range(towerController.attribute.MinATK
+ towerController.Bonus.ATK, towerController.attribute.MaxATK + towerController.Bonus.ATK);
this.enemy = towerAction.enemy;
switch (towerController.chaseType)
{
case EBulletChaseType.CHASE:
bulletTemplate = new BulletChase();
break;
case EBulletChaseType.DROP:
bulletTemplate = new BulletDrop();
break;
case EBulletChaseType.EXPLOSION:
bulletTemplate = new BulletExplosion();
break;
case EBulletChaseType.BOMB:
bulletTemplate = new BulletBomb();
break;
case EBulletChaseType.ARCHITECT:
bulletTemplate = new BulletArchitect();
break;
}
bulletTemplate.updateEnemy(enemy);
bulletTemplate.Initalize(bulletController);
bulletTemplate.Update();
}
public override void Initalize(BulletController controller)
{
isCollision = true;
controller.gameObject.SetActive(false);
updateController(controller);
target = enemy.transform;
m_startPosition = bulletController.gameObject.transform.localPosition;
// tinh khoang cach giua vien dan va muc tieu
m_fX = bulletController.gameObject.transform.InverseTransformPoint(target.position).x;
m_fY = bulletController.gameObject.transform.InverseTransformPoint(target.position).y;
// tinh toan van toc ban dau va goc ban cua dan
calculatorByTime(calculatorByVelocity(Random.Range(55, 60)));
if (m_fX >= 0)
{
controller.transform.Rotate(new Vector3(0, 0, Mathf.Rad2Deg * m_fAngle));
}
else
{
controller.transform.Rotate(new Vector3(0, 0, 180 - Mathf.Rad2Deg * m_fAngle));
}
prePosition = controller.gameObject.transform.position;
controller.gameObject.SetActive(true);
}
public override void Initalize(BulletController controller)
{
// ẩn viên đạn, xác định mục tiêu và hướng (tránh lỗi ngay từ đầu)
controller.gameObject.SetActive(false);
updateController(controller);
Update();
controller.gameObject.SetActive(true);
}
public void TestBullerController()
{
BulletController bc = new BulletController();
try {
bc.ExplodeBullet(bc.transform.position);
}catch (Exception e) {
//Explode bullet doesn't work
Assert.True(false,"error "+e.ToString());
// Assert.True(false);
}
}
public GameObject ShootAtTarget(GameObject bulletPrefab, float speed, Vector2 target, float angularDeviaton = 0)
{
GameObject bullet = Instantiate(bulletPrefab, transform.position, Quaternion.identity);
bullet.transform.LookAt2D(target);
bullet.transform.Rotate(0, 0, angularDeviaton);
bullet.GetComponent <Rigidbody2D>().velocity = bullet.transform.right * speed;
BulletController bulletController = bullet.GetComponent <BulletController>();
bulletController.Origin = gameObject;
return(bullet);
}
void FireCannon()
{
shotCounter -= Time.deltaTime;
{
if (shotCounter < -0)
{
shotCounter = timeBetweenShots;
}
BulletController newBullet = Instantiate(bullet, firePoint.position, firePoint.rotation) as BulletController;
newBullet.speed = bulletSpeed;
}
}
public void TestBullerController()
{
BulletController bc = new BulletController();
try {
bc.ExplodeBullet(bc.transform.position);
}catch (Exception e) {
//Explode bullet doesn't work
Assert.True(false, "error " + e.ToString());
// Assert.True(false);
}
}
private void GreenZoneCollider_TriggerEnter(Collider other)
{
BulletController bullet = other.GetComponent <BulletController>();
if (bullet != null)
{
if (bullet.bulletType == BulletController.BulletTypeEnum.Yellow)
{
Destroy(greenZoneCollider.gameObject);
}
}
}
void Update()
{
if (isReloading)
{
return;
}
//if current ammo <= 0 start reload
if (currentAmmo <= 0)
{
StartCoroutine(Reload());
//Reload();
return;
}
//press r to reload
if (Input.GetKeyDown(KeyCode.R) && currentAmmo != maxAmmo)
{
StartCoroutine(Reload());
return;
}
//shooting
if (isFiring && currentAmmo > 0)
{
shotCounter -= Time.deltaTime;
if (shotCounter <= 0)
{
audioSource.Play();
currentAmmo--;
//holdingAmmo--;
shotCounter = timeBetweenShoot;
BulletController newBullet = Instantiate(bullet, firePoint.position, firePoint.rotation) as BulletController;
var muzzleVFX = Instantiate(muzzlePrefab, firePoint.position, firePoint.rotation);
muzzleVFX.transform.forward = gameObject.transform.forward;
var hitVFX = Instantiate(hitPrefab, firePoint.position, firePoint.rotation);
Destroy(muzzleVFX, 1.5f);
Destroy(hitVFX, 1.5f);
newBullet.speed = bulletSpeed;
newBullet.damageToGive += bulletDamage;
}
}
else
{
shotCounter = 0;
}
}
/*void OnCollisionEnter(Collision collision) //Rigidbody collision
* { GameObject target;
* target = collision.gameObject;
* if (target != null)
* { Debug.Log(target);
* if (destroy_on_impact)
* { Destroy(gameObject);
* }
* else if (!piercing)
* { bullet_vel = Vector3.zero;
* }
* }
* }*/
void OnTriggerEnter(Collider other) //Trigger collision
{
GameObject target;
target = other.gameObject;
if (target != null && target.tag != "Floor")
{
Debug.Log(target.tag);
if (target.tag == "Wall")
{
bullet_vel = Vector3.zero;
if (destroy_on_impact)
{
Destroy(gameObject);
}
}
else if (target.tag == "Destructible") //Doodads
{
DestructableDoodadScript ds = target.GetComponent <DestructableDoodadScript>();
ds.TakeDamage(damage);
CheckPierce();
}
else if (target.tag == "Enemy")
{
if (owner == null || owner.tag != "Enemy")
{ //TODO: Damage enemy and add score
CheckPierce();
}
}
else if (target.tag == "Player")
{
if (owner == null || owner.tag != "Player")
{
PlayerController pc = target.GetComponent <PlayerController>();
pc.TakeDamage(damage, owner);
CheckPierce();
}
}
else if (target.tag == "Projectile")
{
BulletController target_ctrl = target.GetComponent <BulletController>();
if (target_ctrl.take_damage && (owner == null || target_ctrl.owner == null || target_ctrl.owner.tag != owner.tag)) //Avoid friendly fire
{
target_ctrl.hitpoints -= damage;
if (target_ctrl.hitpoints <= 0.0f)
{
Destroy(target);
}
CheckPierce();
}
}
}
}
IEnumerator ShootThree()
{
for (int i = 0; i < 3; i++)
{
BulletController bulletSpawn = Instantiate(projectile, spawner.transform.position, Quaternion.identity).GetComponent <BulletController>();
bulletSpawn.bursting = true;
bulletSpawn.startDirection = shootDirection;
Physics.IgnoreCollision(bulletSpawn.GetComponent <Collider>(), gameObject.GetComponent <Collider>());
audio.PlayOneShot(bulletShot);
yield return(new WaitForSeconds(burstTimer));
}
}
// Update is called once per frame
void Update()
{
if (Time.time > shotCounter)
{
if (Input.GetMouseButtonDown(0))
{
BulletController newBullet = Instantiate(bullet, firePoint.position, firePoint.rotation) as BulletController;
newBullet.speed = bulletSpeed;
shotCounter = Time.time + fireRate;
}
}
}
private void OnCollisionEnter2D(Collision2D collision)
{
BulletController bullet = collision.collider.GetComponent <BulletController>();
if (bullet != null || collision.collider.GetComponent <EnemyController>() != null)
{
rigidbody2D.simulated = false;
animator.SetTrigger("Hit");
audioSource.PlayOneShot(boom);
GameController.instance.GameOver();
}
}
public void SendBullet(BaseGameEntity gameEntity, BulletType bulletType)
{
if (gameEntity != null)
{
GameObject bullet = (GameObject)Instantiate(Resources.Load("GameScene/Bullet"));
bullet.name = string.Empty + bulletType;
bullet.transform.position = this.transform.position;
BulletController bulletCtrl = bullet.GetComponent <BulletController>();
bulletCtrl.Target = gameEntity;
bulletCtrl.BulletType = bulletType;
}
}
protected override void Start()
{
base.Start();
//ターゲット取得
parentBulletCtrl = myTran.root.GetComponent <BulletController>();
if (parentBulletCtrl != null)
{
Transform target = parentBulletCtrl.GetTarget();
SetTarget(target);
}
}
public void Shoot()
{
if (Input.GetKeyDown(KeyCode.Space) && canShoot)
{
canShoot = false;
BulletController bulletInstance = Instantiate(bullet);
bulletInstance.isPlayerBullet = true;
double bulletXVelocity = (bulletInitialVelocity.x + bulletRandomSpread * ((2 * r.NextDouble() - 1) / 2));
bulletXVelocity = direction == Direction.Left ? -bulletXVelocity : bulletXVelocity;
double bulletYVelocity = (bulletInitialVelocity.y + bulletRandomSpread * ((2 * r.NextDouble() - 1) / 2));
if (gameManager.GetPerks()[GameManager.PerkType.DirectFire])
{
bulletYVelocity = 0;
bulletXVelocity *= 2;
}
bulletInstance.transform.position = transform.position + new Vector3(direction == Direction.Left ? -0.8f : 0.8f, 0.2f, 0);
bulletInstance.GetComponent <Rigidbody2D>().velocity = new Vector2((float)bulletXVelocity, (float)bulletYVelocity) + body.velocity;
bulletInstance.onBulletHit = () =>
{
bulletInstance.GetComponent <AudioSource>().PlayOneShot(bulletHitSound);
};
if (gameManager.GetPerks()[GameManager.PerkType.DoubleFire])
{
bulletInstance = Instantiate(bullet);
bulletInstance.isPlayerBullet = true;
bulletXVelocity = (bulletInitialVelocity.x + bulletRandomSpread * ((2 * r.NextDouble() - 1) / 2));
bulletXVelocity = direction == Direction.Left ? -bulletXVelocity : bulletXVelocity;
bulletYVelocity = (bulletInitialVelocity.y + bulletRandomSpread * ((2 * r.NextDouble() - 1) / 2));
if (gameManager.GetPerks()[GameManager.PerkType.DirectFire])
{
bulletYVelocity = 0;
bulletXVelocity *= 2;
}
bulletInstance.transform.position = transform.position - new Vector3(direction == Direction.Left ? -0.8f : 0.8f, 0.2f, 0);
bulletInstance.GetComponent <Rigidbody2D>().velocity = new Vector2(-(float)bulletXVelocity, (float)bulletYVelocity) + body.velocity;
bulletInstance.onBulletHit = () =>
{
bulletInstance.GetComponent <AudioSource>().PlayOneShot(bulletHitSound);
};
}
audioSource.PlayOneShot(bulletShootSound);
StartCoroutine(RunShootCooldown());
}
}
// Update is called once per frame
void Update()
{
shotCounter -= Time.deltaTime;
if (isFiring)
{
if (shotCounter <= 0)
{
shotCounter = timeBetweenShots;
BulletController newBullet = Instantiate(bullet, firePoint.position, firePoint.rotation) as BulletController;
newBullet.speed = bulletSpeed;
}
}
}
IEnumerator Shoot()
{
canShoot = false;
BulletController bulletInstance = Instantiate(bullet, bullet.transform.position, bullet.transform.rotation);
bulletInstance.Appear();
gameController.bullets.Add(bulletInstance);
gameController.bulletsCount--;
yield return(new WaitForSeconds(1));
canShoot = true;
}
public override float GetBulletSpeed()
{
float v = 0;
BulletController bulletCtrl = bullet.GetComponent <BulletController>();
if (bulletCtrl != null)
{
v = bulletCtrl.GetSpeed();
}
return(v);
}
public void Shoot(InputAction.CallbackContext context)
{
if (context.started)
{
GameObject bGameObject = Instantiate(bullet, weaponFront.position, wmanager.currentWeapon.transform.rotation);
BulletController bcontroller = bGameObject.GetComponent <BulletController>();
Painter bPainter = bGameObject.GetComponent <Painter>();
bcontroller.velocity = bulletVelocity;
bcontroller.damage = damage;
bPainter.currentColor = painter.currentColor;
}
}
void OnTriggerEnter(Collider other)
{
BulletController bulletController = other.GetComponent <BulletController>();
if (bulletController == null)
{
return;
}
// Damage
Damage(bulletController.BulletDamage);
Destroy(other.gameObject);
}
void OnCollisionEnter(Collision collision)
{
//
// first detect that it is a bullet
//
BulletController bullet = collision.gameObject.GetComponent <BulletController>();
if (bullet)
{
handleDamage(bullet);
}
}
void OnTriggerEnter2D(Collider2D collision)
{
BulletController bullet = collision.gameObject.GetComponent <BulletController>();
if ((collision.gameObject.tag == "EnemyBullet") && (!bHitOnce) && (shipHealth != 0))
{
shipHealth -= bullet.damage;
AudioSource.PlayOneShot(BasicHitSound, 1.0f);
STGEngine.SpawnPrefab(bullet.hitEffect, this.transform.position, this.transform.rotation, new Vector2(0, 0), 0);
fInviTime = 30;
bHitOnce = true;
}
}
private void Shoot()
{
GameObject bullet = Instantiate(bulletPrefab, bulletSpawn.position, bulletSpawn.rotation);
bullet.layer = LayerMask.NameToLayer("Damage" + skillManager.playerNumber);
BulletController bulletController = bullet.GetComponent <BulletController>();
BulletHealthController bulletHealth = bullet.GetComponent <BulletHealthController>();
bulletController.bulletSpeed = shotSpeed;
bulletHealth.bulletLifeTime = 5f;
bulletHealth.healthController = skillManager.healthController;
}
private void Launch(Vector2 direction)
{
GameObject bullet = Instantiate(
_bulletPrefab,
_rb2d.position,
Quaternion.identity
);
BulletController bc = bullet.GetComponent <BulletController>();
bc.Speed = _bulletSpeed;
bc.Direction = direction;
}
public virtual void LaunchBullet()
{
GameObject launchingBullet = bulets[bulets.Count - 1];
bulets.Remove(launchingBullet);
launchingBullet.transform.position = bulletSpawner.position;
BulletController bulletController = launchingBullet.GetComponent <BulletController>();
bulletController.LaunchBullet(targetSeaker.target, buletSpeed, damage);
launchingBullet.SetActive(true);
}
void FireAndDestroy_Default(Vector3 fireDirection)
{
BulletController[] bulletChildren = transform.GetComponentsInChildren <BulletController>();
for (int i = 0; i < bulletChildren.Length; i++)
{
BulletController bulletChild = bulletChildren[i];
bulletChild.SetHoming();
ApplyArcNoiseAndLaunch(bulletChild, fireDirection);
}
Destroy(gameObject);
}
private void Fire(float x, float z)
{
GameObject bullet = GameObject.Instantiate(bulletType);
Vector3 dir = new Vector3(x, 0, z).normalized;
bullet.transform.position = turretHead.transform.position + 4 * dir + new Vector3(0, 0.65f, 0);
BulletController bulletController = bullet.GetComponent <BulletController>();
bulletController.speed = 50;
bulletController.direction = dir;
bulletController.maxDist = GetComponent <SphereCollider>().radius *transform.localScale.x;
bullet.transform.parent = transform;
}
private void Shoot()
{
GameObject newBullet = Instantiate(bullet, transform.position, Quaternion.identity);
newBullet.transform.Rotate(0f, 0f, 180f, Space.Self);
BulletController bulletController = newBullet.GetComponent <BulletController>();
bulletController.speed = bulletSpeed;
bulletController.damage = bulletDamage;
bulletController.direction = new Vector3(0, -1, 0);
bulletController.targetTag = "Player";
}
// Shoot a projectile in the current direction
private void FireBullet()
{
float offset = GetComponent <Renderer>().bounds.size.x / 2;
// Instantiate bullet prefab at current character position
Vector3 pos = transform.position + GetDirection3D() * offset;
GameObject bullet = Instantiate(bulletPrefab, pos, transform.rotation);
// Add bullet controller component
BulletController bulletControl = bullet.gameObject.AddComponent <BulletController>();
bulletControl.SetProperties(CurrentWeapon.Strength, GetDirection(), 0.1f, 1);
}
public void fire()
{
AudioSource enemyFire = GetComponent <AudioSource>();
if (Time.time > nextFire)
{
enemyFire.Play();
nextFire = Time.time + fireRate;
BulletController newBullet = Instantiate(bullet, gunEnd.position, gunEnd.rotation) as BulletController;
newBullet.gunDamage = gunDamage;
newBullet.speed = bulletSpeed;
}
}
public void SpawnBullet(Vector3 position, float angle)
{
GameObject bullet = (GameObject)GameObject.Instantiate(BulletPrefab, position, Quaternion.identity);
bullet.transform.Rotate(Vector3.forward, angle);
BulletController bulletController = bullet.GetComponent <BulletController>();
bulletController.Shooter = gameObject;
bulletController.Damage = Damage;
SoundEffectManager.PlaySound(transform, ShootingSound);
}
private void Fire()
{
timer -= Time.deltaTime;
if (timer <= 0f)
{
GameObject curBullet = Instantiate(BundleMgr.Instance.GetObject("MonsterBullet"), transform) as GameObject;
BulletController bulletCtrl = curBullet.GetComponent <BulletController>();
bulletCtrl.Init(DefineNumber.BulletSpeed, DefineNumber.BulletDuration, muzzle.transform.position, gameObject);
curBullet.transform.localScale = new Vector3(1f, 1f, 1f);
curBullet.SetActive(true);
timer = cooldown;
}
}
// Update is called once per frame
void Update()
{
if (Input.GetKey(KeyCode.W))
{
Z = 1;
}
if (Input.GetKey(KeyCode.S))
{
Z = -1;
}
if (Input.GetKey(KeyCode.A))
{
X = -1;
}
if (Input.GetKey(KeyCode.D))
{
X = 1;
}
shootCD += Time.deltaTime;
Vector2 mouseScreenPos = Input.mousePosition;
float distanceFromCameraToXZPlane = Camera.main.transform.position.y - transform.position.y;
Vector3 screenPosWithZDistance = (Vector3)mouseScreenPos + (Vector3.forward * distanceFromCameraToXZPlane);
Vector3 mouseToWorldPos = Camera.main.ScreenToWorldPoint(screenPosWithZDistance);
transform.LookAt(mouseToWorldPos);
gunObjects[guns - 1].GetComponent <MeshRenderer>().enabled = true;
if (Input.GetMouseButton(0))
{
if (shootCD > attackSpeed)
{
for (int i = 0; i < guns; i++)
{
GameObject bullet = Instantiate(bulletTemplate, bullets);
BulletController controller = bullet.GetComponent <BulletController>();
bullet.transform.position = transform.position;
controller.transform.LookAt(gunObjects[i].transform);
controller.ally = "Player";
controller.toDamage = "Enemy";
controller.damage = damage;
bulletShooted += 1;
}
shootCD = 0;
}
}
stats.text = "Damage: " + damage.ToString("F2") + "\nAttack Speed: " + attackSpeed.ToString("F2") + "sec" +
"\nHP: " + GetComponent <HealthController>().hp.ToString("F2") + "\nExp: " + GetComponent <LevelController>().currentExp +
"/" + (int)GetComponent <LevelController>().maxExp;
}
void Start()
{
gameManager = GameManager.Instance;
myTrans = transform;
myRigid = rigidbody;
bulletController = bulletPrefab.GetComponent<BulletController>();
GameObject go = Instantiate(bulletPrefab) as GameObject;
go.name = "Bullet";
bulletPosTrans = bulletStartPos.transform;
go.transform.position = bulletPosTrans.transform.position;
go.SetActive(false);
bullet = go;
}
public void setText(BulletController controller)
{
switch(controller.effect)
{
case EBulletEffect.SLOW:
BulletSlowEffect slowEffect = controller as BulletSlowEffect;
effectText.text = "- Slow " + (slowEffect.slowValue * 100) + "% of enemy's speed\n" +
"- Duration: " + slowEffect.existTime + "s";
nameLabel.text = "SLOW";
break;
case EBulletEffect.BURN:
BulletBurnEffect burnEffect = controller as BulletBurnEffect;
effectText.text = "- Burn " + burnEffect.damageEachFrame + " HP every " + burnEffect.timeFrame + "s\n"
+ "- Duration: " + burnEffect.existTime + "s";
nameLabel.text = "BURN";
break;
}
}
public override void Initalize(BulletController controller)
{
updateController(controller);
parentCollider = controller.collider;
if(parentCollider is SphereCollider)
{
childCollider = controller.gameObject.GetComponentsInChildren<SphereCollider>()[1];
colliderType = EBulletColliderType.SPHERE;
}
else if(parentCollider is BoxCollider)
{
childCollider = controller.gameObject.GetComponentsInChildren<BoxCollider>()[1];
colliderType = EBulletColliderType.BOX;
}
else if(parentCollider is CapsuleCollider)
{
childCollider = controller.gameObject.GetComponentsInChildren<CapsuleCollider>()[1];
colliderType = EBulletColliderType.CAPSULE;
}
getChildColliderValue();
}
// Use this for initialization
void Awake()
{
current = this;
}
void BulletHitPlayerRPC(Vector3 aHitPoint, BulletController.BulletInfo aBulletInfo, PhotonPlayer aShooter, PhotonPlayer aHitPlayer)
{
foreach (GameObject plane in GameObject.FindGameObjectsWithTag("Plane"))
{
if (plane.GetComponent<PhotonView>().owner == aHitPlayer)
{
Instantiate((GameObject)Resources.Load("BulletHit"), plane.transform.position + aHitPoint, Quaternion.LookRotation(aBulletInfo.m_startDirection, -Vector3.forward));
break;
}
}
if (aHitPlayer == PhotonNetwork.player)
{
GameObject.Find("PlayerController").GetComponent<PlayerController>().TakeBulletDamage(aShooter);
}
}
public GameObject SpawnBullet(BulletController.BulletInfo aBulletInfo)
{
GameObject player = null;
GameObject[] planes = GameObject.FindGameObjectsWithTag("Plane");
for (int i = 0; i < planes.Length; i++)
{
if (planes[i].GetComponent<PhotonView>().owner == aBulletInfo.m_shooter)
{
player = planes[i];
break;
}
}
if (player != null)
{
player.GetComponent<PlaneController>().ResetGunCharge();
GameObject flare = (GameObject)Instantiate(m_muzzleFlarePrefab, player.GetComponent<PlaneController>().m_bulletSpawnPoint.position, player.GetComponent<PlaneController>().m_bulletSpawnPoint.rotation);
flare.transform.parent = player.transform;
flare.GetComponent<AudioSource>().pitch = 1 + Random.Range(-2.0f, 3.0f) * 0.2f;
if (aBulletInfo.m_shooter == PhotonNetwork.player)
{
flare.GetComponent<AudioSource>().spatialBlend = 0;
}
flare.GetComponent<AudioSource>().Play();
}
GameObject bullet = (GameObject)Instantiate(((int)aBulletInfo.m_shooter.customProperties["Team"] == 1) ? m_bullet1Prefab : m_bullet2Prefab, aBulletInfo.m_startPosition, Quaternion.LookRotation(aBulletInfo.m_startDirection, -Vector3.forward));
bullet.GetComponent<Rigidbody>().velocity = aBulletInfo.m_startVelocity;
bullet.GetComponent<BulletController>().SetBulletInfo(aBulletInfo);
return bullet;
}
void DeleteBulletRPC(BulletController.BulletInfo aBulletInfo)
{
if (m_spawnedBullets.Contains(aBulletInfo))
{
int index = m_spawnedBullets.IndexOf(aBulletInfo);
GameObject bullet = m_spawnedBullets[index].gameObject;
Destroy(bullet);
m_spawnedBullets.Remove(aBulletInfo);
}
}
public void BulletHitPlayer(BulletController.BulletInfo aBulletInfo, Collision aCollision)
{
aBulletInfo.gameObject.transform.parent = aCollision.gameObject.transform;
Vector3 relativeHitPoint = aBulletInfo.gameObject.transform.localPosition;
PhotonPlayer hitPlayer = aCollision.gameObject.GetComponent<PhotonView>().owner;
PhotonPlayer shooter = aBulletInfo.m_shooter;
aBulletInfo.gameObject.transform.parent = null;
DeleteBullet(aBulletInfo);
GetComponent<PhotonView>().RPC("BulletHitPlayerRPC", PhotonTargets.All, relativeHitPoint, aBulletInfo, shooter, hitPlayer);
}
void SpawnBulletRPC(BulletController.BulletInfo aBulletInfo)
{
if (PhotonNetwork.player == aBulletInfo.m_shooter)
{
aBulletInfo.m_isMaster = true;
}
GameObject bullet = GameObject.Find("PlayerController").GetComponent<WeaponController>().SpawnBullet(aBulletInfo);
m_spawnedBullets.Add(bullet.GetComponent<BulletController>().GetBulletInfo());
int playerTeam = (int)aBulletInfo.m_shooter.customProperties["Team"];
if (PhotonNetwork.player != aBulletInfo.m_shooter)
{
bullet.GetComponent<Collider>().isTrigger = true;
}
switch (playerTeam)
{
case 1:
bullet.layer = 10;
break;
case 2:
bullet.layer = 11;
break;
}
}
public void DeleteBullet(BulletController.BulletInfo aBulletInfo)
{
GetComponent<PhotonView>().RPC("DeleteBulletRPC", PhotonTargets.All, aBulletInfo);
}
public virtual void updateController(BulletController controller)
{
bulletController = controller;
}
public void SpawnBullet(BulletController.BulletInfo aBulletInfo)
{
m_shotsFired++;
int id = GetNextBulletID();
aBulletInfo.m_bulletID = id;
GetComponent<PhotonView>().RPC("SpawnBulletRPC", PhotonTargets.All, aBulletInfo);
}
public void SetSplitProps(BulletController bc)
{
dmg = bc.dmg; //damage dealt out
speed = bc.speed; //speed of the bullet
poison = bc.poison; //poison damage on enemy
poisonDur = bc.poisonDur; //how long poison lasts, in seconds
knockback = 0f; //knockback -- positive value for distance knocked back
stun = bc.stun; //amount (time?) of enemy stun
lifeDrain = bc.lifeDrain; //lifedrain on enemy
slowdown = bc.slowdown; //enemy slowdown
slowDur = bc.slowDur; //how long slowdown lasts
splash = bc.splash; //percentage of fx to transfer to hits
splashRad = bc.splashRad; //radius of splash damage
splitCount = bc.splitCount; //split-result bullets don't split themselves
penetration = bc.penetration; //ignores this amount of enemy shield
shieldShred = bc.shieldShred; //lowers enemy shield's max value by this
homingStrength = 0f; //strength of homing effect
arcDmg = 0f; //dmg bonus from arcing - if above 0 it arcs
isSplitBullet = true; //is the result of a split
splitRadius = Mathf.Abs(transform.position.x / Mathf.Cos(Mathf.Atan2 (transform.position.y,transform.position.x)));
//Debug.Log ("splitRadius is " + splitRadius);
angleLimit = splitCount * dirScalar * ((Mathf.PI)/3f);
float superAddValue = 0f;
/*if (splitCount == 3)
{
superAddValue = 6f;
}*/
angleLimitVect = new Vector3 (0f, 0f, ((angleLimit * 57.296f) + superAddValue)); //rad to deg constant
splitParentPos = bc.transform.position;
//Debug.Log ("angleLimit is " + angleLimit);
//Debug.Log ("angleLimit as degrees is " + angleLimit * 57.296f);
//Debug.Log ("angleLimitQuat is " + angleLimitVect.ToString ());
}
public virtual void Initalize(BulletController controller)
{
}
//Assigns skill values to bullets
private void ConfigureBullet(BulletController bc)
{
if (speed == 0 || range == 0 || dmg == 0)
Debug.Log("Check your speed, range, and/or dmg! One might be 0!");
bc.dmg = dmg;
bc.speed = speed;
bc.range = range;
bc.knockback = knockback;
bc.lifeDrain = lifeDrain;
bc.poison = poison;
bc.poisonDur = poisonDur;
bc.splash = splash;
bc.splashRad = splashRad;
bc.stun = stun;
bc.slowdown = slowdown;
bc.slowDur = slowDur;
bc.penetration = penetration;
bc.shieldShred = shieldShred;
bc.splitCount = splitCount;
bc.homingStrength = homingStrength;
bc.arcDmg = arcDmg;
bc.isSplitBullet = false;
Debug.Log ("bullet slowDur is " + bc.slowDur);
}
// Use this for initialization
void Start()
{
SetBulletPattern(GetRandomPattern());
switch (rotateDirection)
{
case RotateDirection.RANDOM:
clockwise = Random.seed % 2 == 1;
break;
case RotateDirection.CLOCKWISE:
clockwise = true;
break;
case RotateDirection.ANTICLOCKWISE:
clockwise = false;
break;
}
switch (bulletPattern)
{
case BulletPattern.RANDOM_SPRAY:
bulletController = new BCRandomSpray(this);
break;
case BulletPattern.RINGS:
bulletController = new BCRings(this);
break;
case BulletPattern.LOOPS:
bulletController = new BCLoops(this);
break;
case BulletPattern.WAVES:
bulletController = new BCWaves(this);
break;
case BulletPattern.SPIRAL:
bulletController = new BCSpiral(this);
break;
case BulletPattern.BURST:
bulletController = new BCBurst(this);
break;
}
}
public override void Initalize(BulletController controller)
{
updateController(controller);
}
