public EnemyBase GetEnemy(EnemyTypeEnum type)
{
switch (type)
{
case EnemyTypeEnum.BlueVan:
return(new EnemyBase(
new EnemySettings()
{
Health = 3,
Speed = 100,
ResourcesForKilling = 1
},
"Assets\\sprite1.png",
new AnimationInfo()
{
FrameSize = new Size(32, 32),
AnimationsList = new List <Animation>()
{
new Animation(0, 3, 20f)
}
}));
default:
throw new ArgumentOutOfRangeException(nameof(type), type, null);
}
}
public EnemySpawnManager ResolveEnemySpawn(EnemyTypeEnum enemyType)
{
if (enemyType == EnemyTypeEnum.Charger)
{
return(FindObjectOfType <ChargerSpawnManager>());
}
if (enemyType == EnemyTypeEnum.Heavy)
{
return(FindObjectOfType <HeavySpawnManager>());
}
if (enemyType == EnemyTypeEnum.Light)
{
return(FindObjectOfType <LightSpawnManager>());
}
if (enemyType == EnemyTypeEnum.Standard)
{
return(FindObjectOfType <StandardSpawnManager>());
}
if (enemyType == EnemyTypeEnum.Trapper)
{
return(FindObjectOfType <TrapperSpawnManager>());
}
return(null);
}
private string GetEnemyNameFromEnum(EnemyTypeEnum enemyType)
{
switch (enemyType)
{
case EnemyTypeEnum.Enemy1:
{
return("Enemy1");
}
case EnemyTypeEnum.Enemy2:
{
return("Enemy2");
}
case EnemyTypeEnum.Enemy3:
{
return("Enemy3");
}
case EnemyTypeEnum.Enemy4:
{
return("Enemy4");
}
case EnemyTypeEnum.Enemy5:
{
return("Enemy5");
}
default:
{
throw new Exception("Unknown EnemyTypeEnum:" + enemyType);
}
}
}
private void SpawnEnemyForWaveWithType(EnemyTypeEnum type)
{
WaveEnemyConfigMetadata waveConfig = waveConfigDictionary[currentWave];
int enemyQuantity = 0;
needLevelUp = false;
switch (type)
{
case EnemyTypeEnum.AVERAGE:
enemyQuantity = waveConfig.averageEnemyQuantity;
break;
case EnemyTypeEnum.ATTACK:
enemyQuantity = waveConfig.attackEnemyQuantity;
break;
case EnemyTypeEnum.DEFEND:
enemyQuantity = waveConfig.defendEnemyQuantity;
break;
case EnemyTypeEnum.SMALL_BOSS:
enemyQuantity = waveConfig.smallBossQuantity;
if (enemyQuantity > 0)
{
needLevelUp = true;
}
break;
case EnemyTypeEnum.BIG_BOSS:
enemyQuantity = waveConfig.bigBossQuantity;
if (enemyQuantity > 0)
{
needLevelUp = true;
}
break;
}
if (enemyQuantity == 0)
{
return;
}
aliveEnemyQuantity += enemyQuantity * enemySpawnLocations.Length;
string key = GetKeyForEnemyConfig(currentWave, type);
if (!enemyConfigDictionary.ContainsKey(key))
{
Debug.LogError("Can't find " + key + " config in enemyConfigDictionary");
}
EnemyMetadata config = enemyConfigDictionary[key];
for (int i = 0; i < enemySpawnLocations.Length; i++)
{
SpawnEnemyWithConfig(enemySpawnLocations[i], enemyQuantity, config);
}
}
private void SpawnSomething()
{
if (_enemySpawner.SpawnEnemy() && _monstersLeftToSpawn.Count > 0)
{
// TODO: Create stuff based on type
EnemyTypeEnum typeToSpawn = _monstersLeftToSpawn.Dequeue();
Enemy newEnemy = _enemyFactory.CreateDefault(typeToSpawn, _settings.Waypoints);
CurrentEnemiesNew.Add(newEnemy);
}
}
public Transform GetEnemyTarget(EnemyTypeEnum enemyType)
{
if (enemyType == EnemyTypeEnum.CultistWithDog)
{
return(_zoneCenter);
}
else
{
return(_player);
}
}
public Enemy GetEnemyByType(EnemyTypeEnum enemyType)
{
var enemy = enemyPrefabs.FirstOrDefault(x => x.EnemyType == enemyType);
if (enemy == null)
{
Debug.LogError($"No enemy of type: {enemyType} was found in the enemy manager.");
}
return(enemy);
}
// Manager can be null when testing in editor mode
private Enemy GetEnemyPrefab(EnemyTypeEnum enemyType, EnemyManager manager)
{
if (manager == null)
{
return(GameUtils.GetEnemyPrefabByType(enemyType));
}
else
{
return(manager.GetEnemyByType(enemyType));
}
}
//public static T[] GetAllInstances<T>() where T : UnityEngine.Object
//{
// string[] guids = AssetDatabase.FindAssets("t:" + typeof(T).Name); //FindAssets uses tags check documentation for more info
// T[] a = new T[guids.Length];
// for (int i = 0; i < guids.Length; i++) //probably could get optimized
// {
// string path = AssetDatabase.GUIDToAssetPath(guids[i]);
// a[i] = AssetDatabase.LoadAssetAtPath<T>(path);
// }
//
// return a;
//}
// public static T[] GetAllInstances<T>() where T : UnityEngine.Object
// {
// return Resources.Load<T>();
// }
public static Enemy GetEnemyPrefabByType(EnemyTypeEnum enemyType)
{
var enemyPrefabs = Resources.LoadAll <Enemy>("").ToList();
var enemy = enemyPrefabs.FirstOrDefault(x => x.EnemyType == enemyType);
if (enemy == null)
{
Debug.LogError($"No enemy of type: {enemyType} was found in the enemy manager.");
}
return(enemy);
}
private SpriteWithDirectionsRenderer CreateSprite(EnemyTypeEnum settingsEnemyType)
{
var spriteWithDirections = new SpriteWithDirections
{
Sprites = new Dictionary <SpriteDirectionEnum, SpriteDetails>
{
{ SpriteDirectionEnum.BottomLeft, _spriteSheets.GetSprite(SpriteEnum.VehicleVanBottomLeft) },
{ SpriteDirectionEnum.BottomRight, _spriteSheets.GetSprite(SpriteEnum.VehicleVanBottomRight) },
{ SpriteDirectionEnum.TopLeft, _spriteSheets.GetSprite(SpriteEnum.VehicleVanTopLeft) },
{ SpriteDirectionEnum.TopRight, _spriteSheets.GetSprite(SpriteEnum.VehicleVanTopRight) }
}
};
return(new SpriteWithDirectionsRenderer(spriteWithDirections));
}
public static EnemySpawnData GetEnemyTypeToSpawn(int currentDifficult, EnemySpawnerResolver enemySpawnerResolver)
{
//get enemy type
EnemyTypeEnum enemyTypeToSpawn = (EnemyTypeEnum)RandomValueTool.GetRandomValue(0, _maxEnemiesTypes);
var enemySpawn = enemySpawnerResolver.ResolveEnemySpawn(enemyTypeToSpawn);
//if enemy type not for current level
if (!EnemyTypeLevel.EnemyIsAtLevel(enemyTypeToSpawn, currentDifficult) ||
!enemySpawn.CanSpawnEnemy())
{
return(GetEnemyTypeToSpawn(currentDifficult, enemySpawnerResolver));
}
return(new EnemySpawnData(enemyTypeToSpawn, enemySpawn));
}
public static EnemyType GetEnemyTypeOf(EnemyTypeEnum enemyType)
{
switch (enemyType)
{
case EnemyTypeEnum.Slime:
return(slime);
case EnemyTypeEnum.Goblin:
return(goblin);
case EnemyTypeEnum.Phoenix:
return(phoenix);
}
return(null);
}
public Enemy CreateEnemy(EnemyTypeEnum type)
{
switch (type)
{
case EnemyTypeEnum.Melee:
return(new MeleeEnemy(EnemyFactory));
case EnemyTypeEnum.Range:
return(new RangeEnemy(EnemyFactory));
case EnemyTypeEnum.Mage:
return(new MageEnemy(EnemyFactory));
default:
throw new Exception("Wrong Enemy Type");
}
}
public Enemy CreateDefault(EnemyTypeEnum enemyType, List <Point> waypoints)
{
float health;
switch (enemyType)
{
case EnemyTypeEnum.BlueVan:
health = BlueVanHealth;
break;
default:
throw new ArgumentOutOfRangeException(nameof(enemyType), enemyType, null);
}
EnemySettings enemySettings = new EnemySettings(enemyType, waypoints, health);
return(Create(enemySettings));
}
private void SpawnSomething()
{
TimeSpan nao = _time.GetCurrent();
bool isFirstSpawn = _lastSpawn == TimeSpan.MinValue;
// Spawn enemy if no enemy was spawned yet or if the time since last spawn is long enough.
bool shouldSpawnEnemy = (_lastSpawn + _settings.SpawnFrequency <= nao) || isFirstSpawn;
if (_monstersLeftToSpawn.Count > 0 && shouldSpawnEnemy)
{
EnemyTypeEnum enemyType = _monstersLeftToSpawn.Dequeue();
EnemyBase enemy = _enemyFactory.GetEnemy(enemyType);
enemy.Init();
enemy.SetLocation(_settings.SpawnPoint);
enemy.Waypoints = _settings.Waypoints;
enemy.OnDeathAction = OnEnemyDeath;
CurrentMonsters.Add(enemy);
_lastSpawn = nao;
}
}
public static int GetEnemyKind(EnemyTypeEnum enemyType, int maxVal, int currentLevel)
{
int spawnKindVal = RandomValueTool.GetRandomValue(0, maxVal);
if (enemyType == EnemyTypeEnum.Standard)
{
if (EnemyKindLevel.GetStandardKindLevel()[spawnKindVal] > currentLevel)
{
return(GetEnemyKind(enemyType, maxVal, currentLevel));
}
return(spawnKindVal);
}
if (enemyType == EnemyTypeEnum.Light)
{
if (EnemyKindLevel.GetLightKindLevel()[spawnKindVal] > currentLevel)
{
return(GetEnemyKind(enemyType, maxVal, currentLevel));
}
return(spawnKindVal);
}
if (enemyType == EnemyTypeEnum.Charger)
{
if (EnemyKindLevel.GetChargerKindLevel()[spawnKindVal] > currentLevel)
{
return(GetEnemyKind(enemyType, maxVal, currentLevel));
}
return(spawnKindVal);
}
if (enemyType == EnemyTypeEnum.Heavy)
{
if (EnemyKindLevel.GetHeavyKindLevel()[spawnKindVal] > currentLevel)
{
return(GetEnemyKind(enemyType, maxVal, currentLevel));
}
return(spawnKindVal);
}
return(spawnKindVal);
}
public EnemyMetadata(SqliteDataReader reader)
{
enemyId = reader.GetInt32(0);
waveNumber = reader.GetInt32(1);
attack = reader.GetInt32(2);
attackFrequency = reader.GetInt32(3);
hp = reader.GetInt32(4);
enemyType = convertToEnemyTypeEnum(reader.GetString(5));
attackRange = reader.GetFloat(6);
moveSpeed = reader.GetFloat(7);
searchRange = reader.GetFloat(8);
string data = reader.GetString(9).Replace("\n", string.Empty);
string[] splits = data.Split('|');
lootIds = new int[splits.Length];
for (int i = 0; i < splits.Length; i++)
{
lootIds[i] = int.Parse(splits[i]);
}
}
public void CreateEnemy(EnemyTypeEnum enemyType)
{
string enemyName = GetEnemyNameFromEnum(enemyType);
GameObject enemyPrefab = Resources.Load <GameObject>("Enemies/" + enemyName) as GameObject;
GameObject newEnemy = UnityEngine.Object.Instantiate(enemyPrefab);
var enemyParent = GameObject.Find("Enemies");
newEnemy.transform.SetParent(enemyParent.transform);
newEnemy.tag = enemyParent.tag;
SpriteRenderer spriteRendered = newEnemy.GetComponent <SpriteRenderer>();
spriteRendered.sortingOrder = (int)enemyType;
Enemy enemyScript = newEnemy.GetComponent <Enemy>();
enemyScript.Initialize(WaypointList);
EnemyList.Add(newEnemy);
}
public EnemySpawnData(EnemyTypeEnum enemyType, EnemySpawnManager enemySpawnManager)
{
this.enemyType = enemyType;
this.enemySpawnManager = enemySpawnManager;
}
public GameObject[] enemyPrefabs = new GameObject[3]; //need to adjust to enum
public GameObject RetrieveEnemyPrefab(EnemyTypeEnum enemyType)
{
GameObject go = Instantiate(enemyPrefabs[(int)enemyType]) as GameObject;
return(go);
}
public void SetType(EnemyTypeEnum typeEnum)
{
_type = typeEnum;
TypeChanged(GetComponent <Enemy>());
}
string GetMaxAmountOfEnemyType(EnemyTypeEnum enemyTypeToSpawn)
{
return(this.GetStringFieldValue("amount" + enemyTypeToSpawn.ToString()));
}
public string GetKeyForEnemyConfig(int waveNumber, EnemyTypeEnum enemyType)
{
return(waveNumber + "_" + enemyType.ToString());
}
public EnemySettings(EnemyTypeEnum enemyType, List <Point> waypoints, float health)
{
EnemyType = enemyType;
Waypoints = waypoints;
Health = health;
}
public static bool EnemyIsAtLevel(EnemyTypeEnum enemyType, int level)
{
var result = GetAllEnemiesLevels()[enemyType] <= level;;
return(result);
}
public override void DrawEditor()
{
using (new GUILayout.VerticalScope())
{
#if UNITY_EDITOR
// Draw helpbox
EditorGUILayout.HelpBox("Example of a custom class. Use GUILayout or EditorGUILayout API to draw custom editor controls.", MessageType.Info);
// Draw enemy type enum dropdown
_enemyType = (EnemyTypeEnum)EditorGUILayout.EnumPopup("Enemy Type: ", _enemyType);
#endif
// Draw health slider
using (new GUILayout.HorizontalScope())
{
#if UNITY_EDITOR
_health = EditorGUILayout.IntSlider("Health: ", _health, 0, 100);
#endif
}
// Draw strength
using (new GUILayout.HorizontalScope())
{
#if UNITY_EDITOR
_strength = EditorGUILayout.IntField("Strength:", _strength);
#endif
}
// Draw min and max speed
using (new GUILayout.VerticalScope())
{
#if UNITY_EDITOR
GUILayout.Label("min speed: " + _minSpeed + " max speed: " + _maxSpeed);
EditorGUILayout.MinMaxSlider(ref _minSpeed, ref _maxSpeed, 0f, 10f);
#endif
}
// Draw ability list
using (new GUILayout.VerticalScope("Box"))
{
GUILayout.Label("Abilities");
abilityId = GUILayout.TextField(abilityId);
if (GUILayout.Button("add"))
{
if (string.IsNullOrEmpty(abilityId))
{
return;
}
abilities.Add(new Abilities(abilityId));
}
for (int i = 0; i < abilities.Count; i++)
{
using (new GUILayout.HorizontalScope("Box"))
{
abilities[i].active = GUILayout.Toggle(abilities[i].active, abilities[i].id);
if (GUILayout.Button("x", GUILayout.Width(20)))
{
abilities.RemoveAt(i);
}
}
}
}
}
}
