public static Enemy CreateEnemy(Vector2 position, EnemyType type, int level, Room room)
{
Enemy enemy = Room.CreateObject (RoomObjectType.Enemy, position, null, room) as Enemy;
enemy.enemyType = type;
enemy.level = level;
return enemy;
}
public GameObject GetPrefab(EnemyType en, int level)
{
if (en != EnemyType.Door && level == 0)
return null;
switch (en)
{
case EnemyType.Scarab:
if (allScarabs[level - 1] == null)
Debug.LogError("Prefab Missing from EnmeyManager", allScarabs[level - 1]);
return allScarabs[level - 1];
case EnemyType.Spider:
if (allSpiders[level - 1] == null)
Debug.LogError("Prefab Missing from EnmeyManager", allSpiders[level - 1]);
return allSpiders[level - 1];
case EnemyType.Snake:
if (allSnakes[level - 1] == null)
Debug.LogError("Prefab Missing from EnmeyManager", allSnakes[level - 1]);
return allSnakes[level - 1];
case EnemyType.Eye:
if (allEyes[level - 1] == null)
Debug.LogError("Prefab Missing from EnmeyManager", allEyes[level - 1]);
return allEyes[level - 1];
case EnemyType.Door:
return m_doors;
default:
Debug.LogError("Prefab Unknown to EnemyManager");
return null;
}
}
public Enemy(EnemyType type)
{
Width = 64;
Height = 64;
ZIndex = 1;
switch (type)
{
case EnemyType.BALLOOM:
Sprite = new Sprite(AssetManager.Textures["balloom"], 64, 64, 0, 6);
speed = 80;
points = 100;
wallpass = false;
break;
}
Tile tile;
do
{
tile = LevelManager.CurrentLevel.GetTile(Blackboard.Random.Next(1, 30), Blackboard.Random.Next(1, 12));
}
while (tile.Solid);
destination = tile;
Position = tile.Position;
EntityManager.Spawn(this);
}
public static Enemy GetEnemy(EnemyType type, float x, float y)
{
if (type == EnemyType.SimpleEnemy) {
return (Enemy)new SimpleEnemy (x, y);
}
return null;
}
public Spider(EnemyType type, Vector2 position, Rectangle loc, Texture2D sheet, int scene)
: base(type, position, sheet, scene)
{
spawnLocation = loc;
numFrames = 7;
animTime = 50;
isAnimating = true;
animFrame = 0;
Speed = 2f;
frameSize = new Vector2(64,64);
frameOffset = new Vector2(32, 32);
hitRadius = 25;
centerOffestLength = 0;
fireRate = 2000;
fireCountdown = 0;
HP = 15;
Target = NewTargetLocation();
}
public static int getModifier(WeaponType weaponType, EnemyType enemyType)
{
if (weaponType == WeaponType.BARE_HANDS) {
if (enemyType == EnemyType.Spider) {
return 1;
} else if (enemyType == EnemyType.Zombie) {
return -1;
} else {
return 0;
}
} else if (weaponType == WeaponType.STAFF) {
if (enemyType == EnemyType.Spider) {
return -1;
} else if (enemyType == EnemyType.Zombie) {
return 0;
} else {
return 1;
}
} else if (weaponType == WeaponType.SWORD) {
if (enemyType == EnemyType.Spider) {
return 0;
} else if (enemyType == EnemyType.Zombie) {
return 1;
} else {
return -1;
}
} else {
return 0;
}
}
//Color Color)
public Enemy(Texture2D Texture, Vector2 Position, EnemyType Enemytype)
{
Type = Enemytype;
position = Position;
animator = new Animator(Texture, 2, 35, 55, 1, 2);
//color = Color;
}
public Quest (string title, string description, int rank, EnemyType enemyType, List<Sprite> winImages) {
this.title = title;
this.description = description;
this.rank = rank;
this.enemyType = enemyType;
this.winImages = winImages;
}
public Wave(EnemyType enemyType, float spawnDelay, int numberOfEnemies)
{
bossType = BossType.Max;
this.enemyType = enemyType;
this.spawnDelay = spawnDelay;
this.numberOfEnemies = numberOfEnemies;
}
private EnemyType type; //定义敌人的类型
#endregion Fields
#region Constructors
public Enemy(EnemyType type, int x, int y, DIRECTION direct)
: base(x, y, GetLife(type), GetSpeed(type), GetPower(type), direct)
{
this.type = type;
this.Width = 60;
this.Height = 60;
}
public Wave(BossType bossType, float spawnDelay, int numberOfEnemies)
{
enemyType = EnemyType.Max;
this.bossType = bossType;
this.spawnDelay = spawnDelay;
this.numberOfEnemies = numberOfEnemies;
}
public Boss(EnemyType type, Vector2 position, Texture2D sheet, List<Point> path, bool loop, int pathnode, int scene)
: base(type, position, sheet, path, loop, pathnode, scene)
{
numFrames = 2;
animTime = 50;
isAnimating = true;
Speed = 0f;
frameSize = new Vector2(128,128);
frameOffset = new Vector2(64, 125);
hitRadius = 30 * scale;
centerOffestLength = 32 * scale;
fireRate = 50;
fireCountdown = 50;
HP = 150;
jeepSound = AudioController.effects["truck"].CreateInstance();
jeepSound.Volume = 0f;
jeepSound.IsLooped = true;
jeepSound.Play();
}
public void addEnemy(EnemyType type, Position pos, int lifetime = 10 * 1000, int maxDimensionOfMovement = int.MaxValue)
{
Enemy n;
switch (type)
{
case EnemyType.ZigZag0:
{
n = new ZigZag(type, pos, 0, lifetime, maxDimensionOfMovement);
break;
}
case EnemyType.ZigZag1:
{
n = new ZigZag(type, pos, 1, lifetime, maxDimensionOfMovement);
break;
}
case EnemyType.StraightLine:
{
n = new StraightLineEnemy(type, pos, lifetime, maxDimensionOfMovement);
break;
}
default:
{
throw new NotImplementedException();
}
}
enemies.Add(n);
}
public void BuildEnemy(EnemyType type) {
GameObject x;
switch (type) {
case EnemyType.SKELETON:
x = Instantiate(Skeleton, Vector3.zero, Quaternion.identity) as GameObject;
break;
case EnemyType.RANGER:
x = Instantiate(Ranger, Vector3.zero, Quaternion.identity) as GameObject;
break;
case EnemyType.CROSSBOW:
x = Instantiate(CrossBow, Vector3.zero, Quaternion.identity) as GameObject;
break;
case EnemyType.MAGE:
x = Instantiate(Mage, Vector3.zero, Quaternion.identity) as GameObject;
break;
case EnemyType.ORC:
x = Instantiate(Orc, Vector3.zero, Quaternion.identity) as GameObject;
break;
default:
x = Instantiate(Skeleton, Vector3.zero, Quaternion.identity) as GameObject;
break;
}
x.GetComponent<EnemyBasicScript>().initialize(this);
x.transform.parent = transform;
x.gameObject.tag = Tags.Enemy;
x.SetActive(false);
pool.Add(x);
enemies++;
}
public RopeDude(EnemyType type, Vector2 position, Texture2D sheet, int scene)
: base(type, position, sheet, scene)
{
numFrames = 1;
animTime = 100;
isAnimating = false;
animFrame = 5;
Speed = 0.02f;
frameSize = new Vector2(16,16);
frameOffset = new Vector2(8, 0);
hitRadius = 10;
centerOffestLength = -8;
fireCountdown = 2000;
HP = 2;
ropeLengthMax = 100f + ((float)EnemyController.randomNumber.NextDouble() * 150f);
ropeLength = 0;
Target = Position + new Vector2(0, ropeLengthMax);
anchorPosition = Position;
}
public Boat(EnemyType type, Vector2 position, Texture2D sheet, int scene)
: base(type, position, sheet, scene)
{
spawnPosition = position;
numFrames = 1;
animTime = 50;
isAnimating = true;
animFrame = 0;
Speed = 0.003f;
frameSize = new Vector2(64,64);
frameOffset = new Vector2(32, 20);
hitRadius = 25;
centerOffestLength = 0;
fireRate = 50;
fireCountdown = 50;
HP = 20;
Target = GameManager.Hero.Position + Helper.AngleToVector(GameManager.Hero.spriteRot, 400f);
chopperSound = AudioController.effects["boat"].CreateInstance();
chopperSound.Volume = 0f;
chopperSound.IsLooped = true;
chopperSound.Play();
}
void UpdateProperties ()
{
EnemyType = (EnemyType)Type;
_speed = Speed;
_rotateClockWise = (ClockwiseRotation == 0) ? true : false;
_pathLength = PathLength;
}
public static Enemy Create(EnemyType enemyType, int level)
{
Enemy newEnemy;
switch (enemyType)
{
case EnemyType.Archer:
newEnemy = new Archer(_content, _graphics) { Level = level };
break;
case EnemyType.Guard:
newEnemy = new Guard(_content, _graphics) { Level = level };
break;
case EnemyType.Wizard:
newEnemy = new Wizard(_content, _graphics) { Level = level };
break;
case EnemyType.Soul:
newEnemy = new Soul(_content, _graphics);
break;
default:
throw new InvalidEnemyException(enemyType);
}
newEnemy.Load();
return newEnemy;
}
// make a new enemy and apply given rotation if applyRotation is set
public GameObject CreateEnemy(EnemyType enemyType, Vector3 position, Quaternion rotation)
{
GameObject enemyObject;
GameObject enemyPrefab;
// add enemycount
currentEnemyCount++;
// select correct prefab by enemy type
switch(enemyType) {
case EnemyType.LIZARD:
enemyPrefab = lizardPrefab;
break;
case EnemyType.WEREWOLF:
enemyPrefab = wolfPrefab;
break;
case EnemyType.ORC:
default:
enemyPrefab = orcPrefab;
break;
}
//if rotation is not set to null, apply it
if (rotation != Quaternion.identity){
enemyObject = (GameObject)Instantiate(enemyPrefab, position, rotation);
// else use prefabs rotation
} else {
enemyObject = (GameObject)Instantiate(enemyPrefab, position, enemyPrefab.transform.rotation);
}
return enemyObject;
}
public void spawnEnemy(EnemyType type, SpawnSide side)
{
Enemy enemy = EnemiesPool.pool.getEnemy(type);
enemy.transform.position = getSpawnPosition(side);
enemy.transform.rotation = Quaternion.identity;
enemy.gameObject.SetActive (true);
}
public override void Load()
{
GameManager.LevelBorderSize = new Vector2(250, 250);
GameManager.BulletLayer = new Layer();
GameManager.UILayer = new Layer();
GameManager.UILayer.Depth = 0.8f;
DamageIndicator.Initialize(GameManager.UILayer);
this.Level = new Level();
this.Player = new Player(GameManager.BulletLayer);
this.Player.Position = new Vector2(32, 0);
this.Director = new Director(this.Player, this.Level, GameManager.BulletLayer);
this.AddChild(this.Level);
this.AddChild(Player);
this.AddChild(GameManager.BulletLayer);
this.AddChild(GameManager.UILayer);
GameManager.currentDrawCamera.followNode = this.Player;
this.SpawnPlayer();
Enemy.Players = new List<Player>(4);
Enemy.Players.Add(this.Player);
EnemyType enemyType = new EnemyType();
Enemy enemy = enemyType.Pool.New();
enemy.Activate();
enemy.Position = this.Player.Position - new Vector2(64, 64);
this.AddChild(enemy);
}
/// <summary>
/// Called in order to get an Enemy ready for battle
/// </summary>
/// <param name="type">What type of enemy will this be (Stored in EnemyType enum)</param>
/// <param name="winSize">Size of the window to determine spawn locations</param>
/// <param name="wave">What wave is the game currently on?</param>
public void setUpEnemy(EnemyType type, int wave, Vector2 winSize)
{
halfWindowSize = winSize;
dir = Random.Range(0, 4);
//Spawn Direction is which way the enemy will move on spawn if simple
//If Spawn Direction is North, spawn below the map with a random x location
if(dir == (int)SpawnDirection.North)
{
transform.position = new Vector2(Random.Range(-halfWindowSize.x - 0.25f, halfWindowSize.x - 0.25f), Random.Range(-7.0f, -6.0f));
}//If Spawn Direction is South, spawn above the map with a random x location
else if (dir == (int)SpawnDirection.South)
{
transform.position = new Vector2(Random.Range(-halfWindowSize.x + 0.25f, halfWindowSize.x - 0.25f), Random.Range(6.0f, 7.0f));
}//If Spawn Direction is East, spawn left of the map with a random y location
if (dir == (int)SpawnDirection.East)
{
transform.position = new Vector2(Random.Range(-halfWindowSize.x - 2, -halfWindowSize.x - 1), Random.Range(-halfWindowSize.y + 0.1f, halfWindowSize.y - 0.1f));
}//If Spawn Direction is West, spawn right of the map with a random y location
else if (dir == (int)SpawnDirection.West)
{
transform.position = new Vector2(Random.Range(halfWindowSize.x + 1, halfWindowSize.x + 2), Random.Range(-halfWindowSize.y + 0.1f, halfWindowSize.y - 0.1f));
}
//Set a random movement speed based on the current wave
movementSpeed = Random.Range(1.0f, 4.0f + (wave * 0.5f));
//Set enemy type specific variables and begin coroutines
if (type == EnemyType.Simple)
{
spriteRenderer.color = Color.red;
StartCoroutine(simpleEnemyUpdate());
}
else if(type == EnemyType.Sin)
{
spriteRenderer.color = Color.green;
//extrainfo for Sin enemy = amplitude and frequency of sinusoidal movement
extraInfo.x = Random.Range(2.0f, 4.0f + (wave * 0.25f));
extraInfo.y = Random.Range(1.0f, 4.0f + (wave * 0.25f));
//timer for Sin enemy = position in sine wave
timer = 0;
StartCoroutine(sinEnemyUpdate());
}
else if(type == EnemyType.Traveler)
{
spriteRenderer.color = Color.yellow;
//extraInfo for Traveler enemy = a random location on the map to move to
extraInfo = new Vector2(Random.Range(-halfWindowSize.x, halfWindowSize.x), Random.Range(-halfWindowSize.y, halfWindowSize.y));
//timer for Traveler enemy = how long the enemy will stay alive
timer = Random.Range(3.0f, 5.0f + (wave * 0.5f));
StartCoroutine(travelerEnemyUpdate());
}
else if (type == EnemyType.Chaser)
{
movementSpeed = Random.Range(0.5f, 2.5f);
spriteRenderer.color = Color.magenta;
//timer for Traveler enemy = how long the enemy will stay alive
timer = Random.Range(5.0f, 8.0f + (wave * 0.4f));
StartCoroutine(chaserEnemyUpdate());
}
}
public Enemy(EnemyType type, Point point, Random random)
{
Type = type;
_point = point;
_random = random;
if (type == EnemyType.Silver || type == EnemyType.Gold)
Life = 2;
}
public Enemy(EnemyType eType, Texture2D texture, EnemyColor eColor)
{
type = eType;
color = eColor;
sprite = texture;
getStatsForType(type);
base.Initialize();
}
public List<AIAction> AIActionList { get; set; } //updates every turn
public AIActor(GameCharacter character, EnemyType type)
{
this.character = character;
this.enemyType = type;
InitActionWeight();
}
public void Init( EnemyType a_type , bool a_bWalkIn , Vector3 a_v3NavTarget)
{
type = a_type;
bCanControl = !a_bWalkIn;
if(!bCanControl)
nav.SetDestination( a_v3NavTarget );
}
protected Enemy(EnemyType type, Position pos, long lifeTime, int maxDimensionOfMovement, int damageAmount = 20)
{
this.pos = pos;
this.type = type;
this.maxDimensionOfMovement = maxDimensionOfMovement;
deathTime = System.DateTime.Now.AddMilliseconds(lifeTime);
this.damageAmount = damageAmount;
}
public void startBattle( EnemyType type )
{
/* start startBattle */
if (type == EnemyType.NULL)
mBattle.startBattle();
else
mBattle.startBattle(type);
}
// Constructor
public Enemy(float _x, float _y, float _endX, float _endY, float _depth, float _speed,
EnemyType _type, string _name)
: base(_x, _y, _depth, _name)
{
endX = _endX;
endY = _endY;
speed = _speed;
type = _type;
}
// void Update () {
// if (animInAction) {
// if (endTime > Time.time) {
// if (newPos.x < maxX) {
// newPos.x += .01f;
// }
// } else {
// newPos.x = initX;
// animInAction = false;
// setSprite();
// }
// trans.localPosition = newPos;
// }
// }
public void initEnemy (EnemyType type) {
this.enemyType = enemyType;
damage = enemyType.getStrength();
health = enemyType.getHealth();
armor = enemyType.getArmor();
dexterity = enemyType.getDexterity();
setSprite(true);
gameObject.SetActive(true);
}
public bool EliteSpawn(EnemyType eType, int spawnNum, int index)
{
bool bElite = false;
switch (eType)
{
case EnemyType.E_ZOMBIE:
if (spawnNum < 5)
{
bElite = Math.RandomRate(5);
}
else
{
if (index % 5 == 4)
{
bElite = true;
}
else
{
bElite = false;
}
}
break;
case EnemyType.E_NURSE:
if (spawnNum < 4)
{
bElite = Math.RandomRate(10);
}
else
{
if (index % 4 == 3)
{
bElite = true;
}
else
{
bElite = false;
}
}
break;
case EnemyType.E_BOOMER:
bElite = Math.RandomRate(10);
break;
case EnemyType.E_SWAT:
bElite = Math.RandomRate(15);
break;
case EnemyType.E_HUNTER:
if (GameApp.GetInstance().GetGameState().LevelNum > 15)
{
bElite = Math.RandomRate(30);
}
break;
case EnemyType.E_TANK:
if (GameApp.GetInstance().GetGameState().LevelNum > 20)
{
bElite = Math.RandomRate(50);
}
break;
}
return(bElite);
}
public static Enemy MakeEntity(int id, int hp, int positionX, int positionY, EnemyType enemy)
{
Enemy entity = new Enemy(id, hp, positionX, positionY);
return(entity);
}
//public GUISkin guiSkin;
// Use this for initialization
IEnumerator Start()
{
yield return(0);
spawnSpeed = 2 - waveNum * 0.1f;
timeBetweenWaves = 1.0f;
gameScene = GameApp.GetInstance().GetGameScene();
GameApp.GetInstance().GetGameScene().ArenaTrigger = this;
doors = GameObject.FindGameObjectsWithTag("Door");
doorCount = doors.Length;
waveStartTime = Time.time;
player = GameApp.GetInstance().GetGameScene().GetPlayer();
paramXML = new GameParametersXML();
if (Application.isEditor || Application.platform == RuntimePlatform.IPhonePlayer)
{
spawnConfigInfo = paramXML.Load(null, GameApp.GetInstance().GetGameState().LevelNum);
}
else
{
spawnConfigInfo = paramXML.Load("/", GameApp.GetInstance().GetGameState().LevelNum);
}
int limit = GameApp.GetInstance().GetGameConfig().globalConf.enemyLimit;
waveNum = 0;
int startWaveNum = GameApp.GetInstance().GetGameState().LevelNum;
int roundNum = 0;
gameScene.ArenaTrigger = this;
Debug.Log("wave num:" + spawnConfigInfo.Waves.Count);
foreach (Wave wave in spawnConfigInfo.Waves)
{
int enemyLeft = GameApp.GetInstance().GetGameScene().GetEnemies().Count;
while (enemyLeft > 0 && Time.time - waveStartTime < Constant.MAX_WAVE_TIME)
{
yield return(0);
enemyLeft = GameApp.GetInstance().GetGameScene().GetEnemies().Count;
}
waveNum++;
waveStartTime = Time.time;
gameScene.CalculateDifficultyFactor(GameApp.GetInstance().GetGameState().LevelNum);
Debug.Log("Wave " + waveNum);
GameApp.GetInstance().GetGameScene().BonusWeapon = null;
GameApp.GetInstance().DebugInfo = "";
//GameApp.GetInstance().GetGameScene().RefreshWoodBoxes();
yield return(new WaitForSeconds(wave.intermission));
foreach (Round round in wave.Rounds)
{
roundNum++;
Debug.Log("Round " + roundNum);
yield return(new WaitForSeconds(round.intermission));
foreach (EnemyInfo enemyInfo in round.EnemyInfos)
{
EnemyType enemyType = enemyInfo.EType;
//Debug.Log("Spawn " + enemyInfo.Count + " " + enemyType + " from " + enemyInfo.From);
int spawnNum = enemyInfo.Count;
SpawnFromType from = enemyInfo.From;
GameObject enemyPrefab = null;// GameApp.GetInstance().GetResourceConfig().enemy[(int)enemyType];
Transform grave = null;
if (from == SpawnFromType.Grave)
{
grave = CalculateGravePosition(player.GetTransform());
}
for (int i = 0; i < spawnNum; i++)
{
bool bElite = false;
bElite = EliteSpawn(enemyType, spawnNum, i);
if (bElite)
{
enemyPrefab = GameApp.GetInstance().GetResourceConfig().enemy_elite[(int)enemyType];
}
else
{
enemyPrefab = GameApp.GetInstance().GetResourceConfig().enemy[(int)enemyType];
}
enemyLeft = GameApp.GetInstance().GetGameScene().GetEnemies().Count;
while (enemyLeft >= limit)
{
yield return(0);
enemyLeft = GameApp.GetInstance().GetGameScene().GetEnemies().Count;
}
Vector3 spawnPosition = Vector3.zero;
if (from == SpawnFromType.Door)
{
spawnPosition = doors[currentDoorIndex].transform.position;
currentDoorIndex++;
if (currentDoorIndex == doorCount)
{
currentDoorIndex = 0;
}
}
else if (from == SpawnFromType.Grave)
{
float rndX = Random.Range(-grave.localScale.x / 2, grave.localScale.x / 2);
float rndZ = Random.Range(-grave.localScale.z / 2, grave.localScale.z / 2);
spawnPosition = grave.position + new Vector3(rndX, 0f, rndZ);
GameObject.Instantiate(GameApp.GetInstance().GetResourceConfig().graveRock, spawnPosition + Vector3.down * 0.3f, Quaternion.identity);
}
GameObject currentEnemy = null;
if (bElite)
{
currentEnemy = (GameObject)Instantiate(enemyPrefab, spawnPosition, Quaternion.Euler(0, 0, 0));
}
else
{
currentEnemy = gameScene.GetEnemyPool(enemyType).CreateObject(spawnPosition, Quaternion.Euler(0, 0, 0));
currentEnemy.layer = PhysicsLayer.ENEMY;
}
int enemyID = GameApp.GetInstance().GetGameScene().GetNextEnemyID();
currentEnemy.name = ConstData.ENEMY_NAME + enemyID.ToString();
Enemy enemy = null;
switch ((int)enemyType)
{
case 0: enemy = new Zombie();
break;
case 1: enemy = new Nurse();
break;
case 2: enemy = new Tank();
currentEnemy.transform.Translate(Vector3.up * 2);
break;
case 3:
enemy = new Hunter();
break;
case 4:
enemy = new Boomer();
break;
case 5:
enemy = new Swat();
break;
}
enemy.IsElite = bElite;
enemy.Init(currentEnemy);
enemy.EnemyType = enemyType;
//enemy.Spawn = this;
enemy.Name = currentEnemy.name;
if (from == SpawnFromType.Grave)
{
enemy.SetInGrave(true);
}
GameApp.GetInstance().GetGameScene().GetEnemies().Add(currentEnemy.name, enemy);
yield return(new WaitForSeconds(0.3f));
}
}
}
}
int enemyCount = GameApp.GetInstance().GetGameScene().GetEnemies().Count;
while (enemyCount > 0)
{
enemyCount = GameApp.GetInstance().GetGameScene().GetEnemies().Count;
yield return(0);
}
//Scene Ends
GameApp.GetInstance().GetGameScene().PlayingState = PlayingState.GameWin;
List <Weapon> weaponList = GameApp.GetInstance().GetGameState().GetWeapons();
GameConfig gConfig = GameApp.GetInstance().GetGameConfig();
WeaponConfig wConf = gConfig.GetUnLockWeapon(GameApp.GetInstance().GetGameState().LevelNum);
if (wConf != null)
{
foreach (Weapon w in weaponList)
{
//No duplicated weapons
if (w.Name == wConf.name)
{
if (w.Exist == WeaponExistState.Locked)
{
w.Exist = WeaponExistState.Unlocked;
GameApp.GetInstance().GetGameScene().BonusWeapon = w;
break;
}
}
}
}
else
{
GameApp.GetInstance().GetGameScene().BonusWeapon = null;
}
GameApp.GetInstance().GetGameState().Achievement.CheckAchievemnet_Survivior(GameApp.GetInstance().GetGameState().LevelNum);
GameApp.GetInstance().GetGameState().Achievement.CheckAchievemnet_LastSurvivior(GameApp.GetInstance().GetGameState().LevelNum);
GameApp.GetInstance().GetGameState().Achievement.SubmitScore(GameApp.GetInstance().GetGameState().LevelNum);
GameApp.GetInstance().GetGameState().LevelNum++;
/*
* AvatarType aType = (AvatarType)Mathf.Clamp((GameApp.GetInstance().GetGameState().LevelNum - 1)/5, 0, GameApp.GetInstance().GetGameState().GetAvatarNum() - 1);
*
* if (GameApp.GetInstance().GetGameState().GetAvatarData(aType) == AvatarState.NotAvaliable)
* {
* GameApp.GetInstance().GetGameState().EnableAvatar(aType);
* }
*/
//GameApp.GetInstance().GetGameState().AddScore(1000);
GameApp.GetInstance().Save();
yield return(new WaitForSeconds(4.0f));
if (gameScene.BonusWeapon != null)
{
GameUIScript.GetGameUIScript().ClearLevelInfo();
GameUIScript.GetGameUIScript().GetPanel(GameUIName.NEW_ITEM).Show();
yield return(new WaitForSeconds(4.0f));
}
FadeAnimationScript.GetInstance().StartFade(new Color(0, 0, 0, 0.0f), new Color(0, 0, 0, 1), 1.0f);
yield return(new WaitForSeconds(1.5f));
UIResourceMgr.GetInstance().UnloadAllUIMaterials();
Application.LoadLevel(SceneName.MAP);
}
public bool IsHero(EnemyType type)
{
return(((int)type + 1) % 5 == 0);
}
// Update is called once per frame
void Update()
{
//Debug.Log(GameManager.StateManager.gameState.enemies1.Count);
if (!deathSource)
{
deathSource = gameObject.AddComponent <AudioSource>();
deathSource.outputAudioMixerGroup = mixerGroup;
deathSource.clip = enemyDeath;
deathSource.loop = false;
//dieSource.Play();
}
if (!fireSource)
{
fireSource = gameObject.AddComponent <AudioSource>();
fireSource.outputAudioMixerGroup = mixerGroup;
fireSource.clip = fire;
fireSource.loop = false;
}
if (!hitSource)
{
hitSource = gameObject.AddComponent <AudioSource>();
hitSource.outputAudioMixerGroup = mixerGroup;
hitSource.clip = enemyHit;
hitSource.loop = false;
}
if (alive)
{
if (target && enemyType == EnemyType.Patrol && patrolType == PatrolType.DistanceBased)
{
//Debug.Log(Vector3.Distance(transform.position, target.transform.position));
Debug.DrawLine(transform.position, target.transform.position, Color.red);
//if((transform.position - target.transform.position).magnitude < distanceToNextNode)
if (agent.remainingDistance < distanceToNextNode)
{
if (path.Length > 0)
{
pathIndex++;
pathIndex %= path.Length;
if (pathIndex >= path.Length)
{
pathIndex = 0;
}
target = path[pathIndex];
}
}
}
if (Vector3.Distance(transform.position, GameManager.instance.playerInstance.transform.position) <= chaseDist)
{
enemyType = EnemyType.Chase;
target = GameObject.FindWithTag("Player");
}
else
{
enemyType = EnemyType.Patrol;
target = path[pathIndex];
}
if (Vector3.Distance(transform.position, GameManager.instance.playerInstance.transform.position) <= attackDist && !fired)
{
co = StartCoroutine(DelayFire());
fired = true;
}
SetTarget();
if (target)
{
agent.SetDestination(target.transform.position);
}
}
else
{
agent.velocity = Vector3.zero;
if (co != null)
{
StopCoroutine(co);
}
}
anim.SetFloat("Speed", transform.InverseTransformDirection(agent.velocity).z);
}
EnemyType UpgradeEnemy(EnemyType type)
{
return(type);
}
void Fire()
{
if (!canShoot)
{
return;
}
if (loadedBullets <= 0)
{
// When Ammo is out, make fire is not working for a moment
StartCoroutine(DisableFire());
soundManager.Play(drySound);
canShoot = false;
StartCoroutine(CoResetShootable());
return;
}
RaycastHit hit;
for (int i = 0; i < pellets; i++)
{
if (Physics.Raycast(shootPoint.position, CalculateSpread(spread, shootPoint), out hit, range))
{
HealthManager health = hit.transform.GetComponent <HealthManager>();
if (hit.transform.tag == "Player")
{
CreateRicochet(hit.point, hit.normal);
}
else if (health)
{
bool wasDead = health.IsDead;
health.ApplyDamage(GetWeaponDamage());
if (!wasDead && health.IsDead)
{
KillReward killReward;
// Check it was head
if (health.referer)
{
killReward = health.referer.transform.GetComponent <KillReward>();
}
else
{
killReward = hit.transform.GetComponent <KillReward>();
}
if (killReward)
{
int exp = killReward.exp;
int fund = killReward.fund;
int playerCount = PhotonNetwork.playerList.Length;
float bonusExp = exp * 0.3f;
float bonusFund = fund * 0.4f;
exp += ((int)bonusExp * (playerCount - 1));
fund += ((int)bonusFund * (playerCount - 1));
levelSystem.GiveExp(exp);
fundSystem.AddFund(fund);
GameObject[] players = GameObject.FindGameObjectsWithTag("Player");
foreach (GameObject player in players)
{
if (player == gameObject.transform.root.gameObject)
{
continue;
}
player.GetComponent <FundSystem>().AddBonus((int)bonusExp, (int)bonusFund);
}
rewardText.Show(exp, fund);
// Update player status
string weaponName = transform.name;
switch (weaponName)
{
case "Glock":
playerStatus.killsGlock++;
break;
case "MP5K":
playerStatus.killsMp5k++;
break;
case "UMP45":
playerStatus.killsUmp45++;
break;
case "Python":
playerStatus.killsPython++;
break;
case "M870":
playerStatus.killsM870++;
break;
case "AKM":
playerStatus.killsAkm++;
break;
}
playerStatus.totalKills++;
}
}
EnemyType enemyType = hit.transform.GetComponent <EnemyType>();
if (enemyType)
{
if (enemyType.type == HitType.BIO)
{
CreateBlood(hit.point, hit.transform.rotation);
}
}
else
{
CreateRicochet(hit.point, hit.normal);
}
}
else
{
CreateRicochet(hit.point, hit.normal);
CreateBulletHole(hit.point, hit.normal, hit.transform);
}
}
}
if (hasLastFire && loadedBullets <= 1)
{
animator.CrossFadeInFixedTime("FPSHand|FireLast", 0.01f);
}
else
{
animator.CrossFadeInFixedTime("FPSHand|Fire", 0.01f);
}
networkPlayer.FireWeapon();
GameObject gunSmokeEffect = Instantiate(gunSmoke, muzzlePoint.position, muzzlePoint.rotation);
Destroy(gunSmokeEffect, 5f);
GiveRecoil();
muzzleflash.Play();
soundManager.Play(gunFireSound);
loadedBullets--;
UpdateAmmoText();
canShoot = false;
StartCoroutine(CoResetShootable());
}
public void OnChangeEnemyType(EnemyType type)
{
_selectedEnemyPrefab = type;
}
public override void OnEnemyCreate(EnemyType enemyType)
{
base.OnEnemyCreate(enemyType);
}
public bool IsEnemyType(EnemyType enemyType)
{
return(this.enemyType == enemyType);
}
public static EnemyType RandomEnemy()
{
EnemyType type = Enemies.allEnemyTypes[Random.Range(0, Enemies.allEnemyTypes.Count)];
return(type);
}
public SingleEnemySpawnData(EnemyType enemyType, float spawnTiming, int spawnPointId)
{
_enemyType = enemyType;
_spawnTiming = spawnTiming;
_spawnPointId = spawnPointId;
}
private void AddEnemy(Wave wave)
{
enemyType = (EnemyType)selectedType;
specialAbility = (EnemySpecialAbility)selectedAbility;
wave.enemies.Add(new Enemy(enemyType, specialAbility));
}
private void CreatePointEvent(String state, float pos, float time)
{
//To prevent enemies at position 0 from being removed
if (pos == 0)
{
pos = 1;
}
//
String enemyData = state.Substring(0, 1);
String movementData = state.Substring(1, 2);
String eventData = state.Substring(3, 1);
SortedDictionary <string, int> settings = new SortedDictionary <string, int>();
MatchCollection matches = Regex.Matches(state, @"([XYWHD])(\d+)");
foreach (Match match in matches)
{
String letter = match.Groups[1].Value;
String valueString = match.Groups[2].Value;
int value = Convert.ToInt32(valueString);
settings.Add(letter, value);
}
//String enemy = SaveLoadStringLibrary.GetEnemyTypeFromSaveString(enemyData);
String enemy = enemyData;
EnemyType identifier = DataConversionLibrary.GetEnemyEnumFromString(enemy);
Movement movement = DataConversionLibrary.GetMovementEnumFromString(movementData);
#region switchEventData
switch (eventData)
{
case "0":
{
LevelEvent lvEv = new SingleEnemy(Game, player, spriteSheet, this, identifier, time, pos);
SetMovement(lvEv, movement);
untriggeredEvents.Add(lvEv);
break;
}
// The horizontal event forces a horizontal movement
case "h":
{
int direction = settings["D"];
int yPos = settings["Y"];
LevelEvent lvEv = new SingleHorizontalEnemy(Game, player, spriteSheet, this, identifier, time, direction, yPos);
if (direction == 1)
{
SetMovement(lvEv, Movement.RightHorizontal);
}
else
{
SetMovement(lvEv, Movement.LeftHorizontal);
}
untriggeredEvents.Add(lvEv);
break;
}
case "l":
{
int width = settings["W"];
int xspacing = settings["X"];
LevelEvent lvEv = new LineFormation(Game, player, spriteSheet, this, identifier, time, width, xspacing, pos);
SetMovement(lvEv, movement);
untriggeredEvents.Add(lvEv);
break;
}
case "s":
{
int width = settings["W"];
int xspacing = settings["X"];
int height = settings["H"];
int yspacing = settings["Y"];
LevelEvent lvEv = new SquareFormation(Game, player, spriteSheet, this, identifier, time, width, height, xspacing, yspacing, pos);
SetMovement(lvEv, movement);
untriggeredEvents.Add(lvEv);
break;
}
case "t":
{
int height = settings["H"];
int xspacing = settings["X"];
int yspacing = settings["Y"];
LevelEvent lvEv = new VFormation(Game, player, spriteSheet, this, identifier, time, height, xspacing, yspacing, pos);
SetMovement(lvEv, movement);
untriggeredEvents.Add(lvEv);
break;
}
}
#endregion
}
public NormalStageHandler(int mLv, int mCountToFinish, StageSystem mStageSystem, EnemyType mEnemyType, WeaponType mWeaponType, int mCount, Vector3 mPosition) : base(mLv, mCountToFinish, mStageSystem)
{
this.mEnemyType = mEnemyType;
this.mWeaponType = mWeaponType;
this.mCount = mCount;
this.mPosition = mPosition;
mSpawnTimer = mSpawnTime;
}
public Ranged(GameObject gameObject, int health, float movementSpeed, float attackRate, float attackRange, EnemyType enemyType, BulletType bulletType, int spread
) : base(gameObject, health, movementSpeed, attackRate, attackRange, enemyType)
{
this.bulletType = bulletType;
this.attackRange = attackRange;
this.spread = spread;
}
public abstract EnemyBase GetEnemy(EnemyType enemyType);
public Enemy(EnemyType enemyType) : base(600, 10)
{
this.enemyType = enemyType;
cardManager = new EnemyCardManager();
hasPutSpecial = false;
}
// Constructor
public Enemy(int level, int damage, int health, int speed, int attackPriority, int attackSpeed, int attackRange, int detectRange, EnemyType currentEnemyType)
{
// this.x = x;
// this.y = y;
this.damage = damage;
// this.health = health;
this.health = health;
this.level = level;
this.speed = speed;
this.currentEnemyType = currentEnemyType;
this.attackPriority = attackPriority;
this.attackSpeed = attackSpeed;
this.attackRange = attackRange;
this.detectRange = detectRange;
//this.cooldown = 0;
//this.targetTower = targetTower;
}
public void SetUnitType(EnemyType _unitType)
{
mUnitType = _unitType;
}
public void Init(EnemyType type)
{
this.type = type;
}
public Enemy(int attack, int defence, int health, EnemyType enemyType, int gold)
: base(attack, defence, health)
{
this.EnemyType = enemyType;
this.Gold = gold;
}
public void SetDisplay(EnemyType newState)
{
ActiveData.enemyState = newState;
}
public void ReturnInstance(EnemyType type, GameObject obj)
{
obj.SetActive(false);
obj.transform.SetParent(_root);
_memberObjects[type].Enqueue(obj);
}
private void OnEnemyKilled(EnemyType enemyType, bool afterRecochet)
{
View.OnEnemyKilled(enemyType, afterRecochet);
}
public NormalStageHandler(StageSystem stageSystem, int level, int countToFinished, EnemyType enemyType, WeaponType weaponType, int enemyCount, Vector3 spawnPosition) : base(stageSystem, level, countToFinished)
{
mEnemyType = enemyType;
mWeaponType = weaponType;
mEnemyCount = enemyCount;
mSpawnPosition = spawnPosition;
mSpawnTimer = mSpawnTime;
}
public void setDeadEnemyType(EnemyType enemyType)
{
LastDeadEnemyType = enemyType;
}
// Deal damage to player
public void DealDamage(Enemy enemy)
{
// The partial damages
int damageFromEnemy = 0, damageFromSpeed = 0, totalDamage;
// Get the enemy type
EnemyType enemyType = enemy.Type;
// Get the speed category
SpeedClassification speedCategory = enemy.SpeedCategory;
// Determine damage if player is holding a sword
if (weapon == PlayerWeapon.Sword)
{
// Determine damage due to enemy type
if (enemyType == EnemyType.Demon)
{
damageFromEnemy = 2;
}
else if (enemyType == EnemyType.Dragon)
{
damageFromEnemy = 5;
}
// Determine damage due to enemy speed
if (speedCategory == SpeedClassification.Slow)
{
damageFromSpeed = 8;
}
else if (speedCategory == SpeedClassification.Normal)
{
damageFromSpeed = 4;
}
else if (speedCategory == SpeedClassification.Fast)
{
damageFromSpeed = 2;
}
}
// Determine damage if player is holding a bow
else if (weapon == PlayerWeapon.Bow)
{
// Determine damage due to enemy type
if (enemyType == EnemyType.Demon)
{
damageFromEnemy = 4;
}
else if (enemyType == EnemyType.Dragon)
{
damageFromEnemy = 3;
}
// Determine damage due to enemy speed
if (speedCategory == SpeedClassification.Slow)
{
damageFromSpeed = 1;
}
else if (speedCategory == SpeedClassification.Normal)
{
damageFromSpeed = 3;
}
else if (speedCategory == SpeedClassification.Fast)
{
damageFromSpeed = 7;
}
}
// Determine total damage player will take
totalDamage = damageFromEnemy * damageFromSpeed;
// Update UI with damage taken by player
uiMessages.text = $"+{totalDamage} damage from "
+ $"{speedCategory.ToString()} {enemyType.ToString()}";
// Update total player damage
SetDamage(damage + totalDamage);
// Is the player being controlled by the AI?
if (!IsAI)
{
// If the game is not being played by the AI, pass the player's
// choice to the AI so it can learn
nbClassifier.Update(
weapon.ToString(),
new Dictionary <Attrib, string>()
{
{ enemyTypeAttrib, enemyType.ToString() },
{ speedAttrib, speedCategory.ToString() }
}
);
// Update the number of AI observations and the respective text
// widget
aiObservations++;
uiAi.text = $"AI Observations = {aiObservations}";
}
}
public EnemyPoolWave(EnemyType enemyType, int amount, float delay)
{
EnemyType = enemyType;
Amount = amount;
Delay = delay;
}
public static EnemyPiece Spawn(int _posX, int _posY, int _health, GridType _movementType, EnemyType _unitType)
{
EnemyPiece curPiece = null;
for (int i = 0; i < enemyPool.Count; i++)
{
if (enemyPool[i].IsAlive == false)
{
curPiece = enemyPool[i];
curPiece.mbIsAlive = true;
curPiece.mSpriteRen.enabled = true;
curPiece.mnPosX = _posX;
curPiece.mnPosY = _posY;
curPiece.mnHealth = _health;
curPiece.SetMovementType(_movementType);
curPiece.SetUnitType(_unitType);
int spriteIndex = Array.IndexOf(enemySpriteNames, _unitType.ToString() + "_" + _movementType.ToString());
curPiece.mSpriteRen.sprite = enemySprites[spriteIndex];
DungeonManager.Instance.PlaceEnemy(curPiece, _posX, _posY);
curPiece.transform.position = DungeonManager.Instance.GridPosToWorldPos(_posX, _posY);
break;
}
}
if (curPiece == null)
{
GameObject newEnemyPiece = (GameObject)Instantiate(GameManager.Instance.EnemyPrefab);
curPiece = newEnemyPiece.GetComponent <EnemyPiece>();
curPiece.mbIsAlive = true;
curPiece.mSpriteRen.enabled = true;
curPiece.mnPosX = _posX;
curPiece.mnPosY = _posY;
curPiece.mnHealth = _health;
curPiece.SetMovementType(_movementType);
curPiece.SetUnitType(_unitType);
int spriteIndex = Array.IndexOf(enemySpriteNames, _unitType.ToString() + "_" + _movementType.ToString());
curPiece.mSpriteRen.sprite = enemySprites[spriteIndex];
DungeonManager.Instance.PlaceEnemy(curPiece, _posX, _posY);
curPiece.transform.position = DungeonManager.Instance.GridPosToWorldPos(_posX, _posY);
}
GameManager.Instance.EnemyList.Add(curPiece);
return(curPiece);
}
