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); } } } } } }