public EnemyShipController PrefabInstantiate(PlanetController planet, Vector2 orbit, Vector2 position, bool immobile)
{
EnemyShipController ship = ((GameObject)Object.Instantiate(gameObject)).GetComponent <EnemyShipController>();
FlyController fly = ship.GetComponent <FlyController>();
PointGravityController pgrav = ship.GetComponent <PointGravityController>();
HullController hull = ship.GetComponent <HullController>();
Animator anim = ship.GetComponent <Animator>();
ship.PrefabName = name;
if (immobile)
{
ship.state = Modes.Appearing;
ship.GetComponent <Rigidbody2D>().isKinematic = hull.InitialShieldPower > 0;
ship.transform.position = orbit;
fly.enabled = false;
pgrav.enabled = false;
GetComponent <Collider2D>().enabled = false;
anim.SetTrigger("Appear");
}
else
{
ship.state = Modes.Flying;
fly.PrepareFly(orbit, planet);
ship.transform.position = position;
}
ship.Planet = planet;
return(ship);
}
private Vector2 ToLocalPositionHorizontal(EnemyShipController enemy, Vector2 pointToMove)
{
Vector2 point = pointToMove;
point.y = enemy.transform.localPosition.y;
return(point);
}
public void DoSpawnEnemy(EnemyShipController prefab, float low, float high, bool immobile, bool easy)
{
float angle = 0;
if (easy == false)
{
if (Random.Range(0f, 1f) < 0.5f)
{
angle = Random.Range(0f, 150f);
}
else
{
angle = Random.Range(210f, 359f);
}
}
else
{
if (Random.Range(0f, 1f) < 0.5f)
{
angle = Random.Range(0f, 75f);
}
else
{
angle = Random.Range(285f, 359f);
}
}
Vector2 orbit = new Vector2(0, Random.Range(low, high)).Rotate(angle);
Vector2 trace = new Vector2(orbit.y, -orbit.x).normalized *300;
EnemyShipController ship = prefab.PrefabInstantiate(Planet, (Vector2)Planet.transform.position + orbit, (Vector2)Planet.transform.position + trace, immobile);
}
//Losowe generowanie przeciwników przy aktywacji rzędu
private void OnEnable()
{
float posY = transform.position.y - (EnemyRows);
for (int n = 0; n < TotalEnemyInLine; n++)
{
Vector2 posX = new Vector2(transform.position.x + (EnemyColumns * n), posY);
Quaternion rot = new Quaternion(0, 0, 180, Quaternion.identity.w);
GameObject GO = objectPooler.SpawnFromPool(objectPooler.enemyList[(int)Random.Range(0, objectPooler.enemyList.Count)], posX, rot);
shipName = GO.name;
shipController = GO.GetComponent <EnemyShipController>();
if (shipName.StartsWith("small"))
{
shipController.hp = StaticDifficulty.SmallEnemyHP;
}
else if (shipName.StartsWith("medium"))
{
shipController.hp = StaticDifficulty.MediumEnemyHP;
}
else if (shipName.StartsWith("large"))
{
shipController.hp = StaticDifficulty.LargeEnemyHP;
}
GO.transform.SetParent(this.transform);
}
}
void Update()
{
if (!PlayerPrefs.HasKey(CheckpointName))
{
GameObject.Destroy(gameObject);
return;
}
try
{
StringReaderEx str = new StringReaderEx(PlayerPrefs.GetString(CheckpointName));
int enemiesCount = str.ReadLineInt();
Debug.Log("Load: enemies = " + enemiesCount);
for (int i = 0; i < enemiesCount; i++)
{
string prefabName = str.ReadLine();
string path = prefabName;
GameObject prefab = (GameObject)Resources.Load(path, typeof(GameObject));
Debug.Log("path: " + path + ", val=" + (prefab == null));
EnemyShipController ship = ((GameObject)GameObject.Instantiate(prefab)).GetComponent <EnemyShipController>();
ship.PrefabName = prefabName;
//ship.transform.position = str.ReadLineVector3();
//LoadObject(str,ship.gameObject);
ObjectSerializer.LoadObject(str, ship.gameObject);
//LoadClass<EnemyShipController>(str,ship);
//EnemyShipController enemy = GameObject.Instantiate()
}
PlanetController planet = GameObject.FindGameObjectWithTag("Planet").GetComponent <PlanetController>();
ObjectSerializer.LoadObject(str, planet.gameObject);
ObjectSerializer.LoadObject(str, planet.Gun.gameObject);
UIController ui = GameObject.Find("UICanvas").GetComponent <UIController>();;
ObjectSerializer.LoadComponent(str, ui.HpBar);
ObjectSerializer.LoadComponent(str, ui.Score);
ObjectSerializer.LoadComponent(str, planet.Multiplier.Indicator);
EnemyGeneratorController eg = GameObject.Find("EnemyGenerator").GetComponent <EnemyGeneratorController>();
ObjectSerializer.LoadComponent(str, eg);
StageController[] stages = eg.GetComponentsInChildren <StageController>(true);
foreach (StageController s in stages)
{
ObjectSerializer.LoadObject(str, s.gameObject);
}
}
catch (Exception e)
{
Debug.LogError("Exception while trying to load level: " + e.ToString());
}
GameObject.Destroy(gameObject);
}
public void RemoveEnemyShip(EnemyShipController enemyShip)
{
if (enemyShip == null || !_enemyShips.Contains(enemyShip))
{
return;
}
_enemyShips.Remove(enemyShip);
}
public void AddEnemyShip(EnemyShipController enemyShip)
{
if (enemyShip == null || _enemyShips.Contains(enemyShip))
{
return;
}
_enemyShips.Add(enemyShip);
}
private void OnTriggerEnter(Collider other)
{
EnemyShipController enemyShipController = other.GetComponent <EnemyShipController>();
if (enemyShipController != null)
{
CollideWithEnemyShip(enemyShipController);
}
}
public void OnExit(ShipController controller)
{
controller.NavMeshAgent.isStopped = false;
EnemyShipController enemyShip = (EnemyShipController)controller;
if (enemyShip != null)
{
enemyShip.FreezeObject.SetActive(false);
}
}
public void OnEnter(ShipController controller)
{
_timer = 0.0f;
controller.NavMeshAgent.isStopped = true;
EnemyShipController enemyShip = (EnemyShipController)controller;
if (enemyShip != null)
{
enemyShip.FreezeObject.SetActive(true);
}
}
public void EnemyDie(EnemyShipController controller)
{
gameStateManager.UpdateScore(controller.ShipPoints());
aliveEnemies.Remove(controller);
enemyFactory.Remove(controller);
if (aliveEnemies.Count == 0)
{
NextLevel();
}
}
private EnemyShipController CreateEnemyFromTemplate(EnemyData enemyData, Vector2 initializePosition)
{
ObjectPool pool = PoolForEnemyData(enemyData);
pool.objectToInstantion = enemyData.enemyPrefab.gameObject;
EnemyShipController enemy = pool.ObjectFromPool().GetComponent <EnemyShipController>();
enemy.isDying = false;
enemy.transform.SetParent(enemiesContainer.transform);
enemy.transform.localPosition = initializePosition;
enemy.Initialize(enemyData);
return(enemy);
}
public void OnEnter(ShipController controller)
{
controller.transform.parent = _target.transform;
controller.NavMeshAgent.enabled = false;
EnemyShipController enemy = _target.GetNearestShip(controller.transform.position);
if (enemy != null)
{
controller.SetState(new Attack(enemy, this));
return;
}
}
public void OnUpdate(ShipController controller)
{
EnemyShipController enemy = _target.GetNearestShip(controller.transform.position);
if (enemy != null)
{
controller.SetState(new Attack(enemy, this));
return;
}
Vector3 targetForward = (controller.transform.position - _target.transform.position);
targetForward.y = 0.0f;
controller.RotateTowards(targetForward.normalized);
}
private void InitializeLevel()
{
aliveEnemies.ForEach(enemy => enemyFactory.Remove(enemy));
aliveEnemies.Clear();
for (int i = 0; i < horizontalAmount; i++)
{
for (int j = 0; j < enemyToFloor.Count; j++)
{
string enemyTypeOnLevel = enemyToFloor.Find(floorSetting => floorSetting.level == j).enemyName;
Vector2 position = gameStateManager.PositionForEnemy(i, j);
EnemyShipController enemyShip = enemyFactory.CreateEnemy(enemyTypeOnLevel, position);
enemyShip.RegisterObserver(this);
aliveEnemies.Add(enemyShip);
}
}
currentDirection = 1;
InvokeRepeating("SpawnSpecialEnemy", timeToSpecialEnemyAppears, timeToSpecialEnemyAppears);
}
public EnemyShipController GetNearestShip(Vector3 position)
{
EnemyShipController nearestEnemy = null;
float minDistance = float.MaxValue;
int enemyShipsLength = _enemyShips.Count;
if (enemyShipsLength > 0)
{
for (int i = 0; i < enemyShipsLength; ++i)
{
float distance = Vector3.Distance(_enemyShips[i].transform.position, position);
if (distance < minDistance)
{
minDistance = distance;
nearestEnemy = _enemyShips[i];
}
}
}
return(nearestEnemy);
}
public void Remove(EnemyShipController enemyShip)
{
EnemyData enemyData = enemyDatabase.Find(enemy => enemy.enemyName == enemyShip.shipName);
PoolForEnemyData(enemyData).AddToPool(enemyShip.gameObject);
}
private void SpawnEnemyShip()
{
Planet planetToAttack = _levelManager.GetPlanetToAttack();
if (planetToAttack == null)
{
return;
}
Vector3 planetScreenPosition = Camera.main.WorldToScreenPoint(planetToAttack.transform.position);
Vector2 xSpawnRange = new Vector2(0.0f, Screen.width);
Vector2 ySpawnRange = new Vector2(0.0f, Screen.height);
SpawnArea spawnArea = SpawnArea.BOTTOM;
if (planetScreenPosition.x > Screen.width * 0.5f)
{
xSpawnRange.x = Screen.width * 0.5f;
spawnArea = SpawnArea.RIGHT;
}
else
{
xSpawnRange.y = Screen.width * 0.5f;
spawnArea = SpawnArea.LEFT;
}
if (planetScreenPosition.y > Screen.height * 0.5f)
{
ySpawnRange.x = Screen.height * 0.5f;
spawnArea |= SpawnArea.BOTTOM;
}
else
{
ySpawnRange.y = Screen.height * 0.5f;
spawnArea |= SpawnArea.TOP;
}
Vector3 spawnScreenPosition = new Vector3(Random.Range(xSpawnRange.x, xSpawnRange.y), Random.Range(ySpawnRange.x, ySpawnRange.y), Camera.main.transform.position.y);
Rect rectangle = new Rect(xSpawnRange.x, ySpawnRange.x, xSpawnRange.y - xSpawnRange.x, ySpawnRange.y - ySpawnRange.x);
switch (spawnArea)
{
case SpawnArea.TOP_LEFT:
{
Vector2 diagonal = new Vector2(xSpawnRange.y - xSpawnRange.x, ySpawnRange.y - ySpawnRange.x);
if (IsPointAboveDiagonal(rectangle, diagonal, spawnScreenPosition))
{
spawnScreenPosition.y = -20.0f;
}
else
{
spawnScreenPosition.x = -20.0f;
}
}
break;
case SpawnArea.TOP_RIGHT:
{
Vector2 diagonal = new Vector2(xSpawnRange.y - xSpawnRange.x, ySpawnRange.x - ySpawnRange.y);
if (IsPointAboveDiagonal(rectangle, diagonal, spawnScreenPosition))
{
spawnScreenPosition.y = -20.0f;
}
else
{
spawnScreenPosition.x = Screen.width + 20.0f;
}
}
break;
case SpawnArea.BOTTOM_LEFT:
{
Vector2 diagonal = new Vector2(xSpawnRange.y - xSpawnRange.x, ySpawnRange.y - ySpawnRange.x);
if (IsPointAboveDiagonal(rectangle, diagonal, spawnScreenPosition))
{
spawnScreenPosition.y = Screen.height + 20.0f;
}
else
{
spawnScreenPosition.x = -20.0f;
}
}
break;
case SpawnArea.BOTTOM_RIGHT:
{
Vector2 diagonal = new Vector2(xSpawnRange.y - xSpawnRange.x, ySpawnRange.x - ySpawnRange.y);
if (IsPointAboveDiagonal(rectangle, diagonal, spawnScreenPosition))
{
spawnScreenPosition.y = Screen.height + 20.0f;
}
else
{
spawnScreenPosition.x = Screen.width + 20.0f;
}
}
break;
default:
Debug.LogError("This should not happen");
return;
}
Vector3 spawnPosition = Camera.main.ScreenToWorldPoint(spawnScreenPosition);
spawnPosition.y = 0.0f;
float randomValue = Random.Range(0.0f, 1.0f);
for (int i = 0; i < _enemyShips.Count; ++i)
{
if (randomValue <= _enemyShips[i].Chance)
{
EnemyShipController spawnedEnemy = _enemyShips[i].Spawn();
spawnedEnemy.transform.position = spawnPosition;
spawnedEnemy.SetPlanetToAttack(planetToAttack);
spawnedEnemy.SetState(new ShipStates.GoToPlanet(planetToAttack, new ShipStates.AttackPlanet(planetToAttack)));
return;
}
}
}
private void CollideWithEnemyShip(EnemyShipController enemyShipController)
{
enemyShipController.HitIsland();
}
