public static BaseEnemy.BaseAttributes Attributes(this EnemyTypes enemyType)
{
if (EnemyAttributes.ContainsKey(enemyType))
{
return(EnemyAttributes[enemyType]);
}
var enemyName = enemyType.ToString();
var csvEntry = GlobalContent.Enemy_Attributes[enemyName];
var enemyAttributes = new BaseEnemy.BaseAttributes()
{
Health = csvEntry.Health,
Speed = csvEntry.Speed,
BombardResist = csvEntry.BombardResist,
PiercingResist = csvEntry.PiercingResist,
ChemicalResist = csvEntry.ChemicalResist,
FrostResist = csvEntry.FrostResist,
FireResist = csvEntry.FireResist,
ElectricResist = csvEntry.ElectricResist,
};
EnemyAttributes[enemyType] = enemyAttributes;
return(enemyAttributes);
}
private void CreateAggressiveEnemy(int x, int y, EnemyTypes enemyType)
{
float waveZOffset = 6000;
float waveYOffset = 5000;
float waveOffset = 30000;
float pX = 10;
float pY = y * waveYOffset;
float pZ = camera.Position.Z + ((x * waveZOffset) - (waveIndex * waveOffset));
Enemy enemy = new Enemy(enemyType);
enemy.Initialise();
enemy.OffsetPosition = new Vector3(pX, pY, pZ);
enemy.Speed = loader.WaveInfo.Velocity;
enemy.HP = loader.WaveInfo.HP;
enemy.Attack = loader.WaveInfo.Attack;
enemy.AttackRate = loader.WaveInfo.AttackRate;
foreach (Enemy.EnemyMovement movement in loader.WaveInfo.GetWaveMovement())
{
enemy.Movement += movement;
//amtitude --?
}
enemyManager.AddEnemy(enemy);
}
public GameObject SpawnEnemy(EnemyTypes enemyType, Transform targetSpawner)
{
GameObject newEnemy;
GameObject enemyShipObject = EnemyShipLarge;
switch (enemyType)
{
case EnemyTypes.Boss:
enemyShipObject = EnemyShipBoss;
break;
case EnemyTypes.Large:
enemyShipObject = EnemyShipLarge;
break;
case EnemyTypes.Medium:
enemyShipObject = EnemyShipMedium;
break;
case EnemyTypes.Small:
enemyShipObject = EnemyShipSmall;
break;
}
newEnemy = Instantiate(enemyShipObject, targetSpawner.transform.position, targetSpawner.transform.rotation) as GameObject;
newEnemy.transform.parent = targetSpawner;
return(newEnemy);
}
public void SpawnEnemy(EnemyTypes enemyType, int pathIndex)
{
//Spawn enemy from pool and initialize it
GameObject pf = pools[enemyType].Spawn();
pf.GetComponent <Enemy>().SetPath(paths[pathIndex]);
}
public void AddEnemy(EnemyTypes type, int hitPoints, int points, int count)
{
for (int i = 0; i < count; i++)
{
_enemies.Add(new Enemy(type, hitPoints, points));
}
}
public void OnKill(EnemyTypes enemyTypes)
{
switch (enemyTypes)
{
case EnemyTypes.Tier1:
_score += (int)EnemyTypes.Tier1;
UpdateScoreUi();
break;
case EnemyTypes.Tier2:
_score += (int)EnemyTypes.Tier2;
UpdateScoreUi();
break;
case EnemyTypes.Tier3:
_score += (int)EnemyTypes.Tier3;
UpdateScoreUi();
break;
case EnemyTypes.Miniboss:
_score += (int)EnemyTypes.Miniboss;
UpdateScoreUi();
break;
case EnemyTypes.Boss:
_score += (int)EnemyTypes.Boss;
UpdateScoreUi();
break;
default:
_score += (int)EnemyTypes.Tier1;
UpdateScoreUi();
break;
}
}
public EnemyData GetEnemyDataByType(EnemyTypes type)
{
EnemyData result = null;
switch (type)
{
case EnemyTypes.t1:
result = enemy1Settings.GetEnemyData();
break;
case EnemyTypes.t2:
result = enemy2Settings.GetEnemyData();
break;
case EnemyTypes.t3:
result = enemy3Settings.GetEnemyData();
break;
default:
Debug.Log("This type is not in enemies list: " + type);
break;
}
if (result == null)
{
Debug.Log("This type is not in enemies list: " + type);
}
return(result);
}
public IEnemy CreateEnemy(EnemyTypes enemyType)
{
switch (enemyType)
{
case EnemyTypes.PowerUp:
powerupReloadClock.Restart();
return(new Enemy1(enemyTextures[(int)EnemyTypes.PowerUp]));
case EnemyTypes.Enemy2:
enemyReloadClock.Restart();
return(new Enemy2(enemyTextures[(int)EnemyTypes.Enemy2]));
case EnemyTypes.Enemy3:
enemyReloadClock.Restart();
return(new Enemy3(enemyTextures[(int)EnemyTypes.Enemy3]));
case EnemyTypes.Enemy4:
enemyReloadClock.Restart();
return(new Enemy4(enemyTextures[(int)EnemyTypes.Enemy4]));
case EnemyTypes.Boss:
return(new Boss(enemyTextures[(int)EnemyTypes.Boss],
enemyTextures[(int)EnemyTypes.Boss + 1]));
default:
throw new Exception("You tried to create non-existing enemy");
}
}
void AddEnemy(EnemyTypes type, int amount)
{
for (int i = 0; i < amount; i++)
{
Enemies.Add(type);
}
}
public EnemyManagerService(
GameObject enemyObjectPrefab,
GameObject enemyContainer,
PlayerService playerService,
EnemyService enemyService,
EnemyTurnService enemyTurnService,
StatusService statusService,
DeckService deckService,
EnemyTypes enemyTypes,
CardUiManager cardUiManager,
CardGeneratorService cardGeneratorService,
SceneUiManager sceneUiManager,
UpgradeUiManager upgradeUiManager,
UpgradeService upgradeService
)
{
this.enemyObjectPrefab = enemyObjectPrefab;
this.enemyContainer = enemyContainer;
this.enemyService = enemyService;
this.enemyTurnService = enemyTurnService;
this.statusService = statusService;
this.playerService = playerService;
this.deckService = deckService;
this.enemyTypes = enemyTypes;
this.cardUiManager = cardUiManager;
this.cardGeneratorService = cardGeneratorService;
this.sceneUiManager = sceneUiManager;
this.upgradeUiManager = upgradeUiManager;
this.upgradeService = upgradeService;
}
public static double PointValue(this EnemyTypes enemyType, SerializableChromosome chromosome)
{
if (!HasCalculatedMinimums)
{
CalculateMinimums();
}
var enemyAttributes = BaseEnemy.GetGeneticAttributes(enemyType.Attributes(), chromosome);
var healthPoints = enemyAttributes.MaximumHealth / minHealth;
var speedPoints = enemyAttributes.EffectiveSpeed / minSpeed;
var flyingPoints = enemyAttributes.IsFlying ? 1.5 : 1;
var piercePoints = enemyAttributes.EffectivePiercingResist - minPierce;
var bombardPoints = enemyAttributes.EffectiveBombardResist - minBombard;
var chemicalPoints = enemyAttributes.EffectiveChemicalResist - minChemical;
var frostPoints = enemyAttributes.EffectiveFrostResist - minFrost;
var firePoints = enemyAttributes.EffectiveFireResist - minFire;
var electricPoints = enemyAttributes.EffectiveElectricResist - minElectric;
var resistPoints = piercePoints + bombardPoints + chemicalPoints + frostPoints + firePoints +
electricPoints;
var survivalPoints = healthPoints * resistPoints;
var movePoints = speedPoints * flyingPoints;
var pointValue = survivalPoints * movePoints;
return(pointValue);
}
/// <summary>
/// Set each enemy stats here
/// </summary>
/// <param name="type"></param>
public static void SetEnemyStats(EnemyTypes type)
{
switch (type)
{
case EnemyTypes.BasicMelee:
{
BasicMelee.MaxHealth = Random.Range(100, 150);
BasicMelee.EnemyDamage = Random.Range(10, 20);
BasicMelee.EnemySpeed = Random.Range(5, 8);
BasicMelee.StoppingDistance = 1f;
break;
}
case EnemyTypes.BasicRanged:
{
BasicRanged.MaxHealth = Random.Range(75, 100);
BasicRanged.EnemyDamage = Random.Range(25, 30);
BasicRanged.EnemySpeed = Random.Range(5, 8);
BasicRanged.StoppingDistance = 7f;
break;
}
case EnemyTypes.BasicTank:
{
BasicTank.MaxHealth = Random.Range(200, 250);
BasicTank.EnemyDamage = Random.Range(5, 20);
BasicTank.EnemySpeed = Random.Range(2, 3);
BasicTank.StoppingDistance = 1f;
break;
}
default:
throw new ArgumentOutOfRangeException(nameof(type), type, null);
}
}
void InitializeGroups()
{
EnemyTypes _default = EnemyTypes.Default;
EnemyTypes _large = EnemyTypes.Large;
EnemyTypes _small = EnemyTypes.Small;
GroupType1.Name = "Group1";
for (int i = 0; i < 3; i++)
{
GroupType1.EnemyTypes.Add(_default);
}
GroupType2.Name = "Group2";
for (int i = 0; i < 3; i++)
{
GroupType2.EnemyTypes.Add(_default);
}
for (int i = 0; i < 10; i++)
{
GroupType2.EnemyTypes.Add(_small);
}
GroupType3.Name = "Group3";
for (int i = 0; i < 3; i++)
{
GroupType3.EnemyTypes.Add(_default);
}
for (int i = 0; i < 10; i++)
{
GroupType3.EnemyTypes.Add(_small);
}
GroupType3.EnemyTypes.Add(_large);
}
private static Enemy CreateEnemy(EnemyTypes type)
{
// Pass a null section so that the enemy is created in the same map section as a random zerd
switch (type)
{
case EnemyTypes.Zombie:
return(new Zombie(null));
case EnemyTypes.Dog:
return(new Dog(null));
case EnemyTypes.Demon:
return(new Demon(null));
case EnemyTypes.FrostDemon:
return(new FrostDemon(null));
case EnemyTypes.Archer:
return(new Archer(null));
case EnemyTypes.SkeletonKing:
return(new SkeletonKing(null));
}
throw new ArgumentException("Unknown Enemy ItemType");
}
//Change the texture of the model based on the enemy code
public void ChangeSkin(EnemyTypes enemyType, int code)
{
switch (enemyType)
{
case EnemyTypes.OLD_PLANE:
foreach (ModelMesh mesh in oldPlaneModel.Meshes)
{
foreach (BasicEffect effect in mesh.Effects)
{
effect.Texture = oldPlaneTextures[code];
}
}
break;
case EnemyTypes.HELICOPTER:
foreach (ModelMesh mesh in helicopterModel.Meshes)
{
foreach (BasicEffect effect in mesh.Effects)
{
effect.Texture = helicpterTextures[code];
}
}
break;
default:
break;
}
}
protected virtual void SpawnAnotherEnemy(EnemyTypes enemyType, Vector3 pos) //change to spawn enemy at point and pass a vector3
{
GameObject newRat = Instantiate(Services.EnemyManager.enemyDict[enemyType]) as GameObject;
Services.EnemyManager.enemies.Add(newRat);
newRat.transform.position = pos;
}
public Enemy CreateEnemy(EnemyTypes type, Position position, bool isInCave)
{
switch (type)
{
case EnemyTypes.Blinky:
_enemyBuilder = new BlinkyBuilder(position, isInCave);
break;
case EnemyTypes.Clyde:
_enemyBuilder = new ClydeBuilder(position, isInCave);
break;
case EnemyTypes.Inky:
_enemyBuilder = new InkyBuilder(position, isInCave);
break;
case EnemyTypes.Pinky:
_enemyBuilder = new PinkyBuilder(position, isInCave);
break;
default:
throw new ArgumentException($"Not supported player type {type}");
}
return(_enemyBuilder.Instance);
}
protected Enemy(EnemyTypes type, EnemyConstants.EnemyProperties properties, string file, int x, int y, bool isSpawned) : base(file, true)
{
Initialize(type, properties, file);
X = x;
Y = y;
IsSpawnedEnemy = isSpawned;
}
public QuestData(QuestType questType, int enemyCount, int friendlyCount, EnemyTypes presentEnemies, FriendlyTypes presentFriends)
{
Type = questType;
EnemyCount = enemyCount;
FriendlyCount = friendlyCount;
PresentEnemies = presentEnemies;
PresentFriends = presentFriends;
}
/// <summary>
/// Create an Enemy
/// </summary>
/// <param name="name">The Name of the Enemy</param>
/// <param name="agility">The Agility of the Enemy</param>
/// <param name="hitPoint">The Max Health Points of the Enemy</param>
/// <param name="enemyType">The Type of the Enemy</param>
public Enemy(String name, int agility, int hitPoint, EnemyTypes enemyType)
{
this.Name = name;
this.BaseAgility = agility;
this.ActualHitPoint = hitPoint;
this.MaxHitPoint = hitPoint;
this.ClassType = enemyType;
}
public static EnemyBase ProvideEnemy(EnemyTypes enemyType, LevelLoader loader)
{
foreach (EnemyBase enemy in enemies)
{
if (enemy.CurrentState is EnemyState_dead)
{
switch (enemyType)
{
case EnemyTypes.Herd:
if (enemy is EnemyHerd)
{
return(enemy);
}
break;
case EnemyTypes.Loner:
if (enemy is EnemyLoner)
{
return(enemy);
}
break;
case EnemyTypes.Stalker:
if (enemy is EnemyStalker)
{
return(enemy);
}
break;
}
}
}
EnemyBase newEnemy;
GameObject enemyObj = GameObject.Instantiate(loader.ghostPrefab);
switch (enemyType)
{
case EnemyTypes.Herd:
newEnemy = enemyObj.AddComponent <EnemyHerd> ();
enemyObj.GetComponent <SpriteRenderer>().color = new Color(1, 1, 0);
break;
case EnemyTypes.Loner:
newEnemy = enemyObj.AddComponent <EnemyLoner> ();
enemyObj.GetComponent <SpriteRenderer>().color = new Color(0, 0, 1);
break;
case EnemyTypes.Stalker:
newEnemy = enemyObj.AddComponent <EnemyStalker> ();
enemyObj.GetComponent <SpriteRenderer>().color = new Color(1, 0, 0);
break;
default:
throw new System.ArgumentException("This enemytype has not been defined");
}
enemies.Add(newEnemy);
return(newEnemy);
}
private HashSet <BaseEnemyController> GetListEnemies(EnemyTypes type)
{
if (!_enemyPool.ContainsKey(type))
{
_enemyPool[type] = new HashSet <BaseEnemyController>();
}
return(_enemyPool[type]);
}
public Enemy GetPrefab_Enemy(EnemyTypes type)
{
if (m_Enemies.ContainsKey(type))
{
return(m_Enemies[type].Prefab);
}
return(null);
}
public void Death(EnemyTypes enemyType)
{
Destroy(this.gameObject, 2);
EnemyManager.Instance.CreateOneEnemy(enemyType);
if (enemyType == TaskManager.Instance.currentTask.EffectEnemyType)
{
TaskManager.Instance.GoingTask();
}
}
public GameObject ReturnEnemyData(EnemyTypes aEnemyType, string sourceName = "Global")
{
if (m_Enemys.ContainsKey(aEnemyType))
{
return(m_Enemys[aEnemyType]);
}
return(null);
}
public void CreateOneEnemy(EnemyTypes enemyType)
{
EnemyBirthInfo enemyInfo = GetBirthInfoByEnemyTypes(enemyType);
GameObject pre = Resources.Load <GameObject>(enemyInfo.EnemyPrefabsPath);
GameObject go = GameObject.Instantiate(pre, enemyInfo.EnemySpawnPos, Quaternion.identity);
go.GetComponent <Enemy>().SetEnemyInfo(enemyInfoList[enemyInfo.EnemyID]);
enemyGameObject.Add(go);
}
public EnemyData(EnemyTypes _enemyType, float _health, float _speed, float _damage, int _minReward, int _maxReward)
{
enemyType = _enemyType;
health = _health;
speed = _speed;
damage = _damage;
minReward = _minReward;
maxReward = _maxReward;
}
public void AddLateSpawnedEnemy(EnemyTypes enemyType, GameObject enemyObj)
{
Stack <GameObject> dummyStack;
if (spawnedEnemies.TryGetValue(enemyType, out dummyStack))
{
dummyStack.Push(enemyObj);
}
}
public float getWalkSpeed(EnemyTypes type)
{
switch (type) {
case EnemyTypes.Guard : return guardWalkSpeed;
case EnemyTypes.Captain : return captainWalkSpeed;
case EnemyTypes.Enforcer : return enforcerWalkSpeed;
case EnemyTypes.Boss : return bossWalkSpeed;
}
return 0;
}
public float getRunSpeed(EnemyTypes type)
{
switch (type) {
case EnemyTypes.Guard : return guardRunSpeed;
case EnemyTypes.Captain : return captainRunSpeed;
case EnemyTypes.Enforcer : return enforcerRunSpeed;
case EnemyTypes.Boss : return bossRunSpeed;
}
return 0;
}
private void CheckType()
{
if (gameObject.tag == "Melee")
type = EnemyTypes.MELEE;
if (gameObject.tag == "Range")
type = EnemyTypes.RANGE;
if (gameObject.tag == "Boss")
type = EnemyTypes.BOSS;
health = (int)type;
}
public void SetEnemyType(string _setEnemyType)
{
switch (_setEnemyType)
{
case "EnemyTest":
enemyType = EnemyTypes._TestEnemy;
break;
}
}
void Start()
{
// audioSource = gameObject.AddComponent<AudioSource>();
enemyAnimator = GetComponent <EnemyAnimations>();
enemyTypeDamage = GetComponent <EnemyTypes>();
enemySound = GetComponent <EnemySoundEffect>();
// player = GameObject.FindWithTag("PlayerFPS").transform;
player = GameObject.FindWithTag("PlayerScripts").transform;
timeBtwShots = startTimeBtwShots;
}
public GameObject CreateEnemy(Vector2 pos, EnemyTypes et){
if (InactiveObjs.Count == 0)
return null;
GameObject temp = (GameObject)InactiveObjs [0];
InactiveObjs.Remove (temp);
temp.SetActive(true);
ActiveObjs.Add (temp);
temp.rigidbody2D.position = pos;
if (et == EnemyTypes.Walker)
temp.GetComponent<Walker> ().Init ();
else if (et == EnemyTypes.Flyer)
temp.GetComponent<Flyer> ().Init ();
return temp;
}
public Enemy(EnemyTypes etype, Scene scene, IMap map)
: base(scene.Game, TextureEnemy(scene.Game, etype))
{
this.scene = scene;
this.map = map;
this.etype = etype;
this.SpriteBatch = scene.currentSpriteBatch;
Collidable = true;
maxSpeed = (float)(map.MaxSpeed * 0.85);
minSpeed = (float)(map.MaxSpeed * 0.15);
int TheSeed = (int)DateTime.Now.Ticks;
random = new Random(TheSeed);
LaneChanger = false;
InitBehavior();
sortChange = random.Next(100, 300);
}
void Summon(EnemyTypes monsterType)
{
throw new NotImplementedException();
}
public Enemy(EnemyTypes type, int hitPoints, int points)
{
EnemyType = type;
HP = hitPoints;
Points = points;
}
public void SpawnEnemy(EnemyTypes type, EnemyUpgrade upgrade, int count)
{
if (MapSystemScript.instance.EnemiesEnabled())
{
Vector3 playerPos = player.transform.position;
for (int i = 0; i < count; ++i)
{
Vector3 spawnPos = MapSystemScript.instance.GetCurrentLevel().GetComponent<LevelScript>().GetRandomSpawnPoint().transform.position;
//MapInfo.GetRandomPointOnMap();
//while (Mathf.Abs(playerPos.x - spawnPos.x) <= minimumSpawnRange || Mathf.Abs(playerPos.z - spawnPos.z) <= minimumSpawnRange)
//{
// spawnPos = MapInfo.GetRandomPointOnMap();
//}
switch (type)
{
case (EnemyTypes.Debugging):
ObjectFactory.CreateDebugEnemy(spawnPos);
break;
case (EnemyTypes.Chaser):
ObjectFactory.CreateEnemyChaser(spawnPos, upgrade);
break;
case (EnemyTypes.Bouncer):
ObjectFactory.CreateEnemyBouncer(spawnPos, upgrade);
break;
case (EnemyTypes.Charger):
ObjectFactory.CreateEnemyCharger(spawnPos, upgrade);
break;
case (EnemyTypes.Sniper):
ObjectFactory.CreateEnemySniper(spawnPos, upgrade);
break;
case (EnemyTypes.Healer):
ObjectFactory.CreateEnemyHealer(spawnPos, upgrade);
break;
case (EnemyTypes.Spawner):
ObjectFactory.CreateEnemySpawner(spawnPos, upgrade);
break;
case (EnemyTypes.Boss):
{
switch (Random.Range(0, 2))
{
case 0:
ObjectFactory.CreateEnemySniperBoss(spawnPos, upgrade);
break;
case 1:
ObjectFactory.CreateEnemyChaserBoss(spawnPos, upgrade);
break;
case 2:
ObjectFactory.CreateEnemySpawnerBoss(spawnPos, upgrade);
break;
}
}
break;
default:
break;
}
}
}
}
public void AddEnemy(EnemyTypes type, int hitPoints, int points, int count)
{
for (int i = 0; i < count; i++)
{
_enemies.Add(new Enemy(type, hitPoints, points));
}
}
private void spawnMonster(bool eastOrNorth, TerrainType currentTT, string enemyPrefab, EnemyTypes enemyType)
{
TileStruct tile = null;
if (Width > Height)
{
if (!eastOrNorth) tile = ObjectPlacer.findAvailableTile(this, -30, 0);
else tile = ObjectPlacer.findAvailableTile(this, 30, 0);
}
else
{
if (!eastOrNorth) tile = ObjectPlacer.findAvailableTile(this, 0, -30);
else tile = ObjectPlacer.findAvailableTile(this, 0, 30);
}
var obj = (GameObject)Instantiate(Resources.Load(enemyPrefab), new Vector3(tile.X * 3.2f, tile.Y * 3.2f, -0.15f), Quaternion.identity);
obj.GetComponent<EnemyRandomizer>().RandomizeFrames(enemyType, currentTT);
obj.GetComponent<BaseEnemy>().terrainType = currentTT;
monsters.Add(obj);
}
public void SetActive( EnemyTypes type )
{
tile.material.color = type == enemyType? on : off;
}
public static Texture2D TextureEnemy(Game game, EnemyTypes etype)
{
switch (etype)
{
case EnemyTypes.Inimigo1:
return game.Content.Load<Texture2D>("Textures/carroInimigo1");
case EnemyTypes.Inimigo2:
return game.Content.Load<Texture2D>("Textures/carroInimigo2");
case EnemyTypes.Inimigo3:
return game.Content.Load<Texture2D>("Textures/carroInimigo3");
case EnemyTypes.Inimigo4:
return game.Content.Load<Texture2D>("Textures/carroInimigo4");
case EnemyTypes.Inimigo5:
return game.Content.Load<Texture2D>("Textures/carroInimigo5");
case EnemyTypes.Inimigo6:
return game.Content.Load<Texture2D>("Textures/carroInimigo6");
case EnemyTypes.Inimigo7:
return game.Content.Load<Texture2D>("Textures/carroInimigo7");
case EnemyTypes.Inimigo8:
return game.Content.Load<Texture2D>("Textures/carroInimigo8");
default:
return game.Content.Load<Texture2D>("Textures/carSprite");
}
}
void Select( EnemyTypes type )
{
selection = type;
UI.SetSelection( selection );
}
public static void SetSelection( EnemyTypes type )
{
ins.Select( type );
}
public EnemySpriteKey(int frame, EnemyTypes enemyType, TerrainType variation)
{
this.Frame = frame;
this.EnemyType = enemyType;
this.Variation = variation;
}
public void RandomizeFrames(EnemyTypes typeOfEnemy, TerrainType associatedTType)
{
sprites[0] = TerrainTypeDict[new EnemySpriteKey(0, typeOfEnemy, associatedTType)];
sprites[1] = TerrainTypeDict[new EnemySpriteKey(1, typeOfEnemy, associatedTType)];
}
