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