public void Init(data.Player player)
{
// characters
for (int i = 0; i < btnCharacters.Count; ++i)
{
CharacterController charController = btnCharacters[i].gameObject.GetComponent <CharacterController>();
if (i < player.Characters.Count)
{
// set button for character controller
btnCharacters[i].name = player.Characters[i].Name;
btnCharacters[i].GetComponentInChildren <Text>().text = player.Characters[i].Name;
charController.Init(player.Characters[i]);
}
else
{
btnCharacters[i].gameObject.SetActive(false);
charController.scrollbar.gameObject.SetActive(false);
}
}
MissileController missileController = btnMissile.gameObject.GetComponent <MissileController>();
// missiles
if (player.Missiles.Count > 0)
{
// set button for character controller
missileController.Init(player.Missiles[0]);
}
else
{
missileController.gameObject.SetActive(false);
}
}
public void OnMissileCollision(MissileController missile)
{
if (missile.ResetMultiplier)
{
Multiplier.ResetMultiplier();
}
}
public Map CopyAndFlip(Map map, CoordinateFlipper flipper, Dictionary <int, Entity> flippedEntities)
{
var copy = new Map(map);
// Copy all entities including walls
for (var y = 0; y < map.Height; y++)
{
for (var x = 0; x < map.Width; x++)
{
var entity = map.GetEntity(x, y);
if (entity == null)
{
continue;
}
Entity flippedEntity = null;
if (entity.GetType() == typeof(Alien))
{
flippedEntity = Alien.CopyAndFlip((Alien)entity, flipper, flippedEntities);
}
else if (entity.GetType() == typeof(Missile))
{
flippedEntity = Missile.CopyAndFlip((Missile)entity, flipper, flippedEntities);
}
else if (entity.GetType() == typeof(Bullet))
{
flippedEntity = Bullet.CopyAndFlip((Bullet)entity, flipper, flippedEntities);
}
else if (entity.GetType() == typeof(Shield))
{
flippedEntity = Shield.CopyAndFlip((Shield)entity, flipper, flippedEntities);
}
else if (entity.GetType() == typeof(Ship))
{
flippedEntity = Ship.CopyAndFlip((Ship)entity, flipper, flippedEntities);
}
else if (entity.GetType() == typeof(AlienFactory))
{
flippedEntity = AlienFactory.CopyAndFlip((AlienFactory)entity, flipper, flippedEntities);
}
else if (entity.GetType() == typeof(MissileController))
{
flippedEntity = MissileController.CopyAndFlip((MissileController)entity, flipper,
flippedEntities);
}
else if (entity.GetType() == typeof(Wall))
{
flippedEntity = Wall.CopyAndFlip((Wall)entity, flipper, flippedEntities);
}
if ((flippedEntity != null) && (copy.GetEntity(flippedEntity.X, flippedEntity.Y) == null))
{
copy.AddEntity(flippedEntity);
}
}
}
return(copy);
}
void Start()
{
missileController = GetComponentInParent<MissileController> ();
if (blastRadius <= 0) {
blastRadius = DEFAULT_BLAST_RADIUS;
}
}
public void TriggerMissile()
{
MissileController missileController = m_TriggerMissile.GetComponent <MissileController>();
missileController.Trigger();
m_TriggerMissile = null;
}
/// <summary>
/// Called when an enemy should fire. If there are already MAX_ENEMY_MISSILES, then no firing will
/// take place. Checks the ACTIVE CHILD count, since pooling is used to spawn/despawn (activeate/deactive)
/// enemy missiles.
/// </summary>
/// <param name="enemy"></param>
private bool enemyFireMissile(EnemyController enemy)
{
int activeCount = 0;
bool fired = false;
for (int cnt = 0; cnt < EnemyMissileContainer.childCount; cnt++)
{
if (EnemyMissileContainer.GetChild(cnt).gameObject.activeInHierarchy == true)
{
activeCount++;
}
}
// Fire a missile from the invader if the maximum number of active missiles don't already exist.
if (activeCount < GameGlobals.MAX_ENEMY_MISSILES)
{
GameObject missile = RFObjectPool.Spawn(EnemyMissilePrefab, Vector3.zero, Quaternion.identity);
if (missile != null)
{
MissileController mc = missile.GetComponent <MissileController>();
mc.EnemyFired(enemy.gameObject);
fired = true;
}
}
return(fired);
}
private void SpawnMissile()
{
float yOffset = Random.RandomRange(-MAX_SPAWN_OFFSET, MAX_SPAWN_OFFSET);
float ypos = target.transform.position.y + yOffset;
if (ypos < 1.0f)
{
ypos = 1.0f;
}
Vector3 missilePosition = new Vector3(target.transform.position.x + TARGET_X_OFFSET, ypos, target.transform.position.z);
Vector3 estimatedPosition = target.transform.position + (target.linearVelocity * 7600.0f);
float estimatedDist = Vector3.Distance(estimatedPosition, missilePosition);
float angleOffset = Random.Range(-MAX_SPAWN_ANGLE, MAX_SPAWN_ANGLE);
float height = missilePosition.y - estimatedPosition.y;
float angle = (Mathf.Sin(height / estimatedDist) * Mathf.Rad2Deg) + angleOffset;
GameObject missile = GameObject.Instantiate(missilePrefab);
missile.transform.position = missilePosition;
missile.transform.rotation = Quaternion.Euler(0.0f, angle, 0.0f);
MissileController controller = missile.GetComponent <MissileController>();
controller.Fire(angle);
}
public static Player CopyAndFlip(Player player, CoordinateFlipper flipper,
Dictionary <int, Entity> flippedEntities)
{
var copy = new Player(player)
{
PlayerNumber = player.PlayerNumber == 1 ? 2 : 1
};
copy.Missiles.Clear();
foreach (var missile in player.Missiles)
{
copy.Missiles.Add(flippedEntities.ContainsKey(missile.Id)
? (Missile)flippedEntities[missile.Id]
: Missile.CopyAndFlip(missile, flipper, flippedEntities));
}
if (player.MissileController != null)
{
copy.MissileController = MissileController.CopyAndFlip(player.MissileController, flipper, flippedEntities);
}
if (player.AlienFactory != null)
{
copy.AlienFactory = AlienFactory.CopyAndFlip(player.AlienFactory, flipper, flippedEntities);
}
copy.AlienManager = AlienManager.CopyAndFlip(player.AlienManager, flipper, flippedEntities);
if (player.Ship != null)
{
copy.Ship = Ship.CopyAndFlip(player.Ship, flipper, flippedEntities);
}
return(copy);
}
void OnLaunchFragments(MissileController.FragmentsArg arg)
{
if (arg.cause != null)
{
return;
}
Rigidbody2D r = GetComponent <Rigidbody2D>();
Vector2 p = r.velocity * r.mass, p2 = p;
Vector3 shift = p.normalized * Shift;
MissileController mc = SplitsPrefab.PrefabInstantiate(transform.position + shift, Damage, p);
mc.transform.rotation = transform.rotation;
for (int i = 0; i < Count; i++)
{
p = p.Rotate(Angle);
p2 = p2.Rotate(-Angle);
shift = p.normalized * Shift;
mc = SplitsPrefab.PrefabInstantiate(transform.position + shift, Damage, p);
mc.transform.rotation = transform.rotation;
shift = p2.normalized * Shift;
mc = SplitsPrefab.PrefabInstantiate(transform.position + shift, Damage, p2);
mc.transform.rotation = transform.rotation;
}
}
/*
* Retarget active missiles to the knife
*/
void RedirectMissiles()
{
KnifeController knife = playerKnifeController.GetActiveKnifeController();
if (knife == null)
{
return;
}
// Get all currently active missiles
List <MissileController> missiles = new List <MissileController>();
foreach (GameObject obj in GameObject.FindGameObjectsWithTag("Missile"))
{
MissileController controller = obj.GetComponent <MissileController>();
if (controller != null)
{
missiles.Add(controller);
}
}
if (missiles.Count <= 0)
{
return;
}
// apply new target
foreach (MissileController missile in missiles)
{
// set target here!
missile.SetTarget(knife.transform);
}
}
private IEnumerator ShootSR()
{
float damage = playerWeaponStats.WeaponStats[(int)GunMode.SR, (int)PlayerWeaponStats.WeaponStat.DAMAGE];
float energyDown = playerWeaponStats.WeaponStats[(int)GunMode.SR, (int)PlayerWeaponStats.WeaponStat.CONSUMPTION];
if (canSR && playerStats.EnergyValue >= energyDown)
{
canSR = false;
CmdNetworkAnimation("SR");
GetComponent <PlayerSound>().PlayOneShot(gameObject.name, (int)PlayerSound.AudioClipNum.SR, 1f);
ray = new Ray(cam.transform.position, cam.transform.forward);
RaycastHit hit;
if (Physics.Raycast(ray, out hit, 3000f, 1 << LayerMask.NameToLayer("Player")
| 1 << LayerMask.NameToLayer("Block")
| 1 << LayerMask.NameToLayer("HeadHitBox")
| 1 << LayerMask.NameToLayer("Bullet")))
{
ray = new Ray(cam.transform.position,
(hit.point - fireStart.transform.position));
if (hit.transform.gameObject.tag == "Player")
{
CmdHitPlayer(hit.point, hit.normal);
}
else
{
CmdOnhit(hit.point, hit.normal);
}
if (hit.collider.gameObject.tag == "Player")
{
CmdTakeDamage(hit.collider.gameObject.name, damage);
GetComponent <PlayerSound>().PlayOneShot(hit.collider.gameObject.name, (int)PlayerSound.AudioClipNum.DAMAGE, 1f);
}
else if (hit.collider.gameObject.tag == "HeadHitBox")
{
CmdTakeDamage(hit.collider.gameObject.name, damage * 2f);
GetComponent <PlayerSound>().PlayOneShot(hit.collider.gameObject.name, (int)PlayerSound.AudioClipNum.DAMAGE, 1f);
}
else if (hit.collider.gameObject.tag == "Bullet")
{
BulletController bullet = hit.collider.gameObject.GetComponent <BulletController>();
CmdRpgReset(bullet.getShooter().name, bullet.getRpgCount(), hit.point);
}
else if (hit.collider.gameObject.tag == "Missile")
{
MissileController missile = hit.collider.gameObject.GetComponent <MissileController>();
CmdMissileReset(missile.getShooter().name, missile.getMissileCount(), hit.point);
}
}
playerStats.EnergyDown(energyDown);
yield return(new WaitForSeconds(playerWeaponStats.WeaponStats[(int)GunMode.SR, (int)PlayerWeaponStats.WeaponStat.DELAY]));
canSR = true;
}
}
void Start()
{
controller = GetComponent <MissileController>();
if (triggerImmediately)
{
OnTrigger(this, System.EventArgs.Empty);
}
}
public void ResetEffect(MissileController newMissile)
{
currentMissile = newMissile;
currentTime = Time.time;
lifetime = particleSys.main.duration + particleSys.main.startLifetime.constant;
newMissile.fireAgainTiming = Time.time + lifetime;
}
private void DestroyMissiles()
{
GameObject[] missiles = GameObject.FindGameObjectsWithTag("Missile");
foreach (GameObject missile in missiles)
{
MissileController controller = missile.GetComponent <MissileController>();
controller.Destroy();
}
}
private void Awake()
{
missileRigidbody = GetComponent <Rigidbody2D>();
boxCollider = GetComponent <BoxCollider2D>();
missileController = FindObjectOfType <MissileController>();
playerResources = FindObjectOfType <PlayerResources>();
model = this.transform.GetChild(0).gameObject;
}
public void InstantiateMissileAtLocation(List <Missile> missiles, int x, int y, float rate)
{
float interval = 0.15f;
for (int m = 0; m < missiles.Count; m++)
{
float z = y;
if (m > 0 && m % 2 == 0)
{
z += m * interval;
}
else
{
z += m * interval;
}
PlayerType missilePlayerType = missiles [m].PlayerType;
int direction = missilePlayerType == PlayerType.A ? 1 : -1;
var missile = missilePlayerType == PlayerType.A ?
MissileObjectPool.current.GetForPlayerA() :
MissileObjectPool.current.GetForPlayerB();
missile.SetActive(true);
missile.transform.position = new Vector3(x, missile.transform.position.y, z);
MissileController missileCtrl = missile.GetComponent <MissileController>();
missileCtrl.Setup(missiles[m], direction, rate);
if (IsNewMissile(missileCtrl.missile))
{
// Play muzzleflash effect
var pos = missile.transform.position;
var offset = missileCtrl.missile.PlayerType == PlayerType.A ? -0.5f : 0.25f;
var muzzleFlash = missileCtrl.missile.PlayerType == PlayerType.A ? muzzleFlashPlayerA : muzzleFlashPlayerB;
pos.x -= direction * missileCtrl.missile.Speed + offset;
pos.y = 0.5f;
var muzzleFlashObj = Instantiate(muzzleFlash, pos, Quaternion.identity);
Destroy(muzzleFlashObj, CommandLineUtil.GetRoundStep());
AudioClip clip;
if (missileCtrl.missile.PlayerType == PlayerType.A)
{
clip = firingSoundsPlayerA[Random.Range(0, firingSoundsPlayerA.Length)];
}
else
{
clip = firingSoundsPlayerB[Random.Range(0, firingSoundsPlayerB.Length)];
}
missileCtrl.PlaySound(clip);
}
}
}
public override void Fire(Transform firePoint)
{
GameObject missile = spawnGameObjectBehaviour.Spawn(prefab, firePoint.position, firePoint.rotation);
MissileController missileController = missile.GetComponent <MissileController>();
Assert.IsNotNull(missileController, $"{missile.gameObject.name} doesn't have MissileController component");
missileController.SearchAndDestroy();
}
private void RpcMissileReset(string name, int count, Vector3 lastPosition)
{
MissileController missileController =
GameDirector.Instance.players[name].GetComponent <AttackManager>().missiles[count].GetComponent <MissileController>();
if (missileController != null)
{
missileController.Reset(lastPosition);
}
}
private void Fire(Vector3 focus, Vector3 from)
{
GameObject missile = Instantiate(missilePrefab, from, new Quaternion());
missile.layer = 9;
MissileController missileComponent = missile.GetComponent <MissileController> ();
missileComponent.direction = focus - from;
missileComponent.SetUser(this.gameObject);
}
private void Shoot()
{
Vector3 spawnPoint = transform.position;
MissileController missileController = Container.InstantiatePrefabForComponent <MissileController>(missileResource,
spawnPoint,
Quaternion.identity,
_missileParent.transform);
missileController.transform.LookAt(player.transform);
}
// Fire missiles. Higher level means faster travel speed
public void FireMissiles(int currLevel)
{
// Missiles
MissileController currentMissile_up = missilePool.objects[0].GetComponent <MissileController>();
MissileController currentMissile_down = missilePool.objects[1].GetComponent <MissileController>();
if (!currentMissile_up.gameObject.activeInHierarchy && Time.time >= currentMissile_up.fireAgainTiming)
{
currentMissile_up.missilePattern = missilePattern;
currentMissile_up.shotSpeed = 5.0f * currLevel;
currentMissile_up.rotationStartingAngle = 30;
currentMissile_up.rotationLimit = 70;
currentMissile_up.twoWay_isUp = true;
currentMissile_up.InitializeMissile();
currentMissile_up.gameObject.SetActive(true);
}
if (!currentMissile_down.gameObject.activeInHierarchy && Time.time >= currentMissile_down.fireAgainTiming)
{
currentMissile_down.missilePattern = missilePattern;
currentMissile_down.shotSpeed = 5.0f * currLevel;
currentMissile_down.rotationStartingAngle = -30;
currentMissile_down.rotationLimit = 70;
currentMissile_down.twoWay_isUp = false;
currentMissile_down.InitializeMissile();
currentMissile_down.gameObject.SetActive(true);
}
// Version 1: Deprecate due to priority bug causing up-firing missiles to always shoot upwards
/*
* for(int i = 0; i < missilePool.objects.Count; i++) {
* MissileController currentMissile_up = missilePool.objects[i].GetComponent<MissileController>();
* if(!currentMissile_up.gameObject.activeInHierarchy) {
* currentMissile_up.missilePattern = missilePattern;
* currentMissile_up.rotationStartingAngle = 30;
* currentMissile_up.twoWay_isUp = true;
* currentMissile_up.InitializeMissile();
* currentMissile_up.gameObject.SetActive(true);
* break;
* }
* }
* for(int i = 0; i < missilePool.objects.Count; i++) {
* MissileController currentMissile_down = missilePool.objects[i].GetComponent<MissileController>();
* if(!currentMissile_down.gameObject.activeInHierarchy) {
* currentMissile_down.missilePattern = missilePattern;
* currentMissile_down.rotationStartingAngle = -30;
* currentMissile_down.twoWay_isUp = false;
* currentMissile_down.InitializeMissile();
* currentMissile_down.gameObject.SetActive(true);
* break;
* }
* }
*/
}
public MissileController PrefabInstantiate(Vector3 position, float damage, Vector2 impulse)
{
GameObject go = GameObject.Instantiate(gameObject) as GameObject;
MissileController mc = go.GetComponent <MissileController>();
mc.transform.position = position;
mc.Damage = damage;
mc.GetComponent <Rigidbody2D>().AddForce(impulse, ForceMode2D.Impulse);
return(mc);
}
private GameObject Shoot()
{
sparks.Play();
// Shoot a missile
GameObject missileInstance = Instantiate(missile, missileSpawn.position, missileSpawn.rotation);
MissileController controller = missileInstance.GetComponent <MissileController>();
controller.moveSpeed = (float)attributes.bulletSpeed;
controller.spawner = gameObject;
return(missileInstance);
}
public void OnFire(Vector2 direction, bool alt)
{
MissileController p = alt ? Weapon.AltMissilePrefab : Weapon.MainMissilePrefab;
MissileController mc = p.PrefabInstantiate(
(Vector2)transform.position + direction.normalized * 3,
Damage,
direction * p.FirePower);
mc.SendMessage("OnFire", direction);
}
public override void Activate(PlayerController playerController)
{
playerController.ui?.ClearSkillUIFor(this);
AudioManager.Instance?.Play("MissileShotSFX");
MissileController projectile = Object.Instantiate(Resources.Load <GameObject>("Prefabs/Missile")).GetComponent <MissileController>();
projectile.transform.position = playerController.transform.position + playerController.direction.ToVector3() * safeDistance;
projectile.Rigidbody2D.velocity = (playerController.moveSpeed + speed) * playerController.direction;
projectile.color = playerController.color;
}
public override void FireShot()
{
fireCooldown = Time.time + fireRate;
// Projectile
if (ammo > 0 || ammo == -1)
{
ammo--;
if (origin == 0)
{
//Player missile. Update UI
GameSingleton.Instance.Missiles = ammo;
EventManager.TriggerEvent("missileFired");
}
if (createPool)
{
bullet = pool.GetPooledObject();
bullet.transform.position = transform.position + transform.forward * createForward;
bullet.transform.rotation = transform.rotation;
}
else
{
bullet = Instantiate(projectile, transform.position + transform.forward * createForward, Quaternion.identity) as GameObject;
}
Projectile P = bullet.GetComponent <Projectile>();
P.damage = damage;
P.duration = bulletLife;
P.pooled = createPool;
P.speed = bulletSpeed;
P.layerMask = layerMask;
P.Init();
// Missile stuff
MissileController missile = P.GetComponent <MissileController>();
if (missile != null)
{
missile.targetTag = targetTag;
missile.targetTag2 = targetTag2;
}
bullet.SetActive(true);
if (bulletSpeed > 0)
{
bullet.GetComponent <Rigidbody>().velocity = transform.forward * bulletSpeed;
}
}
else
{
// out of missiles. error sound.
}
}
protected override void RegisterDelegates()
{
base.RegisterDelegates();
barrageAbility.onReleaseShots += (shots) =>
{
shots.ForEach(shot =>
{
MissileController missile = shot.gameObject.FindComponent <MissileController>();
missile.Target = (Vector2)Utility.MouseWorldPos;
});
};
}
void Update()
{
if (Time.time >= (currentTime + lifetime))
{
returnToInitialPosition.ResetPosition();
// Disable current missile after effect finishes playing.
currentMissile = null;
gameObject.SetActive(false);
}
}
// Restart -resets position
public void restart()
{
if (missile != null)
{
Destroy(missile.gameObject);
missile = null;
}
Vector3 pos = transform.position;
pos.x = 0;
transform.position = pos;
}
public void TestMissileController()
{
MissileController bc = new MissileController();
try {
bc.ExplodeBullet(bc.transform.position);
}catch (Exception e) {
//Explode bullet doesn't work
Assert.True(false, "error " + e.ToString());
// Assert.True(false);
}
}
void SpawnMissile()
{
GameObject missile = (GameObject)Instantiate(MissilePrefab, MissileSpawnPoint.position, MissileSpawnPoint.rotation);
MissileController missileController = missile.GetComponent <MissileController>();
missileController.OnMissileExploded = OnMissileExploded;
missileController.TailColor = Player.Color;
Rigidbody rb = missile.GetComponent <Rigidbody>();
rb.AddForce(MissileSpawnPoint.forward * MissileForce, ForceMode.Impulse);
}
public void TestMissileController()
{
MissileController bc = new MissileController();
try {
bc.ExplodeBullet(bc.transform.position);
}catch (Exception e) {
//Explode bullet doesn't work
Assert.True(false,"error "+e.ToString());
// Assert.True(false);
}
}
void Start()
{
controller = GetComponent<MissileController>();
objPlayer = (GameObject) GameObject.FindWithTag("Player");
}
